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

/******/ (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 = 357);

/******/ })

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

/******/ ({

/***/ 0:

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

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

/***/ }),

/***/ 1:

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

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

/***/ }),

/***/ 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);

}

/***/ }),

/***/ 111:

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

"use strict";

var __extends = (this && this.__extends) || (function () {

    var extendStatics = Object.setPrototypeOf ||

        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||

        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };

    return function (d, b) {

        extendStatics(d, b);

        function __() { this.constructor = d; }

        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());

    };

})();

var __assign = (this && this.__assign) || Object.assign || function(t) {

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

        s = arguments[i];

        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))

            t[p] = s[p];

    }

    return t;

};

var __rest = (this && this.__rest) || function (s, e) {

    var t = {};

    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)

        t[p] = s[p];

    if (s != null && typeof Object.getOwnPropertySymbols === "function")

        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)

            t[p[i]] = s[p[i]];

    return t;

};

exports.__esModule = true;

var React = __webpack_require__(27);

var PropTypes = __webpack_require__(31);

var autosize = __webpack_require__(112);

var _getLineHeight = __webpack_require__(113);

var getLineHeight = _getLineHeight;

var UPDATE = 'autosize:update';

var DESTROY = 'autosize:destroy';

var RESIZED = 'autosize:resized';

/**

 * A light replacement for built-in textarea component

 * which automaticaly adjusts its height to match the content

 */

var TextareaAutosize = /** @class */ (function (_super) {

    __extends(TextareaAutosize, _super);

    function TextareaAutosize() {

        var _this = _super !== null && _super.apply(this, arguments) || this;

        _this.state = {

            lineHeight: null

        };

        _this.dispatchEvent = function (EVENT_TYPE) {

            var event = document.createEvent('Event');

            event.initEvent(EVENT_TYPE, true, false);

            _this.textarea.dispatchEvent(event);

        };

        _this.updateLineHeight = function () {

            _this.setState({

                lineHeight: getLineHeight(_this.textarea)

            });

        };

        _this.onChange = function (e) {

            var onChange = _this.props.onChange;

            _this.currentValue = e.currentTarget.value;

            onChange && onChange(e);

        };

        _this.saveDOMNodeRef = function (ref) {

            var innerRef = _this.props.innerRef;

            if (innerRef) {

                innerRef(ref);

            }

            _this.textarea = ref;

        };

        _this.getLocals = function () {

            var _a = _this, _b = _a.props, onResize = _b.onResize, maxRows = _b.maxRows, onChange = _b.onChange, style = _b.style, innerRef = _b.innerRef, props = __rest(_b, ["onResize", "maxRows", "onChange", "style", "innerRef"]), lineHeight = _a.state.lineHeight, saveDOMNodeRef = _a.saveDOMNodeRef;

            var maxHeight = maxRows && lineHeight ? lineHeight * maxRows : null;

            return __assign({}, props, { saveDOMNodeRef: saveDOMNodeRef, style: maxHeight ? __assign({}, style, { maxHeight: maxHeight }) : style, onChange: _this.onChange });

        };

        return _this;

    }

    TextareaAutosize.prototype.componentDidMount = function () {

        var _this = this;

        var _a = this.props, onResize = _a.onResize, maxRows = _a.maxRows;

        if (typeof maxRows === 'number') {

            this.updateLineHeight();

        }

        /*

          the defer is needed to:

            - force "autosize" to activate the scrollbar when this.props.maxRows is passed

            - support StyledComponents (see #71)

        */

        setTimeout(function () { return autosize(_this.textarea); });

        if (onResize) {

            this.textarea.addEventListener(RESIZED, onResize);

        }

    };

    TextareaAutosize.prototype.componentWillUnmount = function () {

        var onResize = this.props.onResize;

        if (onResize) {

            this.textarea.removeEventListener(RESIZED, onResize);

        }

        this.dispatchEvent(DESTROY);

    };

    TextareaAutosize.prototype.render = function () {

        var _a = this.getLocals(), children = _a.children, saveDOMNodeRef = _a.saveDOMNodeRef, locals = __rest(_a, ["children", "saveDOMNodeRef"]);

        return (React.createElement("textarea", __assign({}, locals, { ref: saveDOMNodeRef }), children));

    };

    TextareaAutosize.prototype.componentDidUpdate = function (prevProps) {

        if (this.props.value !== this.currentValue || this.props.rows !== prevProps.rows) {

            this.dispatchEvent(UPDATE);

        }

    };

    TextareaAutosize.defaultProps = {

        rows: 1

    };

    TextareaAutosize.propTypes = {

        rows: PropTypes.number,

        maxRows: PropTypes.number,

        onResize: PropTypes.func,

        innerRef: PropTypes.func

    };

    return TextareaAutosize;

}(React.Component));

exports["default"] = TextareaAutosize;

/***/ }),

/***/ 112:

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

var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!

	autosize 4.0.2

	license: MIT

	http://www.jacklmoore.com/autosize

*/

(function (global, factory) {

	if (true) {

		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [module, exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),

				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?

				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),

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

	} else { var mod; }

})(this, function (module, exports) {

	'use strict';

	var map = typeof Map === "function" ? new Map() : function () {

		var keys = [];

		var values = [];

		return {

			has: function has(key) {

				return keys.indexOf(key) > -1;

			},

			get: function get(key) {

				return values[keys.indexOf(key)];

			},

			set: function set(key, value) {

				if (keys.indexOf(key) === -1) {

					keys.push(key);

					values.push(value);

				}

			},

			delete: function _delete(key) {

				var index = keys.indexOf(key);

				if (index > -1) {

					keys.splice(index, 1);

					values.splice(index, 1);

				}

			}

		};

	}();

	var createEvent = function createEvent(name) {

		return new Event(name, { bubbles: true });

	};

	try {

		new Event('test');

	} catch (e) {

		// IE does not support `new Event()`

		createEvent = function createEvent(name) {

			var evt = document.createEvent('Event');

			evt.initEvent(name, true, false);

			return evt;

		};

	}

	function assign(ta) {

		if (!ta || !ta.nodeName || ta.nodeName !== 'TEXTAREA' || map.has(ta)) return;

		var heightOffset = null;

		var clientWidth = null;

		var cachedHeight = null;

		function init() {

			var style = window.getComputedStyle(ta, null);

			if (style.resize === 'vertical') {

				ta.style.resize = 'none';

			} else if (style.resize === 'both') {

				ta.style.resize = 'horizontal';

			}

			if (style.boxSizing === 'content-box') {

				heightOffset = -(parseFloat(style.paddingTop) + parseFloat(style.paddingBottom));

			} else {

				heightOffset = parseFloat(style.borderTopWidth) + parseFloat(style.borderBottomWidth);

			}

			// Fix when a textarea is not on document body and heightOffset is Not a Number

			if (isNaN(heightOffset)) {

				heightOffset = 0;

			}

			update();

		}

		function changeOverflow(value) {

			{

				// Chrome/Safari-specific fix:

				// When the textarea y-overflow is hidden, Chrome/Safari do not reflow the text to account for the space

				// made available by removing the scrollbar. The following forces the necessary text reflow.

				var width = ta.style.width;

				ta.style.width = '0px';

				// Force reflow:

				/* jshint ignore:start */

				ta.offsetWidth;

				/* jshint ignore:end */

				ta.style.width = width;

			}

			ta.style.overflowY = value;

		}

		function getParentOverflows(el) {

			var arr = [];

			while (el && el.parentNode && el.parentNode instanceof Element) {

				if (el.parentNode.scrollTop) {

					arr.push({

						node: el.parentNode,

						scrollTop: el.parentNode.scrollTop

					});

				}

				el = el.parentNode;

			}

			return arr;

		}

		function resize() {

			if (ta.scrollHeight === 0) {

				// If the scrollHeight is 0, then the element probably has display:none or is detached from the DOM.

				return;

			}

			var overflows = getParentOverflows(ta);

			var docTop = document.documentElement && document.documentElement.scrollTop; // Needed for Mobile IE (ticket #240)

			ta.style.height = '';

			ta.style.height = ta.scrollHeight + heightOffset + 'px';

			// used to check if an update is actually necessary on window.resize

			clientWidth = ta.clientWidth;

			// prevents scroll-position jumping

			overflows.forEach(function (el) {

				el.node.scrollTop = el.scrollTop;

			});

			if (docTop) {

				document.documentElement.scrollTop = docTop;

			}

		}

		function update() {

			resize();

			var styleHeight = Math.round(parseFloat(ta.style.height));

			var computed = window.getComputedStyle(ta, null);

			// Using offsetHeight as a replacement for computed.height in IE, because IE does not account use of border-box

			var actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(computed.height)) : ta.offsetHeight;

			// The actual height not matching the style height (set via the resize method) indicates that 

			// the max-height has been exceeded, in which case the overflow should be allowed.

			if (actualHeight < styleHeight) {

				if (computed.overflowY === 'hidden') {

					changeOverflow('scroll');

					resize();

					actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;

				}

			} else {

				// Normally keep overflow set to hidden, to avoid flash of scrollbar as the textarea expands.

				if (computed.overflowY !== 'hidden') {

					changeOverflow('hidden');

					resize();

					actualHeight = computed.boxSizing === 'content-box' ? Math.round(parseFloat(window.getComputedStyle(ta, null).height)) : ta.offsetHeight;

				}

			}

			if (cachedHeight !== actualHeight) {

				cachedHeight = actualHeight;

				var evt = createEvent('autosize:resized');

				try {

					ta.dispatchEvent(evt);

				} catch (err) {

					// Firefox will throw an error on dispatchEvent for a detached element

					// https://bugzilla.mozilla.org/show_bug.cgi?id=889376

				}

			}

		}

		var pageResize = function pageResize() {

			if (ta.clientWidth !== clientWidth) {

				update();

			}

		};

		var destroy = function (style) {

			window.removeEventListener('resize', pageResize, false);

			ta.removeEventListener('input', update, false);

			ta.removeEventListener('keyup', update, false);

			ta.removeEventListener('autosize:destroy', destroy, false);

			ta.removeEventListener('autosize:update', update, false);

			Object.keys(style).forEach(function (key) {

				ta.style[key] = style[key];

			});

			map.delete(ta);

		}.bind(ta, {

			height: ta.style.height,

			resize: ta.style.resize,

			overflowY: ta.style.overflowY,

			overflowX: ta.style.overflowX,

			wordWrap: ta.style.wordWrap

		});

		ta.addEventListener('autosize:destroy', destroy, false);

		// IE9 does not fire onpropertychange or oninput for deletions,

		// so binding to onkeyup to catch most of those events.

		// There is no way that I know of to detect something like 'cut' in IE9.

		if ('onpropertychange' in ta && 'oninput' in ta) {

			ta.addEventListener('keyup', update, false);

		}

		window.addEventListener('resize', pageResize, false);

		ta.addEventListener('input', update, false);

		ta.addEventListener('autosize:update', update, false);

		ta.style.overflowX = 'hidden';

		ta.style.wordWrap = 'break-word';

		map.set(ta, {

			destroy: destroy,

			update: update

		});

		init();

	}

	function destroy(ta) {

		var methods = map.get(ta);

		if (methods) {

			methods.destroy();

		}

	}

	function update(ta) {

		var methods = map.get(ta);

		if (methods) {

			methods.update();

		}

	}

	var autosize = null;

	// Do nothing in Node.js environment and IE8 (or lower)

	if (typeof window === 'undefined' || typeof window.getComputedStyle !== 'function') {

		autosize = function autosize(el) {

			return el;

		};

		autosize.destroy = function (el) {

			return el;

		};

		autosize.update = function (el) {

			return el;

		};

	} else {

		autosize = function autosize(el, options) {

			if (el) {

				Array.prototype.forEach.call(el.length ? el : [el], function (x) {

					return assign(x, options);