this["wp"] = this["wp"] || {}; this["wp"]["blockLibrary"] =

/******/ (function(modules) { // webpackBootstrap

/******/ 	// The module cache

/******/ 	var installedModules = {};

/******/

/******/ 	// The require function

/******/ 	function __webpack_require__(moduleId) {

/******/

/******/ 		// Check if module is in cache

/******/ 		if(installedModules[moduleId]) {

/******/ 			return installedModules[moduleId].exports;

/******/ 		}

/******/ 		// Create a new module (and put it into the cache)

/******/ 		var module = installedModules[moduleId] = {

/******/ 			i: moduleId,

/******/ 			l: false,

/******/ 			exports: {}

/******/ 		};

/******/

/******/ 		// Execute the module function

/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/

/******/ 		// Flag the module as loaded

/******/ 		module.l = true;

/******/

/******/ 		// Return the exports of the module

/******/ 		return module.exports;

/******/ 	}

/******/

/******/

/******/ 	// expose the modules object (__webpack_modules__)

/******/ 	__webpack_require__.m = modules;

/******/

/******/ 	// expose the module cache

/******/ 	__webpack_require__.c = installedModules;

/******/

/******/ 	// define getter function for harmony exports

/******/ 	__webpack_require__.d = function(exports, name, getter) {

/******/ 		if(!__webpack_require__.o(exports, name)) {

/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });

/******/ 		}

/******/ 	};

/******/

/******/ 	// define __esModule on exports

/******/ 	__webpack_require__.r = function(exports) {

/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {

/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });

/******/ 		}

/******/ 		Object.defineProperty(exports, '__esModule', { value: true });

/******/ 	};

/******/

/******/ 	// create a fake namespace object

/******/ 	// mode & 1: value is a module id, require it

/******/ 	// mode & 2: merge all properties of value into the ns

/******/ 	// mode & 4: return value when already ns object

/******/ 	// mode & 8|1: behave like require

/******/ 	__webpack_require__.t = function(value, mode) {

/******/ 		if(mode & 1) value = __webpack_require__(value);

/******/ 		if(mode & 8) return value;

/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;

/******/ 		var ns = Object.create(null);

/******/ 		__webpack_require__.r(ns);

/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });

/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));

/******/ 		return ns;

/******/ 	};

/******/

/******/ 	// getDefaultExport function for compatibility with non-harmony modules

/******/ 	__webpack_require__.n = function(module) {

/******/ 		var getter = module && module.__esModule ?

/******/ 			function getDefault() { return module['default']; } :

/******/ 			function getModuleExports() { return module; };

/******/ 		__webpack_require__.d(getter, 'a', getter);

/******/ 		return getter;

/******/ 	};

/******/

/******/ 	// Object.prototype.hasOwnProperty.call

/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

/******/

/******/ 	// __webpack_public_path__

/******/ 	__webpack_require__.p = "";

/******/

/******/

/******/ 	// Load entry module and return exports

/******/ 	return __webpack_require__(__webpack_require__.s = 256);

/******/ })

/************************************************************************/

/******/ ([

/* 0 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["element"]; }());

/***/ }),

/* 1 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["i18n"]; }());

/***/ }),

/* 2 */

/***/ (function(module, exports) {

(function() { module.exports = this["lodash"]; }());

/***/ }),

/* 3 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _assertThisInitialized; });

function _assertThisInitialized(self) {

  if (self === void 0) {

    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");

  }

  return self;

}

/***/ }),

/* 4 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["components"]; }());

/***/ }),

/* 5 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["data"]; }());

/***/ }),

/* 6 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["compose"]; }());

/***/ }),

/* 7 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectSpread; });

/* harmony import */ var _defineProperty__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15);

function _objectSpread(target) {

  for (var i = 1; i < arguments.length; i++) {

    var source = arguments[i] != null ? arguments[i] : {};

    var ownKeys = Object.keys(source);

    if (typeof Object.getOwnPropertySymbols === 'function') {

      ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {

        return Object.getOwnPropertyDescriptor(source, sym).enumerable;

      }));

    }

    ownKeys.forEach(function (key) {

      Object(_defineProperty__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(target, key, source[key]);

    });

  }

  return target;

}

/***/ }),

/* 8 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["blockEditor"]; }());

/***/ }),

/* 9 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _createClass; });

function _defineProperties(target, props) {

  for (var i = 0; i < props.length; i++) {

    var descriptor = props[i];

    descriptor.enumerable = descriptor.enumerable || false;

    descriptor.configurable = true;

    if ("value" in descriptor) descriptor.writable = true;

    Object.defineProperty(target, descriptor.key, descriptor);

  }

}

function _createClass(Constructor, protoProps, staticProps) {

  if (protoProps) _defineProperties(Constructor.prototype, protoProps);

  if (staticProps) _defineProperties(Constructor, staticProps);

  return Constructor;

}

/***/ }),

/* 10 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _classCallCheck; });

function _classCallCheck(instance, Constructor) {

  if (!(instance instanceof Constructor)) {

    throw new TypeError("Cannot call a class as a function");

  }

}

/***/ }),

/* 11 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; });

/* harmony import */ var _helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(32);

/* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3);

function _possibleConstructorReturn(self, call) {

  if (call && (Object(_helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__[/* default */ "a"])(call) === "object" || typeof call === "function")) {

    return call;

  }

  return Object(_assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__[/* default */ "a"])(self);

}

/***/ }),

/* 12 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _getPrototypeOf; });

function _getPrototypeOf(o) {

  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {

    return o.__proto__ || Object.getPrototypeOf(o);

  };

  return _getPrototypeOf(o);

}

/***/ }),

/* 13 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js

function _setPrototypeOf(o, p) {

  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {

    o.__proto__ = p;

    return o;

  };

  return _setPrototypeOf(o, p);

}

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _inherits; });

function _inherits(subClass, superClass) {

  if (typeof superClass !== "function" && superClass !== null) {

    throw new TypeError("Super expression must either be null or a function");

  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {

    constructor: {

      value: subClass,

      writable: true,

      configurable: true

    }

  });

  if (superClass) _setPrototypeOf(subClass, superClass);

}

/***/ }),

/* 14 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["blocks"]; }());

/***/ }),

/* 15 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _defineProperty; });

function _defineProperty(obj, key, value) {

  if (key in obj) {

    Object.defineProperty(obj, key, {

      value: value,

      enumerable: true,

      configurable: true,

      writable: true

    });

  } else {

    obj[key] = value;

  }

  return obj;

}

/***/ }),

/* 16 */

/***/ (function(module, exports, __webpack_require__) {

var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!

  Copyright (c) 2017 Jed Watson.

  Licensed under the MIT License (MIT), see

  http://jedwatson.github.io/classnames

*/

/* global define */

(function () {

	'use strict';

	var hasOwn = {}.hasOwnProperty;

	function classNames () {

		var classes = [];

		for (var i = 0; i < arguments.length; i++) {

			var arg = arguments[i];

			if (!arg) continue;

			var argType = typeof arg;

			if (argType === 'string' || argType === 'number') {

				classes.push(arg);

			} else if (Array.isArray(arg) && arg.length) {

				var inner = classNames.apply(null, arg);

				if (inner) {

					classes.push(inner);

				}

			} else if (argType === 'object') {

				for (var key in arg) {

					if (hasOwn.call(arg, key) && arg[key]) {

						classes.push(key);

					}

				}

			}

		}

		return classes.join(' ');

	}

	if ( true && module.exports) {

		classNames.default = classNames;

		module.exports = classNames;

	} else if (true) {

		// register as 'classnames', consistent with npm package name

		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {

			return classNames;

		}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),

				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));

	} else {}

}());

/***/ }),

/* 17 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js

function _arrayWithoutHoles(arr) {

  if (Array.isArray(arr)) {

    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {

      arr2[i] = arr[i];

    }

    return arr2;

  }

}

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArray.js

var iterableToArray = __webpack_require__(34);

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js

function _nonIterableSpread() {

  throw new TypeError("Invalid attempt to spread non-iterable instance");

}

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _toConsumableArray; });

function _toConsumableArray(arr) {

  return _arrayWithoutHoles(arr) || Object(iterableToArray["a" /* default */])(arr) || _nonIterableSpread();

}

/***/ }),

/* 18 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["keycodes"]; }());

/***/ }),

/* 19 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; });

function _extends() {

  _extends = Object.assign || function (target) {

    for (var i = 1; i < arguments.length; i++) {

      var source = arguments[i];

      for (var key in source) {

        if (Object.prototype.hasOwnProperty.call(source, key)) {

          target[key] = source[key];

        }

      }

    }

    return target;

  };

  return _extends.apply(this, arguments);

}

/***/ }),

/* 20 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["richText"]; }());

/***/ }),

/* 21 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js

function _objectWithoutPropertiesLoose(source, excluded) {

  if (source == null) return {};

  var target = {};

  var sourceKeys = Object.keys(source);

  var key, i;

  for (i = 0; i < sourceKeys.length; i++) {

    key = sourceKeys[i];

    if (excluded.indexOf(key) >= 0) continue;

    target[key] = source[key];

  }

  return target;

}

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutProperties; });

function _objectWithoutProperties(source, excluded) {

  if (source == null) return {};

  var target = _objectWithoutPropertiesLoose(source, excluded);

  var key, i;

  if (Object.getOwnPropertySymbols) {

    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

    for (i = 0; i < sourceSymbolKeys.length; i++) {

      key = sourceSymbolKeys[i];

      if (excluded.indexOf(key) >= 0) continue;

      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;

      target[key] = source[key];

    }

  }

  return target;

}

/***/ }),

/* 22 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["editor"]; }());

/***/ }),

/* 23 */,

/* 24 */,

/* 25 */

/***/ (function(module, exports) {

(function() { module.exports = this["wp"]["url"]; }());

/***/ }),

/* 26 */,

/* 27 */,

/* 28 */

/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js

var arrayWithHoles = __webpack_require__(37);

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js

function _iterableToArrayLimit(arr, i) {

  var _arr = [];

  var _n = true;

  var _d = false;

  var _e = undefined;

  try {

    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {

      _arr.push(_s.value);

      if (i && _arr.length === i) break;

    }

  } catch (err) {

    _d = true;

    _e = err;

  } finally {

    try {

      if (!_n && _i["return"] != null) _i["return"]();

    } finally {

      if (_d) throw _e;

    }

  }

  return _arr;

}

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js

var nonIterableRest = __webpack_require__(38);

// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js

/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _slicedToArray; });

function _slicedToArray(arr, i) {

  return Object(arrayWithHoles["a" /* default */])(arr) || _iterableToArrayLimit(arr, i) || Object(nonIterableRest["a" /* default */])();

}

/***/ }),

/* 29 */

/***/ (function(module, exports) {