diff -r c7c34916027a -r 177826044cd9 wp/wp-includes/js/dist/editor.js --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wp/wp-includes/js/dist/editor.js Mon Oct 14 18:28:13 2019 +0200 @@ -0,0 +1,17367 @@ +this["wp"] = this["wp"] || {}; this["wp"]["editor"] = +/******/ (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 = 358); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 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"); + } +} + +/***/ }), + +/***/ 109: +/***/ (function(module, exports) { + +if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + ctor.super_ = superCtor + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); + }; +} else { + // old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } +} + + +/***/ }), + +/***/ 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); + }); + } + return el; + }; + autosize.destroy = function (el) { + if (el) { + Array.prototype.forEach.call(el.length ? el : [el], destroy); + } + return el; + }; + autosize.update = function (el) { + if (el) { + Array.prototype.forEach.call(el.length ? el : [el], update); + } + return el; + }; + } + + exports.default = autosize; + module.exports = exports['default']; +}); + +/***/ }), + +/***/ 113: +/***/ (function(module, exports, __webpack_require__) { + +// Load in dependencies +var computedStyle = __webpack_require__(114); + +/** + * Calculate the `line-height` of a given node + * @param {HTMLElement} node Element to calculate line height of. Must be in the DOM. + * @returns {Number} `line-height` of the element in pixels + */ +function lineHeight(node) { + // Grab the line-height via style + var lnHeightStr = computedStyle(node, 'line-height'); + var lnHeight = parseFloat(lnHeightStr, 10); + + // If the lineHeight did not contain a unit (i.e. it was numeric), convert it to ems (e.g. '2.3' === '2.3em') + if (lnHeightStr === lnHeight + '') { + // Save the old lineHeight style and update the em unit to the element + var _lnHeightStyle = node.style.lineHeight; + node.style.lineHeight = lnHeightStr + 'em'; + + // Calculate the em based height + lnHeightStr = computedStyle(node, 'line-height'); + lnHeight = parseFloat(lnHeightStr, 10); + + // Revert the lineHeight style + if (_lnHeightStyle) { + node.style.lineHeight = _lnHeightStyle; + } else { + delete node.style.lineHeight; + } + } + + // If the lineHeight is in `pt`, convert it to pixels (4px for 3pt) + // DEV: `em` units are converted to `pt` in IE6 + // Conversion ratio from https://developer.mozilla.org/en-US/docs/Web/CSS/length + if (lnHeightStr.indexOf('pt') !== -1) { + lnHeight *= 4; + lnHeight /= 3; + // Otherwise, if the lineHeight is in `mm`, convert it to pixels (96px for 25.4mm) + } else if (lnHeightStr.indexOf('mm') !== -1) { + lnHeight *= 96; + lnHeight /= 25.4; + // Otherwise, if the lineHeight is in `cm`, convert it to pixels (96px for 2.54cm) + } else if (lnHeightStr.indexOf('cm') !== -1) { + lnHeight *= 96; + lnHeight /= 2.54; + // Otherwise, if the lineHeight is in `in`, convert it to pixels (96px for 1in) + } else if (lnHeightStr.indexOf('in') !== -1) { + lnHeight *= 96; + // Otherwise, if the lineHeight is in `pc`, convert it to pixels (12pt for 1pc) + } else if (lnHeightStr.indexOf('pc') !== -1) { + lnHeight *= 16; + } + + // Continue our computation + lnHeight = Math.round(lnHeight); + + // If the line-height is "normal", calculate by font-size + if (lnHeightStr === 'normal') { + // Create a temporary node + var nodeName = node.nodeName; + var _node = document.createElement(nodeName); + _node.innerHTML = ' '; + + // If we have a text area, reset it to only 1 row + // https://github.com/twolfson/line-height/issues/4 + if (nodeName.toUpperCase() === 'TEXTAREA') { + _node.setAttribute('rows', '1'); + } + + // Set the font-size of the element + var fontSizeStr = computedStyle(node, 'font-size'); + _node.style.fontSize = fontSizeStr; + + // Remove default padding/border which can affect offset height + // https://github.com/twolfson/line-height/issues/4 + // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetHeight + _node.style.padding = '0px'; + _node.style.border = '0px'; + + // Append it to the body + var body = document.body; + body.appendChild(_node); + + // Assume the line height of the element is the height + var height = _node.offsetHeight; + lnHeight = height; + + // Remove our child from the DOM + body.removeChild(_node); + } + + // Return the calculated height + return lnHeight; +} + +// Export lineHeight +module.exports = lineHeight; + + +/***/ }), + +/***/ 114: +/***/ (function(module, exports) { + +// This code has been refactored for 140 bytes +// You can see the original here: https://github.com/twolfson/computedStyle/blob/04cd1da2e30fa45844f95f5cb1ac898e9b9ef050/lib/computedStyle.js +var computedStyle = function (el, prop, getComputedStyle) { + getComputedStyle = window.getComputedStyle; + + // In one fell swoop + return ( + // If we have getComputedStyle + getComputedStyle ? + // Query it + // TODO: From CSS-Query notes, we might need (node, null) for FF + getComputedStyle(el) : + + // Otherwise, we are in IE and use currentStyle + el.currentStyle + )[ + // Switch to camelCase for CSSOM + // DEV: Grabbed from jQuery + // https://github.com/jquery/jquery/blob/1.9-stable/src/css.js#L191-L194 + // https://github.com/jquery/jquery/blob/1.9-stable/src/core.js#L593-L597 + prop.replace(/-(\w)/gi, function (word, letter) { + return letter.toUpperCase(); + }) + ]; +}; + +module.exports = computedStyle; + + +/***/ }), + +/***/ 117: +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(module, global) {var __WEBPACK_AMD_DEFINE_RESULT__;/*! https://mths.be/punycode v1.4.1 by @mathias */ +;(function(root) { + + /** Detect free variables */ + var freeExports = true && exports && + !exports.nodeType && exports; + var freeModule = true && module && + !module.nodeType && module; + var freeGlobal = typeof global == 'object' && global; + if ( + freeGlobal.global === freeGlobal || + freeGlobal.window === freeGlobal || + freeGlobal.self === freeGlobal + ) { + root = freeGlobal; + } + + /** + * The `punycode` object. + * @name punycode + * @type Object + */ + var punycode, + + /** Highest positive signed 32-bit float value */ + maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1 + + /** Bootstring parameters */ + base = 36, + tMin = 1, + tMax = 26, + skew = 38, + damp = 700, + initialBias = 72, + initialN = 128, // 0x80 + delimiter = '-', // '\x2D' + + /** Regular expressions */ + regexPunycode = /^xn--/, + regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars + regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators + + /** Error messages */ + errors = { + 'overflow': 'Overflow: input needs wider integers to process', + 'not-basic': 'Illegal input >= 0x80 (not a basic code point)', + 'invalid-input': 'Invalid input' + }, + + /** Convenience shortcuts */ + baseMinusTMin = base - tMin, + floor = Math.floor, + stringFromCharCode = String.fromCharCode, + + /** Temporary variable */ + key; + + /*--------------------------------------------------------------------------*/ + + /** + * A generic error utility function. + * @private + * @param {String} type The error type. + * @returns {Error} Throws a `RangeError` with the applicable error message. + */ + function error(type) { + throw new RangeError(errors[type]); + } + + /** + * A generic `Array#map` utility function. + * @private + * @param {Array} array The array to iterate over. + * @param {Function} callback The function that gets called for every array + * item. + * @returns {Array} A new array of values returned by the callback function. + */ + function map(array, fn) { + var length = array.length; + var result = []; + while (length--) { + result[length] = fn(array[length]); + } + return result; + } + + /** + * A simple `Array#map`-like wrapper to work with domain name strings or email + * addresses. + * @private + * @param {String} domain The domain name or email address. + * @param {Function} callback The function that gets called for every + * character. + * @returns {Array} A new string of characters returned by the callback + * function. + */ + function mapDomain(string, fn) { + var parts = string.split('@'); + var result = ''; + if (parts.length > 1) { + // In email addresses, only the domain name should be punycoded. Leave + // the local part (i.e. everything up to `@`) intact. + result = parts[0] + '@'; + string = parts[1]; + } + // Avoid `split(regex)` for IE8 compatibility. See #17. + string = string.replace(regexSeparators, '\x2E'); + var labels = string.split('.'); + var encoded = map(labels, fn).join('.'); + return result + encoded; + } + + /** + * Creates an array containing the numeric code points of each Unicode + * character in the string. While JavaScript uses UCS-2 internally, + * this function will convert a pair of surrogate halves (each of which + * UCS-2 exposes as separate characters) into a single code point, + * matching UTF-16. + * @see `punycode.ucs2.encode` + * @see + * @memberOf punycode.ucs2 + * @name decode + * @param {String} string The Unicode input string (UCS-2). + * @returns {Array} The new array of code points. + */ + function ucs2decode(string) { + var output = [], + counter = 0, + length = string.length, + value, + extra; + while (counter < length) { + value = string.charCodeAt(counter++); + if (value >= 0xD800 && value <= 0xDBFF && counter < length) { + // high surrogate, and there is a next character + extra = string.charCodeAt(counter++); + if ((extra & 0xFC00) == 0xDC00) { // low surrogate + output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000); + } else { + // unmatched surrogate; only append this code unit, in case the next + // code unit is the high surrogate of a surrogate pair + output.push(value); + counter--; + } + } else { + output.push(value); + } + } + return output; + } + + /** + * Creates a string based on an array of numeric code points. + * @see `punycode.ucs2.decode` + * @memberOf punycode.ucs2 + * @name encode + * @param {Array} codePoints The array of numeric code points. + * @returns {String} The new Unicode string (UCS-2). + */ + function ucs2encode(array) { + return map(array, function(value) { + var output = ''; + if (value > 0xFFFF) { + value -= 0x10000; + output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800); + value = 0xDC00 | value & 0x3FF; + } + output += stringFromCharCode(value); + return output; + }).join(''); + } + + /** + * Converts a basic code point into a digit/integer. + * @see `digitToBasic()` + * @private + * @param {Number} codePoint The basic numeric code point value. + * @returns {Number} The numeric value of a basic code point (for use in + * representing integers) in the range `0` to `base - 1`, or `base` if + * the code point does not represent a value. + */ + function basicToDigit(codePoint) { + if (codePoint - 48 < 10) { + return codePoint - 22; + } + if (codePoint - 65 < 26) { + return codePoint - 65; + } + if (codePoint - 97 < 26) { + return codePoint - 97; + } + return base; + } + + /** + * Converts a digit/integer into a basic code point. + * @see `basicToDigit()` + * @private + * @param {Number} digit The numeric value of a basic code point. + * @returns {Number} The basic code point whose value (when used for + * representing integers) is `digit`, which needs to be in the range + * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is + * used; else, the lowercase form is used. The behavior is undefined + * if `flag` is non-zero and `digit` has no uppercase form. + */ + function digitToBasic(digit, flag) { + // 0..25 map to ASCII a..z or A..Z + // 26..35 map to ASCII 0..9 + return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5); + } + + /** + * Bias adaptation function as per section 3.4 of RFC 3492. + * https://tools.ietf.org/html/rfc3492#section-3.4 + * @private + */ + function adapt(delta, numPoints, firstTime) { + var k = 0; + delta = firstTime ? floor(delta / damp) : delta >> 1; + delta += floor(delta / numPoints); + for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) { + delta = floor(delta / baseMinusTMin); + } + return floor(k + (baseMinusTMin + 1) * delta / (delta + skew)); + } + + /** + * Converts a Punycode string of ASCII-only symbols to a string of Unicode + * symbols. + * @memberOf punycode + * @param {String} input The Punycode string of ASCII-only symbols. + * @returns {String} The resulting string of Unicode symbols. + */ + function decode(input) { + // Don't use UCS-2 + var output = [], + inputLength = input.length, + out, + i = 0, + n = initialN, + bias = initialBias, + basic, + j, + index, + oldi, + w, + k, + digit, + t, + /** Cached calculation results */ + baseMinusT; + + // Handle the basic code points: let `basic` be the number of input code + // points before the last delimiter, or `0` if there is none, then copy + // the first basic code points to the output. + + basic = input.lastIndexOf(delimiter); + if (basic < 0) { + basic = 0; + } + + for (j = 0; j < basic; ++j) { + // if it's not a basic code point + if (input.charCodeAt(j) >= 0x80) { + error('not-basic'); + } + output.push(input.charCodeAt(j)); + } + + // Main decoding loop: start just after the last delimiter if any basic code + // points were copied; start at the beginning otherwise. + + for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) { + + // `index` is the index of the next character to be consumed. + // Decode a generalized variable-length integer into `delta`, + // which gets added to `i`. The overflow checking is easier + // if we increase `i` as we go, then subtract off its starting + // value at the end to obtain `delta`. + for (oldi = i, w = 1, k = base; /* no condition */; k += base) { + + if (index >= inputLength) { + error('invalid-input'); + } + + digit = basicToDigit(input.charCodeAt(index++)); + + if (digit >= base || digit > floor((maxInt - i) / w)) { + error('overflow'); + } + + i += digit * w; + t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + + if (digit < t) { + break; + } + + baseMinusT = base - t; + if (w > floor(maxInt / baseMinusT)) { + error('overflow'); + } + + w *= baseMinusT; + + } + + out = output.length + 1; + bias = adapt(i - oldi, out, oldi == 0); + + // `i` was supposed to wrap around from `out` to `0`, + // incrementing `n` each time, so we'll fix that now: + if (floor(i / out) > maxInt - n) { + error('overflow'); + } + + n += floor(i / out); + i %= out; + + // Insert `n` at position `i` of the output + output.splice(i++, 0, n); + + } + + return ucs2encode(output); + } + + /** + * Converts a string of Unicode symbols (e.g. a domain name label) to a + * Punycode string of ASCII-only symbols. + * @memberOf punycode + * @param {String} input The string of Unicode symbols. + * @returns {String} The resulting Punycode string of ASCII-only symbols. + */ + function encode(input) { + var n, + delta, + handledCPCount, + basicLength, + bias, + j, + m, + q, + k, + t, + currentValue, + output = [], + /** `inputLength` will hold the number of code points in `input`. */ + inputLength, + /** Cached calculation results */ + handledCPCountPlusOne, + baseMinusT, + qMinusT; + + // Convert the input in UCS-2 to Unicode + input = ucs2decode(input); + + // Cache the length + inputLength = input.length; + + // Initialize the state + n = initialN; + delta = 0; + bias = initialBias; + + // Handle the basic code points + for (j = 0; j < inputLength; ++j) { + currentValue = input[j]; + if (currentValue < 0x80) { + output.push(stringFromCharCode(currentValue)); + } + } + + handledCPCount = basicLength = output.length; + + // `handledCPCount` is the number of code points that have been handled; + // `basicLength` is the number of basic code points. + + // Finish the basic string - if it is not empty - with a delimiter + if (basicLength) { + output.push(delimiter); + } + + // Main encoding loop: + while (handledCPCount < inputLength) { + + // All non-basic code points < n have been handled already. Find the next + // larger one: + for (m = maxInt, j = 0; j < inputLength; ++j) { + currentValue = input[j]; + if (currentValue >= n && currentValue < m) { + m = currentValue; + } + } + + // Increase `delta` enough to advance the decoder's state to , + // but guard against overflow + handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { + error('overflow'); + } + + delta += (m - n) * handledCPCountPlusOne; + n = m; + + for (j = 0; j < inputLength; ++j) { + currentValue = input[j]; + + if (currentValue < n && ++delta > maxInt) { + error('overflow'); + } + + if (currentValue == n) { + // Represent delta as a generalized variable-length integer + for (q = delta, k = base; /* no condition */; k += base) { + t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + if (q < t) { + break; + } + qMinusT = q - t; + baseMinusT = base - t; + output.push( + stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)) + ); + q = floor(qMinusT / baseMinusT); + } + + output.push(stringFromCharCode(digitToBasic(q, 0))); + bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); + delta = 0; + ++handledCPCount; + } + } + + ++delta; + ++n; + + } + return output.join(''); + } + + /** + * Converts a Punycode string representing a domain name or an email address + * to Unicode. Only the Punycoded parts of the input will be converted, i.e. + * it doesn't matter if you call it on a string that has already been + * converted to Unicode. + * @memberOf punycode + * @param {String} input The Punycoded domain name or email address to + * convert to Unicode. + * @returns {String} The Unicode representation of the given Punycode + * string. + */ + function toUnicode(input) { + return mapDomain(input, function(string) { + return regexPunycode.test(string) + ? decode(string.slice(4).toLowerCase()) + : string; + }); + } + + /** + * Converts a Unicode string representing a domain name or an email address to + * Punycode. Only the non-ASCII parts of the domain name will be converted, + * i.e. it doesn't matter if you call it with a domain that's already in + * ASCII. + * @memberOf punycode + * @param {String} input The domain name or email address to convert, as a + * Unicode string. + * @returns {String} The Punycode representation of the given domain name or + * email address. + */ + function toASCII(input) { + return mapDomain(input, function(string) { + return regexNonASCII.test(string) + ? 'xn--' + encode(string) + : string; + }); + } + + /*--------------------------------------------------------------------------*/ + + /** Define the public API */ + punycode = { + /** + * A string representing the current Punycode.js version number. + * @memberOf punycode + * @type String + */ + 'version': '1.4.1', + /** + * An object of methods to convert from JavaScript's internal character + * representation (UCS-2) to Unicode code points, and back. + * @see + * @memberOf punycode + * @type Object + */ + 'ucs2': { + 'decode': ucs2decode, + 'encode': ucs2encode + }, + 'decode': decode, + 'encode': encode, + 'toASCII': toASCII, + 'toUnicode': toUnicode + }; + + /** Expose `punycode` */ + // Some AMD build optimizers, like r.js, check for specific condition patterns + // like the following: + if ( + true + ) { + !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { + return punycode; + }).call(exports, __webpack_require__, exports, module), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); + } else {} + +}(this)); + +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(118)(module), __webpack_require__(59))) + +/***/ }), + +/***/ 118: +/***/ (function(module, exports) { + +module.exports = function(module) { + if (!module.webpackPolyfill) { + module.deprecate = function() {}; + module.paths = []; + // module.parent = undefined by default + if (!module.children) module.children = []; + Object.defineProperty(module, "loaded", { + enumerable: true, + get: function() { + return module.l; + } + }); + Object.defineProperty(module, "id", { + enumerable: true, + get: function() { + return module.i; + } + }); + module.webpackPolyfill = 1; + } + return module; +}; + + +/***/ }), + +/***/ 119: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = { + isString: function(arg) { + return typeof(arg) === 'string'; + }, + isObject: function(arg) { + return typeof(arg) === 'object' && arg !== null; + }, + isNull: function(arg) { + return arg === null; + }, + isNullOrUndefined: function(arg) { + return arg == null; + } +}; + + +/***/ }), + +/***/ 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); +} + +/***/ }), + +/***/ 120: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +exports.decode = exports.parse = __webpack_require__(121); +exports.encode = exports.stringify = __webpack_require__(122); + + +/***/ }), + +/***/ 121: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +// If obj.hasOwnProperty has been overridden, then calling +// obj.hasOwnProperty(prop) will break. +// See: https://github.com/joyent/node/issues/1707 +function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); +} + +module.exports = function(qs, sep, eq, options) { + sep = sep || '&'; + eq = eq || '='; + var obj = {}; + + if (typeof qs !== 'string' || qs.length === 0) { + return obj; + } + + var regexp = /\+/g; + qs = qs.split(sep); + + var maxKeys = 1000; + if (options && typeof options.maxKeys === 'number') { + maxKeys = options.maxKeys; + } + + var len = qs.length; + // maxKeys <= 0 means that we should not limit keys count + if (maxKeys > 0 && len > maxKeys) { + len = maxKeys; + } + + for (var i = 0; i < len; ++i) { + var x = qs[i].replace(regexp, '%20'), + idx = x.indexOf(eq), + kstr, vstr, k, v; + + if (idx >= 0) { + kstr = x.substr(0, idx); + vstr = x.substr(idx + 1); + } else { + kstr = x; + vstr = ''; + } + + k = decodeURIComponent(kstr); + v = decodeURIComponent(vstr); + + if (!hasOwnProperty(obj, k)) { + obj[k] = v; + } else if (isArray(obj[k])) { + obj[k].push(v); + } else { + obj[k] = [obj[k], v]; + } + } + + return obj; +}; + +var isArray = Array.isArray || function (xs) { + return Object.prototype.toString.call(xs) === '[object Array]'; +}; + + +/***/ }), + +/***/ 122: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +var stringifyPrimitive = function(v) { + switch (typeof v) { + case 'string': + return v; + + case 'boolean': + return v ? 'true' : 'false'; + + case 'number': + return isFinite(v) ? v : ''; + + default: + return ''; + } +}; + +module.exports = function(obj, sep, eq, name) { + sep = sep || '&'; + eq = eq || '='; + if (obj === null) { + obj = undefined; + } + + if (typeof obj === 'object') { + return map(objectKeys(obj), function(k) { + var ks = encodeURIComponent(stringifyPrimitive(k)) + eq; + if (isArray(obj[k])) { + return map(obj[k], function(v) { + return ks + encodeURIComponent(stringifyPrimitive(v)); + }).join(sep); + } else { + return ks + encodeURIComponent(stringifyPrimitive(obj[k])); + } + }).join(sep); + + } + + if (!name) return ''; + return encodeURIComponent(stringifyPrimitive(name)) + eq + + encodeURIComponent(stringifyPrimitive(obj)); +}; + +var isArray = Array.isArray || function (xs) { + return Object.prototype.toString.call(xs) === '[object Array]'; +}; + +function map (xs, f) { + if (xs.map) return xs.map(f); + var res = []; + for (var i = 0; i < xs.length; i++) { + res.push(f(xs[i], i)); + } + return res; +} + +var objectKeys = Object.keys || function (obj) { + var res = []; + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key); + } + return res; +}; + + +/***/ }), + +/***/ 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); +} + +/***/ }), + +/***/ 133: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["notices"]; }()); + +/***/ }), + +/***/ 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); +} + +/***/ }), + +/***/ 2: +/***/ (function(module, exports) { + +(function() { module.exports = this["lodash"]; }()); + +/***/ }), + +/***/ 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; +} + +/***/ }), + +/***/ 227: +/***/ (function(module, exports) { + +var traverse = module.exports = function (obj) { + return new Traverse(obj); +}; + +function Traverse (obj) { + this.value = obj; +} + +Traverse.prototype.get = function (ps) { + var node = this.value; + for (var i = 0; i < ps.length; i ++) { + var key = ps[i]; + if (!node || !hasOwnProperty.call(node, key)) { + node = undefined; + break; + } + node = node[key]; + } + return node; +}; + +Traverse.prototype.has = function (ps) { + var node = this.value; + for (var i = 0; i < ps.length; i ++) { + var key = ps[i]; + if (!node || !hasOwnProperty.call(node, key)) { + return false; + } + node = node[key]; + } + return true; +}; + +Traverse.prototype.set = function (ps, value) { + var node = this.value; + for (var i = 0; i < ps.length - 1; i ++) { + var key = ps[i]; + if (!hasOwnProperty.call(node, key)) node[key] = {}; + node = node[key]; + } + node[ps[i]] = value; + return value; +}; + +Traverse.prototype.map = function (cb) { + return walk(this.value, cb, true); +}; + +Traverse.prototype.forEach = function (cb) { + this.value = walk(this.value, cb, false); + return this.value; +}; + +Traverse.prototype.reduce = function (cb, init) { + var skip = arguments.length === 1; + var acc = skip ? this.value : init; + this.forEach(function (x) { + if (!this.isRoot || !skip) { + acc = cb.call(this, acc, x); + } + }); + return acc; +}; + +Traverse.prototype.paths = function () { + var acc = []; + this.forEach(function (x) { + acc.push(this.path); + }); + return acc; +}; + +Traverse.prototype.nodes = function () { + var acc = []; + this.forEach(function (x) { + acc.push(this.node); + }); + return acc; +}; + +Traverse.prototype.clone = function () { + var parents = [], nodes = []; + + return (function clone (src) { + for (var i = 0; i < parents.length; i++) { + if (parents[i] === src) { + return nodes[i]; + } + } + + if (typeof src === 'object' && src !== null) { + var dst = copy(src); + + parents.push(src); + nodes.push(dst); + + forEach(objectKeys(src), function (key) { + dst[key] = clone(src[key]); + }); + + parents.pop(); + nodes.pop(); + return dst; + } + else { + return src; + } + })(this.value); +}; + +function walk (root, cb, immutable) { + var path = []; + var parents = []; + var alive = true; + + return (function walker (node_) { + var node = immutable ? copy(node_) : node_; + var modifiers = {}; + + var keepGoing = true; + + var state = { + node : node, + node_ : node_, + path : [].concat(path), + parent : parents[parents.length - 1], + parents : parents, + key : path.slice(-1)[0], + isRoot : path.length === 0, + level : path.length, + circular : null, + update : function (x, stopHere) { + if (!state.isRoot) { + state.parent.node[state.key] = x; + } + state.node = x; + if (stopHere) keepGoing = false; + }, + 'delete' : function (stopHere) { + delete state.parent.node[state.key]; + if (stopHere) keepGoing = false; + }, + remove : function (stopHere) { + if (isArray(state.parent.node)) { + state.parent.node.splice(state.key, 1); + } + else { + delete state.parent.node[state.key]; + } + if (stopHere) keepGoing = false; + }, + keys : null, + before : function (f) { modifiers.before = f }, + after : function (f) { modifiers.after = f }, + pre : function (f) { modifiers.pre = f }, + post : function (f) { modifiers.post = f }, + stop : function () { alive = false }, + block : function () { keepGoing = false } + }; + + if (!alive) return state; + + function updateState() { + if (typeof state.node === 'object' && state.node !== null) { + if (!state.keys || state.node_ !== state.node) { + state.keys = objectKeys(state.node) + } + + state.isLeaf = state.keys.length == 0; + + for (var i = 0; i < parents.length; i++) { + if (parents[i].node_ === node_) { + state.circular = parents[i]; + break; + } + } + } + else { + state.isLeaf = true; + state.keys = null; + } + + state.notLeaf = !state.isLeaf; + state.notRoot = !state.isRoot; + } + + updateState(); + + // use return values to update if defined + var ret = cb.call(state, state.node); + if (ret !== undefined && state.update) state.update(ret); + + if (modifiers.before) modifiers.before.call(state, state.node); + + if (!keepGoing) return state; + + if (typeof state.node == 'object' + && state.node !== null && !state.circular) { + parents.push(state); + + updateState(); + + forEach(state.keys, function (key, i) { + path.push(key); + + if (modifiers.pre) modifiers.pre.call(state, state.node[key], key); + + var child = walker(state.node[key]); + if (immutable && hasOwnProperty.call(state.node, key)) { + state.node[key] = child.node; + } + + child.isLast = i == state.keys.length - 1; + child.isFirst = i == 0; + + if (modifiers.post) modifiers.post.call(state, child); + + path.pop(); + }); + parents.pop(); + } + + if (modifiers.after) modifiers.after.call(state, state.node); + + return state; + })(root).node; +} + +function copy (src) { + if (typeof src === 'object' && src !== null) { + var dst; + + if (isArray(src)) { + dst = []; + } + else if (isDate(src)) { + dst = new Date(src.getTime ? src.getTime() : src); + } + else if (isRegExp(src)) { + dst = new RegExp(src); + } + else if (isError(src)) { + dst = { message: src.message }; + } + else if (isBoolean(src)) { + dst = new Boolean(src); + } + else if (isNumber(src)) { + dst = new Number(src); + } + else if (isString(src)) { + dst = new String(src); + } + else if (Object.create && Object.getPrototypeOf) { + dst = Object.create(Object.getPrototypeOf(src)); + } + else if (src.constructor === Object) { + dst = {}; + } + else { + var proto = + (src.constructor && src.constructor.prototype) + || src.__proto__ + || {} + ; + var T = function () {}; + T.prototype = proto; + dst = new T; + } + + forEach(objectKeys(src), function (key) { + dst[key] = src[key]; + }); + return dst; + } + else return src; +} + +var objectKeys = Object.keys || function keys (obj) { + var res = []; + for (var key in obj) res.push(key) + return res; +}; + +function toS (obj) { return Object.prototype.toString.call(obj) } +function isDate (obj) { return toS(obj) === '[object Date]' } +function isRegExp (obj) { return toS(obj) === '[object RegExp]' } +function isError (obj) { return toS(obj) === '[object Error]' } +function isBoolean (obj) { return toS(obj) === '[object Boolean]' } +function isNumber (obj) { return toS(obj) === '[object Number]' } +function isString (obj) { return toS(obj) === '[object String]' } + +var isArray = Array.isArray || function isArray (xs) { + return Object.prototype.toString.call(xs) === '[object Array]'; +}; + +var forEach = function (xs, fn) { + if (xs.forEach) return xs.forEach(fn) + else for (var i = 0; i < xs.length; i++) { + fn(xs[i], i, xs); + } +}; + +forEach(objectKeys(Traverse.prototype), function (key) { + traverse[key] = function (obj) { + var args = [].slice.call(arguments, 1); + var t = new Traverse(obj); + return t[key].apply(t, args); + }; +}); + +var hasOwnProperty = Object.hasOwnProperty || function (obj, key) { + return key in obj; +}; + + +/***/ }), + +/***/ 23: +/***/ (function(module, exports, __webpack_require__) { + +module.exports = __webpack_require__(54); + + +/***/ }), + +/***/ 25: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["url"]; }()); + +/***/ }), + +/***/ 26: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["hooks"]; }()); + +/***/ }), + +/***/ 27: +/***/ (function(module, exports) { + +(function() { module.exports = this["React"]; }()); + +/***/ }), + +/***/ 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 */])(); +} + +/***/ }), + +/***/ 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; +} + +/***/ }), + +/***/ 30: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + + +var LEAF_KEY, hasWeakMap; + +/** + * Arbitrary value used as key for referencing cache object in WeakMap tree. + * + * @type {Object} + */ +LEAF_KEY = {}; + +/** + * Whether environment supports WeakMap. + * + * @type {boolean} + */ +hasWeakMap = typeof WeakMap !== 'undefined'; + +/** + * Returns the first argument as the sole entry in an array. + * + * @param {*} value Value to return. + * + * @return {Array} Value returned as entry in array. + */ +function arrayOf( value ) { + return [ value ]; +} + +/** + * Returns true if the value passed is object-like, or false otherwise. A value + * is object-like if it can support property assignment, e.g. object or array. + * + * @param {*} value Value to test. + * + * @return {boolean} Whether value is object-like. + */ +function isObjectLike( value ) { + return !! value && 'object' === typeof value; +} + +/** + * Creates and returns a new cache object. + * + * @return {Object} Cache object. + */ +function createCache() { + var cache = { + clear: function() { + cache.head = null; + }, + }; + + return cache; +} + +/** + * Returns true if entries within the two arrays are strictly equal by + * reference from a starting index. + * + * @param {Array} a First array. + * @param {Array} b Second array. + * @param {number} fromIndex Index from which to start comparison. + * + * @return {boolean} Whether arrays are shallowly equal. + */ +function isShallowEqual( a, b, fromIndex ) { + var i; + + if ( a.length !== b.length ) { + return false; + } + + for ( i = fromIndex; i < a.length; i++ ) { + if ( a[ i ] !== b[ i ] ) { + return false; + } + } + + return true; +} + +/** + * Returns a memoized selector function. The getDependants function argument is + * called before the memoized selector and is expected to return an immutable + * reference or array of references on which the selector depends for computing + * its own return value. The memoize cache is preserved only as long as those + * dependant references remain the same. If getDependants returns a different + * reference(s), the cache is cleared and the selector value regenerated. + * + * @param {Function} selector Selector function. + * @param {Function} getDependants Dependant getter returning an immutable + * reference or array of reference used in + * cache bust consideration. + * + * @return {Function} Memoized selector. + */ +/* harmony default export */ __webpack_exports__["a"] = (function( selector, getDependants ) { + var rootCache, getCache; + + // Use object source as dependant if getter not provided + if ( ! getDependants ) { + getDependants = arrayOf; + } + + /** + * Returns the root cache. If WeakMap is supported, this is assigned to the + * root WeakMap cache set, otherwise it is a shared instance of the default + * cache object. + * + * @return {(WeakMap|Object)} Root cache object. + */ + function getRootCache() { + return rootCache; + } + + /** + * Returns the cache for a given dependants array. When possible, a WeakMap + * will be used to create a unique cache for each set of dependants. This + * is feasible due to the nature of WeakMap in allowing garbage collection + * to occur on entries where the key object is no longer referenced. Since + * WeakMap requires the key to be an object, this is only possible when the + * dependant is object-like. The root cache is created as a hierarchy where + * each top-level key is the first entry in a dependants set, the value a + * WeakMap where each key is the next dependant, and so on. This continues + * so long as the dependants are object-like. If no dependants are object- + * like, then the cache is shared across all invocations. + * + * @see isObjectLike + * + * @param {Array} dependants Selector dependants. + * + * @return {Object} Cache object. + */ + function getWeakMapCache( dependants ) { + var caches = rootCache, + isUniqueByDependants = true, + i, dependant, map, cache; + + for ( i = 0; i < dependants.length; i++ ) { + dependant = dependants[ i ]; + + // Can only compose WeakMap from object-like key. + if ( ! isObjectLike( dependant ) ) { + isUniqueByDependants = false; + break; + } + + // Does current segment of cache already have a WeakMap? + if ( caches.has( dependant ) ) { + // Traverse into nested WeakMap. + caches = caches.get( dependant ); + } else { + // Create, set, and traverse into a new one. + map = new WeakMap(); + caches.set( dependant, map ); + caches = map; + } + } + + // We use an arbitrary (but consistent) object as key for the last item + // in the WeakMap to serve as our running cache. + if ( ! caches.has( LEAF_KEY ) ) { + cache = createCache(); + cache.isUniqueByDependants = isUniqueByDependants; + caches.set( LEAF_KEY, cache ); + } + + return caches.get( LEAF_KEY ); + } + + // Assign cache handler by availability of WeakMap + getCache = hasWeakMap ? getWeakMapCache : getRootCache; + + /** + * Resets root memoization cache. + */ + function clear() { + rootCache = hasWeakMap ? new WeakMap() : createCache(); + } + + // eslint-disable-next-line jsdoc/check-param-names + /** + * The augmented selector call, considering first whether dependants have + * changed before passing it to underlying memoize function. + * + * @param {Object} source Source object for derivation. + * @param {...*} extraArgs Additional arguments to pass to selector. + * + * @return {*} Selector result. + */ + function callSelector( /* source, ...extraArgs */ ) { + var len = arguments.length, + cache, node, i, args, dependants; + + // Create copy of arguments (avoid leaking deoptimization). + args = new Array( len ); + for ( i = 0; i < len; i++ ) { + args[ i ] = arguments[ i ]; + } + + dependants = getDependants.apply( null, args ); + cache = getCache( dependants ); + + // If not guaranteed uniqueness by dependants (primitive type or lack + // of WeakMap support), shallow compare against last dependants and, if + // references have changed, destroy cache to recalculate result. + if ( ! cache.isUniqueByDependants ) { + if ( cache.lastDependants && ! isShallowEqual( dependants, cache.lastDependants, 0 ) ) { + cache.clear(); + } + + cache.lastDependants = dependants; + } + + node = cache.head; + while ( node ) { + // Check whether node arguments match arguments + if ( ! isShallowEqual( node.args, args, 1 ) ) { + node = node.next; + continue; + } + + // At this point we can assume we've found a match + + // Surface matched node to head if not already + if ( node !== cache.head ) { + // Adjust siblings to point to each other. + node.prev.next = node.next; + if ( node.next ) { + node.next.prev = node.prev; + } + + node.next = cache.head; + node.prev = null; + cache.head.prev = node; + cache.head = node; + } + + // Return immediately + return node.val; + } + + // No cached value found. Continue to insertion phase: + + node = { + // Generate the result from original function + val: selector.apply( null, args ), + }; + + // Avoid including the source object in the cache. + args[ 0 ] = null; + node.args = args; + + // Don't need to check whether node is already head, since it would + // have been returned above already if it was + + // Shift existing head down list + if ( cache.head ) { + cache.head.prev = node; + node.next = cache.head; + } + + cache.head = node; + + return node.val; + } + + callSelector.getDependants = getDependants; + callSelector.clear = clear; + clear(); + + return callSelector; +}); + + +/***/ }), + +/***/ 31: +/***/ (function(module, exports, __webpack_require__) { + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +if (false) { var throwOnDirectAccess, isValidElement, REACT_ELEMENT_TYPE; } else { + // By explicitly using `prop-types` you are opting into new production behavior. + // http://fb.me/prop-types-in-prod + module.exports = __webpack_require__(89)(); +} + + +/***/ }), + +/***/ 32: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _typeof; }); +function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); } + +function _typeof(obj) { + if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") { + _typeof = function _typeof(obj) { + return _typeof2(obj); + }; + } else { + _typeof = function _typeof(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj); + }; + } + + return _typeof(obj); +} + +/***/ }), + +/***/ 33: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["apiFetch"]; }()); + +/***/ }), + +/***/ 34: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _iterableToArray; }); +function _iterableToArray(iter) { + if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); +} + +/***/ }), + +/***/ 341: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var _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; }; + +function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } + +var BEGIN = 'BEGIN'; +var COMMIT = 'COMMIT'; +var REVERT = 'REVERT'; +// Array({transactionID: string or null, beforeState: {object}, action: {object}} +var INITIAL_OPTIMIST = []; + +module.exports = optimist; +module.exports.BEGIN = BEGIN; +module.exports.COMMIT = COMMIT; +module.exports.REVERT = REVERT; +function optimist(fn) { + function beginReducer(state, action) { + var _separateState = separateState(state); + + var optimist = _separateState.optimist; + var innerState = _separateState.innerState; + + optimist = optimist.concat([{ beforeState: innerState, action: action }]); + innerState = fn(innerState, action); + validateState(innerState, action); + return _extends({ optimist: optimist }, innerState); + } + function commitReducer(state, action) { + var _separateState2 = separateState(state); + + var optimist = _separateState2.optimist; + var innerState = _separateState2.innerState; + + var newOptimist = [], + started = false, + committed = false; + optimist.forEach(function (entry) { + if (started) { + if (entry.beforeState && matchesTransaction(entry.action, action.optimist.id)) { + committed = true; + newOptimist.push({ action: entry.action }); + } else { + newOptimist.push(entry); + } + } else if (entry.beforeState && !matchesTransaction(entry.action, action.optimist.id)) { + started = true; + newOptimist.push(entry); + } else if (entry.beforeState && matchesTransaction(entry.action, action.optimist.id)) { + committed = true; + } + }); + if (!committed) { + console.error('Cannot commit transaction with id "' + action.optimist.id + '" because it does not exist'); + } + optimist = newOptimist; + return baseReducer(optimist, innerState, action); + } + function revertReducer(state, action) { + var _separateState3 = separateState(state); + + var optimist = _separateState3.optimist; + var innerState = _separateState3.innerState; + + var newOptimist = [], + started = false, + gotInitialState = false, + currentState = innerState; + optimist.forEach(function (entry) { + if (entry.beforeState && matchesTransaction(entry.action, action.optimist.id)) { + currentState = entry.beforeState; + gotInitialState = true; + } + if (!matchesTransaction(entry.action, action.optimist.id)) { + if (entry.beforeState) { + started = true; + } + if (started) { + if (gotInitialState && entry.beforeState) { + newOptimist.push({ + beforeState: currentState, + action: entry.action + }); + } else { + newOptimist.push(entry); + } + } + if (gotInitialState) { + currentState = fn(currentState, entry.action); + validateState(innerState, action); + } + } + }); + if (!gotInitialState) { + console.error('Cannot revert transaction with id "' + action.optimist.id + '" because it does not exist'); + } + optimist = newOptimist; + return baseReducer(optimist, currentState, action); + } + function baseReducer(optimist, innerState, action) { + if (optimist.length) { + optimist = optimist.concat([{ action: action }]); + } + innerState = fn(innerState, action); + validateState(innerState, action); + return _extends({ optimist: optimist }, innerState); + } + return function (state, action) { + if (action.optimist) { + switch (action.optimist.type) { + case BEGIN: + return beginReducer(state, action); + case COMMIT: + return commitReducer(state, action); + case REVERT: + return revertReducer(state, action); + } + } + + var _separateState4 = separateState(state); + + var optimist = _separateState4.optimist; + var innerState = _separateState4.innerState; + + if (state && !optimist.length) { + var nextState = fn(innerState, action); + if (nextState === innerState) { + return state; + } + validateState(nextState, action); + return _extends({ optimist: optimist }, nextState); + } + return baseReducer(optimist, innerState, action); + }; +} + +function matchesTransaction(action, id) { + return action.optimist && action.optimist.id === id; +} + +function validateState(newState, action) { + if (!newState || typeof newState !== 'object' || Array.isArray(newState)) { + throw new TypeError('Error while handling "' + action.type + '": Optimist requires that state is always a plain object.'); + } +} + +function separateState(state) { + if (!state) { + return { optimist: INITIAL_OPTIMIST, innerState: state }; + } else { + var _state$optimist = state.optimist; + + var _optimist = _state$optimist === undefined ? INITIAL_OPTIMIST : _state$optimist; + + var innerState = _objectWithoutProperties(state, ['optimist']); + + return { optimist: _optimist, innerState: innerState }; + } +} + +/***/ }), + +/***/ 35: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["blob"]; }()); + +/***/ }), + +/***/ 358: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +var actions_namespaceObject = {}; +__webpack_require__.r(actions_namespaceObject); +__webpack_require__.d(actions_namespaceObject, "setupEditor", function() { return setupEditor; }); +__webpack_require__.d(actions_namespaceObject, "resetPost", function() { return resetPost; }); +__webpack_require__.d(actions_namespaceObject, "resetAutosave", function() { return resetAutosave; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalRequestPostUpdateStart", function() { return __experimentalRequestPostUpdateStart; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalRequestPostUpdateSuccess", function() { return __experimentalRequestPostUpdateSuccess; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalRequestPostUpdateFailure", function() { return __experimentalRequestPostUpdateFailure; }); +__webpack_require__.d(actions_namespaceObject, "updatePost", function() { return updatePost; }); +__webpack_require__.d(actions_namespaceObject, "setupEditorState", function() { return setupEditorState; }); +__webpack_require__.d(actions_namespaceObject, "editPost", function() { return actions_editPost; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalOptimisticUpdatePost", function() { return __experimentalOptimisticUpdatePost; }); +__webpack_require__.d(actions_namespaceObject, "savePost", function() { return savePost; }); +__webpack_require__.d(actions_namespaceObject, "refreshPost", function() { return refreshPost; }); +__webpack_require__.d(actions_namespaceObject, "trashPost", function() { return trashPost; }); +__webpack_require__.d(actions_namespaceObject, "autosave", function() { return actions_autosave; }); +__webpack_require__.d(actions_namespaceObject, "redo", function() { return actions_redo; }); +__webpack_require__.d(actions_namespaceObject, "undo", function() { return actions_undo; }); +__webpack_require__.d(actions_namespaceObject, "createUndoLevel", function() { return createUndoLevel; }); +__webpack_require__.d(actions_namespaceObject, "updatePostLock", function() { return updatePostLock; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalFetchReusableBlocks", function() { return __experimentalFetchReusableBlocks; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalReceiveReusableBlocks", function() { return __experimentalReceiveReusableBlocks; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalSaveReusableBlock", function() { return __experimentalSaveReusableBlock; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalDeleteReusableBlock", function() { return __experimentalDeleteReusableBlock; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalUpdateReusableBlockTitle", function() { return __experimentalUpdateReusableBlockTitle; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalConvertBlockToStatic", function() { return __experimentalConvertBlockToStatic; }); +__webpack_require__.d(actions_namespaceObject, "__experimentalConvertBlockToReusable", function() { return __experimentalConvertBlockToReusable; }); +__webpack_require__.d(actions_namespaceObject, "enablePublishSidebar", function() { return enablePublishSidebar; }); +__webpack_require__.d(actions_namespaceObject, "disablePublishSidebar", function() { return disablePublishSidebar; }); +__webpack_require__.d(actions_namespaceObject, "lockPostSaving", function() { return lockPostSaving; }); +__webpack_require__.d(actions_namespaceObject, "unlockPostSaving", function() { return unlockPostSaving; }); +__webpack_require__.d(actions_namespaceObject, "resetEditorBlocks", function() { return actions_resetEditorBlocks; }); +__webpack_require__.d(actions_namespaceObject, "updateEditorSettings", function() { return updateEditorSettings; }); +__webpack_require__.d(actions_namespaceObject, "resetBlocks", function() { return resetBlocks; }); +__webpack_require__.d(actions_namespaceObject, "receiveBlocks", function() { return receiveBlocks; }); +__webpack_require__.d(actions_namespaceObject, "updateBlock", function() { return updateBlock; }); +__webpack_require__.d(actions_namespaceObject, "updateBlockAttributes", function() { return updateBlockAttributes; }); +__webpack_require__.d(actions_namespaceObject, "selectBlock", function() { return selectBlock; }); +__webpack_require__.d(actions_namespaceObject, "startMultiSelect", function() { return startMultiSelect; }); +__webpack_require__.d(actions_namespaceObject, "stopMultiSelect", function() { return stopMultiSelect; }); +__webpack_require__.d(actions_namespaceObject, "multiSelect", function() { return multiSelect; }); +__webpack_require__.d(actions_namespaceObject, "clearSelectedBlock", function() { return clearSelectedBlock; }); +__webpack_require__.d(actions_namespaceObject, "toggleSelection", function() { return toggleSelection; }); +__webpack_require__.d(actions_namespaceObject, "replaceBlocks", function() { return replaceBlocks; }); +__webpack_require__.d(actions_namespaceObject, "replaceBlock", function() { return replaceBlock; }); +__webpack_require__.d(actions_namespaceObject, "moveBlocksDown", function() { return moveBlocksDown; }); +__webpack_require__.d(actions_namespaceObject, "moveBlocksUp", function() { return moveBlocksUp; }); +__webpack_require__.d(actions_namespaceObject, "moveBlockToPosition", function() { return moveBlockToPosition; }); +__webpack_require__.d(actions_namespaceObject, "insertBlock", function() { return insertBlock; }); +__webpack_require__.d(actions_namespaceObject, "insertBlocks", function() { return insertBlocks; }); +__webpack_require__.d(actions_namespaceObject, "showInsertionPoint", function() { return showInsertionPoint; }); +__webpack_require__.d(actions_namespaceObject, "hideInsertionPoint", function() { return hideInsertionPoint; }); +__webpack_require__.d(actions_namespaceObject, "setTemplateValidity", function() { return setTemplateValidity; }); +__webpack_require__.d(actions_namespaceObject, "synchronizeTemplate", function() { return synchronizeTemplate; }); +__webpack_require__.d(actions_namespaceObject, "mergeBlocks", function() { return mergeBlocks; }); +__webpack_require__.d(actions_namespaceObject, "removeBlocks", function() { return removeBlocks; }); +__webpack_require__.d(actions_namespaceObject, "removeBlock", function() { return removeBlock; }); +__webpack_require__.d(actions_namespaceObject, "toggleBlockMode", function() { return toggleBlockMode; }); +__webpack_require__.d(actions_namespaceObject, "startTyping", function() { return startTyping; }); +__webpack_require__.d(actions_namespaceObject, "stopTyping", function() { return stopTyping; }); +__webpack_require__.d(actions_namespaceObject, "enterFormattedText", function() { return enterFormattedText; }); +__webpack_require__.d(actions_namespaceObject, "exitFormattedText", function() { return exitFormattedText; }); +__webpack_require__.d(actions_namespaceObject, "insertDefaultBlock", function() { return insertDefaultBlock; }); +__webpack_require__.d(actions_namespaceObject, "updateBlockListSettings", function() { return updateBlockListSettings; }); +var selectors_namespaceObject = {}; +__webpack_require__.r(selectors_namespaceObject); +__webpack_require__.d(selectors_namespaceObject, "hasEditorUndo", function() { return hasEditorUndo; }); +__webpack_require__.d(selectors_namespaceObject, "hasEditorRedo", function() { return hasEditorRedo; }); +__webpack_require__.d(selectors_namespaceObject, "isEditedPostNew", function() { return selectors_isEditedPostNew; }); +__webpack_require__.d(selectors_namespaceObject, "hasChangedContent", function() { return hasChangedContent; }); +__webpack_require__.d(selectors_namespaceObject, "isEditedPostDirty", function() { return selectors_isEditedPostDirty; }); +__webpack_require__.d(selectors_namespaceObject, "isCleanNewPost", function() { return selectors_isCleanNewPost; }); +__webpack_require__.d(selectors_namespaceObject, "getCurrentPost", function() { return selectors_getCurrentPost; }); +__webpack_require__.d(selectors_namespaceObject, "getCurrentPostType", function() { return selectors_getCurrentPostType; }); +__webpack_require__.d(selectors_namespaceObject, "getCurrentPostId", function() { return selectors_getCurrentPostId; }); +__webpack_require__.d(selectors_namespaceObject, "getCurrentPostRevisionsCount", function() { return getCurrentPostRevisionsCount; }); +__webpack_require__.d(selectors_namespaceObject, "getCurrentPostLastRevisionId", function() { return getCurrentPostLastRevisionId; }); +__webpack_require__.d(selectors_namespaceObject, "getPostEdits", function() { return getPostEdits; }); +__webpack_require__.d(selectors_namespaceObject, "getReferenceByDistinctEdits", function() { return getReferenceByDistinctEdits; }); +__webpack_require__.d(selectors_namespaceObject, "getCurrentPostAttribute", function() { return selectors_getCurrentPostAttribute; }); +__webpack_require__.d(selectors_namespaceObject, "getEditedPostAttribute", function() { return selectors_getEditedPostAttribute; }); +__webpack_require__.d(selectors_namespaceObject, "getAutosaveAttribute", function() { return getAutosaveAttribute; }); +__webpack_require__.d(selectors_namespaceObject, "getEditedPostVisibility", function() { return selectors_getEditedPostVisibility; }); +__webpack_require__.d(selectors_namespaceObject, "isCurrentPostPending", function() { return isCurrentPostPending; }); +__webpack_require__.d(selectors_namespaceObject, "isCurrentPostPublished", function() { return selectors_isCurrentPostPublished; }); +__webpack_require__.d(selectors_namespaceObject, "isCurrentPostScheduled", function() { return selectors_isCurrentPostScheduled; }); +__webpack_require__.d(selectors_namespaceObject, "isEditedPostPublishable", function() { return selectors_isEditedPostPublishable; }); +__webpack_require__.d(selectors_namespaceObject, "isEditedPostSaveable", function() { return selectors_isEditedPostSaveable; }); +__webpack_require__.d(selectors_namespaceObject, "isEditedPostEmpty", function() { return isEditedPostEmpty; }); +__webpack_require__.d(selectors_namespaceObject, "isEditedPostAutosaveable", function() { return selectors_isEditedPostAutosaveable; }); +__webpack_require__.d(selectors_namespaceObject, "getAutosave", function() { return getAutosave; }); +__webpack_require__.d(selectors_namespaceObject, "hasAutosave", function() { return hasAutosave; }); +__webpack_require__.d(selectors_namespaceObject, "isEditedPostBeingScheduled", function() { return selectors_isEditedPostBeingScheduled; }); +__webpack_require__.d(selectors_namespaceObject, "isEditedPostDateFloating", function() { return isEditedPostDateFloating; }); +__webpack_require__.d(selectors_namespaceObject, "isSavingPost", function() { return selectors_isSavingPost; }); +__webpack_require__.d(selectors_namespaceObject, "didPostSaveRequestSucceed", function() { return didPostSaveRequestSucceed; }); +__webpack_require__.d(selectors_namespaceObject, "didPostSaveRequestFail", function() { return didPostSaveRequestFail; }); +__webpack_require__.d(selectors_namespaceObject, "isAutosavingPost", function() { return selectors_isAutosavingPost; }); +__webpack_require__.d(selectors_namespaceObject, "isPreviewingPost", function() { return isPreviewingPost; }); +__webpack_require__.d(selectors_namespaceObject, "getEditedPostPreviewLink", function() { return selectors_getEditedPostPreviewLink; }); +__webpack_require__.d(selectors_namespaceObject, "getSuggestedPostFormat", function() { return selectors_getSuggestedPostFormat; }); +__webpack_require__.d(selectors_namespaceObject, "getBlocksForSerialization", function() { return getBlocksForSerialization; }); +__webpack_require__.d(selectors_namespaceObject, "getEditedPostContent", function() { return getEditedPostContent; }); +__webpack_require__.d(selectors_namespaceObject, "__experimentalGetReusableBlock", function() { return __experimentalGetReusableBlock; }); +__webpack_require__.d(selectors_namespaceObject, "__experimentalIsSavingReusableBlock", function() { return __experimentalIsSavingReusableBlock; }); +__webpack_require__.d(selectors_namespaceObject, "__experimentalIsFetchingReusableBlock", function() { return __experimentalIsFetchingReusableBlock; }); +__webpack_require__.d(selectors_namespaceObject, "__experimentalGetReusableBlocks", function() { return __experimentalGetReusableBlocks; }); +__webpack_require__.d(selectors_namespaceObject, "getStateBeforeOptimisticTransaction", function() { return getStateBeforeOptimisticTransaction; }); +__webpack_require__.d(selectors_namespaceObject, "isPublishingPost", function() { return selectors_isPublishingPost; }); +__webpack_require__.d(selectors_namespaceObject, "isPermalinkEditable", function() { return selectors_isPermalinkEditable; }); +__webpack_require__.d(selectors_namespaceObject, "getPermalink", function() { return getPermalink; }); +__webpack_require__.d(selectors_namespaceObject, "getPermalinkParts", function() { return selectors_getPermalinkParts; }); +__webpack_require__.d(selectors_namespaceObject, "inSomeHistory", function() { return inSomeHistory; }); +__webpack_require__.d(selectors_namespaceObject, "isPostLocked", function() { return isPostLocked; }); +__webpack_require__.d(selectors_namespaceObject, "isPostSavingLocked", function() { return selectors_isPostSavingLocked; }); +__webpack_require__.d(selectors_namespaceObject, "isPostLockTakeover", function() { return isPostLockTakeover; }); +__webpack_require__.d(selectors_namespaceObject, "getPostLockUser", function() { return getPostLockUser; }); +__webpack_require__.d(selectors_namespaceObject, "getActivePostLock", function() { return getActivePostLock; }); +__webpack_require__.d(selectors_namespaceObject, "canUserUseUnfilteredHTML", function() { return canUserUseUnfilteredHTML; }); +__webpack_require__.d(selectors_namespaceObject, "isPublishSidebarEnabled", function() { return selectors_isPublishSidebarEnabled; }); +__webpack_require__.d(selectors_namespaceObject, "getEditorBlocks", function() { return getEditorBlocks; }); +__webpack_require__.d(selectors_namespaceObject, "__unstableIsEditorReady", function() { return __unstableIsEditorReady; }); +__webpack_require__.d(selectors_namespaceObject, "getEditorSettings", function() { return selectors_getEditorSettings; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockDependantsCacheBust", function() { return getBlockDependantsCacheBust; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockName", function() { return selectors_getBlockName; }); +__webpack_require__.d(selectors_namespaceObject, "isBlockValid", function() { return isBlockValid; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockAttributes", function() { return getBlockAttributes; }); +__webpack_require__.d(selectors_namespaceObject, "getBlock", function() { return getBlock; }); +__webpack_require__.d(selectors_namespaceObject, "getBlocks", function() { return selectors_getBlocks; }); +__webpack_require__.d(selectors_namespaceObject, "__unstableGetBlockWithoutInnerBlocks", function() { return __unstableGetBlockWithoutInnerBlocks; }); +__webpack_require__.d(selectors_namespaceObject, "getClientIdsOfDescendants", function() { return getClientIdsOfDescendants; }); +__webpack_require__.d(selectors_namespaceObject, "getClientIdsWithDescendants", function() { return getClientIdsWithDescendants; }); +__webpack_require__.d(selectors_namespaceObject, "getGlobalBlockCount", function() { return getGlobalBlockCount; }); +__webpack_require__.d(selectors_namespaceObject, "getBlocksByClientId", function() { return getBlocksByClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockCount", function() { return getBlockCount; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockSelectionStart", function() { return getBlockSelectionStart; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockSelectionEnd", function() { return getBlockSelectionEnd; }); +__webpack_require__.d(selectors_namespaceObject, "getSelectedBlockCount", function() { return getSelectedBlockCount; }); +__webpack_require__.d(selectors_namespaceObject, "hasSelectedBlock", function() { return hasSelectedBlock; }); +__webpack_require__.d(selectors_namespaceObject, "getSelectedBlockClientId", function() { return selectors_getSelectedBlockClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getSelectedBlock", function() { return getSelectedBlock; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockRootClientId", function() { return getBlockRootClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockHierarchyRootClientId", function() { return getBlockHierarchyRootClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getAdjacentBlockClientId", function() { return getAdjacentBlockClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getPreviousBlockClientId", function() { return getPreviousBlockClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getNextBlockClientId", function() { return getNextBlockClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getSelectedBlocksInitialCaretPosition", function() { return getSelectedBlocksInitialCaretPosition; }); +__webpack_require__.d(selectors_namespaceObject, "getMultiSelectedBlockClientIds", function() { return getMultiSelectedBlockClientIds; }); +__webpack_require__.d(selectors_namespaceObject, "getMultiSelectedBlocks", function() { return getMultiSelectedBlocks; }); +__webpack_require__.d(selectors_namespaceObject, "getFirstMultiSelectedBlockClientId", function() { return getFirstMultiSelectedBlockClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getLastMultiSelectedBlockClientId", function() { return getLastMultiSelectedBlockClientId; }); +__webpack_require__.d(selectors_namespaceObject, "isFirstMultiSelectedBlock", function() { return isFirstMultiSelectedBlock; }); +__webpack_require__.d(selectors_namespaceObject, "isBlockMultiSelected", function() { return isBlockMultiSelected; }); +__webpack_require__.d(selectors_namespaceObject, "isAncestorMultiSelected", function() { return isAncestorMultiSelected; }); +__webpack_require__.d(selectors_namespaceObject, "getMultiSelectedBlocksStartClientId", function() { return getMultiSelectedBlocksStartClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getMultiSelectedBlocksEndClientId", function() { return getMultiSelectedBlocksEndClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockOrder", function() { return getBlockOrder; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockIndex", function() { return getBlockIndex; }); +__webpack_require__.d(selectors_namespaceObject, "isBlockSelected", function() { return isBlockSelected; }); +__webpack_require__.d(selectors_namespaceObject, "hasSelectedInnerBlock", function() { return hasSelectedInnerBlock; }); +__webpack_require__.d(selectors_namespaceObject, "isBlockWithinSelection", function() { return isBlockWithinSelection; }); +__webpack_require__.d(selectors_namespaceObject, "hasMultiSelection", function() { return hasMultiSelection; }); +__webpack_require__.d(selectors_namespaceObject, "isMultiSelecting", function() { return isMultiSelecting; }); +__webpack_require__.d(selectors_namespaceObject, "isSelectionEnabled", function() { return isSelectionEnabled; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockMode", function() { return getBlockMode; }); +__webpack_require__.d(selectors_namespaceObject, "isTyping", function() { return selectors_isTyping; }); +__webpack_require__.d(selectors_namespaceObject, "isCaretWithinFormattedText", function() { return selectors_isCaretWithinFormattedText; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockInsertionPoint", function() { return getBlockInsertionPoint; }); +__webpack_require__.d(selectors_namespaceObject, "isBlockInsertionPointVisible", function() { return isBlockInsertionPointVisible; }); +__webpack_require__.d(selectors_namespaceObject, "isValidTemplate", function() { return isValidTemplate; }); +__webpack_require__.d(selectors_namespaceObject, "getTemplate", function() { return getTemplate; }); +__webpack_require__.d(selectors_namespaceObject, "getTemplateLock", function() { return getTemplateLock; }); +__webpack_require__.d(selectors_namespaceObject, "canInsertBlockType", function() { return canInsertBlockType; }); +__webpack_require__.d(selectors_namespaceObject, "getInserterItems", function() { return selectors_getInserterItems; }); +__webpack_require__.d(selectors_namespaceObject, "hasInserterItems", function() { return hasInserterItems; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockListSettings", function() { return getBlockListSettings; }); + +// EXTERNAL MODULE: external {"this":["wp","blockEditor"]} +var external_this_wp_blockEditor_ = __webpack_require__(8); + +// EXTERNAL MODULE: external {"this":["wp","blocks"]} +var external_this_wp_blocks_ = __webpack_require__(14); + +// EXTERNAL MODULE: external {"this":["wp","coreData"]} +var external_this_wp_coreData_ = __webpack_require__(72); + +// EXTERNAL MODULE: external {"this":["wp","notices"]} +var external_this_wp_notices_ = __webpack_require__(133); + +// EXTERNAL MODULE: external {"this":["wp","nux"]} +var external_this_wp_nux_ = __webpack_require__(60); + +// EXTERNAL MODULE: external {"this":["wp","richText"]} +var external_this_wp_richText_ = __webpack_require__(20); + +// EXTERNAL MODULE: external {"this":["wp","viewport"]} +var external_this_wp_viewport_ = __webpack_require__(40); + +// EXTERNAL MODULE: external {"this":["wp","data"]} +var external_this_wp_data_ = __webpack_require__(5); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules +var slicedToArray = __webpack_require__(28); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js +var defineProperty = __webpack_require__(15); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js +var objectSpread = __webpack_require__(7); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js +var esm_typeof = __webpack_require__(32); + +// EXTERNAL MODULE: ./node_modules/redux-optimist/index.js +var redux_optimist = __webpack_require__(62); +var redux_optimist_default = /*#__PURE__*/__webpack_require__.n(redux_optimist); + +// EXTERNAL MODULE: external "lodash" +var external_lodash_ = __webpack_require__(2); + +// EXTERNAL MODULE: external {"this":["wp","url"]} +var external_this_wp_url_ = __webpack_require__(25); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/defaults.js + + +/** + * WordPress dependencies + */ + +var PREFERENCES_DEFAULTS = { + isPublishSidebarEnabled: true +}; +/** + * Default initial edits state. + * + * @type {Object} + */ + +var INITIAL_EDITS_DEFAULTS = {}; +/** + * The default post editor settings + * + * allowedBlockTypes boolean|Array Allowed block types + * richEditingEnabled boolean Whether rich editing is enabled or not + * enableCustomFields boolean Whether the WordPress custom fields are enabled or not + * autosaveInterval number Autosave Interval + * availableTemplates array? The available post templates + * disablePostFormats boolean Whether or not the post formats are disabled + * allowedMimeTypes array? List of allowed mime types and file extensions + * maxUploadFileSize number Maximum upload file size + */ + +var EDITOR_SETTINGS_DEFAULTS = Object(objectSpread["a" /* default */])({}, external_this_wp_blockEditor_["SETTINGS_DEFAULTS"], { + richEditingEnabled: true, + enableCustomFields: false +}); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/constants.js +/** + * Set of post properties for which edits should assume a merging behavior, + * assuming an object value. + * + * @type {Set} + */ +var EDIT_MERGE_PROPERTIES = new Set(['meta']); +/** + * Constant for the store module (or reducer) key. + * @type {string} + */ + +var STORE_KEY = 'core/editor'; +var POST_UPDATE_TRANSACTION_ID = 'post-update'; +var SAVE_POST_NOTICE_ID = 'SAVE_POST_NOTICE_ID'; +var TRASH_POST_NOTICE_ID = 'TRASH_POST_NOTICE_ID'; +var PERMALINK_POSTNAME_REGEX = /%(?:postname|pagename)%/; +var ONE_MINUTE_IN_MS = 60 * 1000; + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/utils/with-change-detection/index.js + + +/** + * External dependencies + */ + +/** + * Higher-order reducer creator for tracking changes to state over time. The + * returned reducer will include a `isDirty` property on the object reflecting + * whether the original reference of the reducer has changed. + * + * @param {?Object} options Optional options. + * @param {?Array} options.ignoreTypes Action types upon which to skip check. + * @param {?Array} options.resetTypes Action types upon which to reset dirty. + * + * @return {Function} Higher-order reducer. + */ + +var with_change_detection_withChangeDetection = function withChangeDetection() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + return function (reducer) { + return function (state, action) { + var nextState = reducer(state, action); // Reset at: + // - Initial state + // - Reset types + + var isReset = state === undefined || Object(external_lodash_["includes"])(options.resetTypes, action.type); + var isChanging = state !== nextState; // If not intending to update dirty flag, return early and avoid clone. + + if (!isChanging && !isReset) { + return state; + } // Avoid mutating state, unless it's already changing by original + // reducer and not initial. + + + if (!isChanging || state === undefined) { + nextState = Object(objectSpread["a" /* default */])({}, nextState); + } + + var isIgnored = Object(external_lodash_["includes"])(options.ignoreTypes, action.type); + + if (isIgnored) { + // Preserve the original value if ignored. + nextState.isDirty = state.isDirty; + } else { + nextState.isDirty = !isReset && isChanging; + } + + return nextState; + }; + }; +}; + +/* harmony default export */ var with_change_detection = (with_change_detection_withChangeDetection); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules +var toConsumableArray = __webpack_require__(17); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/utils/with-history/index.js + + + +/** + * External dependencies + */ + +/** + * Default options for withHistory reducer enhancer. Refer to withHistory + * documentation for options explanation. + * + * @see withHistory + * + * @type {Object} + */ + +var DEFAULT_OPTIONS = { + resetTypes: [], + ignoreTypes: [], + shouldOverwriteState: function shouldOverwriteState() { + return false; + } +}; +/** + * Higher-order reducer creator which transforms the result of the original + * reducer into an object tracking its own history (past, present, future). + * + * @param {?Object} options Optional options. + * @param {?Array} options.resetTypes Action types upon which to + * clear past. + * @param {?Array} options.ignoreTypes Action types upon which to + * avoid history tracking. + * @param {?Function} options.shouldOverwriteState Function receiving last and + * current actions, returning + * boolean indicating whether + * present should be merged, + * rather than add undo level. + * + * @return {Function} Higher-order reducer. + */ + +var with_history_withHistory = function withHistory() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + return function (reducer) { + options = Object(objectSpread["a" /* default */])({}, DEFAULT_OPTIONS, options); // `ignoreTypes` is simply a convenience for `shouldOverwriteState` + + options.shouldOverwriteState = Object(external_lodash_["overSome"])([options.shouldOverwriteState, function (action) { + return Object(external_lodash_["includes"])(options.ignoreTypes, action.type); + }]); + var initialState = { + past: [], + present: reducer(undefined, {}), + future: [], + lastAction: null, + shouldCreateUndoLevel: false + }; + var _options = options, + _options$resetTypes = _options.resetTypes, + resetTypes = _options$resetTypes === void 0 ? [] : _options$resetTypes, + _options$shouldOverwr = _options.shouldOverwriteState, + shouldOverwriteState = _options$shouldOverwr === void 0 ? function () { + return false; + } : _options$shouldOverwr; + return function () { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState; + var action = arguments.length > 1 ? arguments[1] : undefined; + var past = state.past, + present = state.present, + future = state.future, + lastAction = state.lastAction, + shouldCreateUndoLevel = state.shouldCreateUndoLevel; + var previousAction = lastAction; + + switch (action.type) { + case 'UNDO': + // Can't undo if no past. + if (!past.length) { + return state; + } + + return { + past: Object(external_lodash_["dropRight"])(past), + present: Object(external_lodash_["last"])(past), + future: [present].concat(Object(toConsumableArray["a" /* default */])(future)), + lastAction: null, + shouldCreateUndoLevel: false + }; + + case 'REDO': + // Can't redo if no future. + if (!future.length) { + return state; + } + + return { + past: [].concat(Object(toConsumableArray["a" /* default */])(past), [present]), + present: Object(external_lodash_["first"])(future), + future: Object(external_lodash_["drop"])(future), + lastAction: null, + shouldCreateUndoLevel: false + }; + + case 'CREATE_UNDO_LEVEL': + return Object(objectSpread["a" /* default */])({}, state, { + lastAction: null, + shouldCreateUndoLevel: true + }); + } + + var nextPresent = reducer(present, action); + + if (Object(external_lodash_["includes"])(resetTypes, action.type)) { + return { + past: [], + present: nextPresent, + future: [], + lastAction: null, + shouldCreateUndoLevel: false + }; + } + + if (present === nextPresent) { + return state; + } + + var nextPast = past; // The `lastAction` property is used to compare actions in the + // `shouldOverwriteState` option. If an action should be ignored, do not + // submit that action as the last action, otherwise the ability to + // compare subsequent actions will break. + + var lastActionToSubmit = previousAction; + + if (shouldCreateUndoLevel || !past.length || !shouldOverwriteState(action, previousAction)) { + nextPast = [].concat(Object(toConsumableArray["a" /* default */])(past), [present]); + lastActionToSubmit = action; + } + + return { + past: nextPast, + present: nextPresent, + future: [], + shouldCreateUndoLevel: false, + lastAction: lastActionToSubmit + }; + }; + }; +}; + +/* harmony default export */ var with_history = (with_history_withHistory); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/reducer.js + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + + +/** + * Returns a post attribute value, flattening nested rendered content using its + * raw value in place of its original object form. + * + * @param {*} value Original value. + * + * @return {*} Raw value. + */ + +function getPostRawValue(value) { + if (value && 'object' === Object(esm_typeof["a" /* default */])(value) && 'raw' in value) { + return value.raw; + } + + return value; +} +/** + * Returns an object against which it is safe to perform mutating operations, + * given the original object and its current working copy. + * + * @param {Object} original Original object. + * @param {Object} working Working object. + * + * @return {Object} Mutation-safe object. + */ + +function getMutateSafeObject(original, working) { + if (original === working) { + return Object(objectSpread["a" /* default */])({}, original); + } + + return working; +} +/** + * Returns true if the two object arguments have the same keys, or false + * otherwise. + * + * @param {Object} a First object. + * @param {Object} b Second object. + * + * @return {boolean} Whether the two objects have the same keys. + */ + + +function hasSameKeys(a, b) { + return Object(external_lodash_["isEqual"])(Object(external_lodash_["keys"])(a), Object(external_lodash_["keys"])(b)); +} +/** + * Returns true if, given the currently dispatching action and the previously + * dispatched action, the two actions are editing the same post property, or + * false otherwise. + * + * @param {Object} action Currently dispatching action. + * @param {Object} previousAction Previously dispatched action. + * + * @return {boolean} Whether actions are updating the same post property. + */ + +function isUpdatingSamePostProperty(action, previousAction) { + return action.type === 'EDIT_POST' && hasSameKeys(action.edits, previousAction.edits); +} +/** + * Returns true if, given the currently dispatching action and the previously + * dispatched action, the two actions are modifying the same property such that + * undo history should be batched. + * + * @param {Object} action Currently dispatching action. + * @param {Object} previousAction Previously dispatched action. + * + * @return {boolean} Whether to overwrite present state. + */ + +function reducer_shouldOverwriteState(action, previousAction) { + if (action.type === 'RESET_EDITOR_BLOCKS') { + return !action.shouldCreateUndoLevel; + } + + if (!previousAction || action.type !== previousAction.type) { + return false; + } + + return isUpdatingSamePostProperty(action, previousAction); +} +/** + * Undoable reducer returning the editor post state, including blocks parsed + * from current HTML markup. + * + * Handles the following state keys: + * - edits: an object describing changes to be made to the current post, in + * the format accepted by the WP REST API + * - blocks: post content blocks + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @returns {Object} Updated state. + */ + +var editor = Object(external_lodash_["flow"])([external_this_wp_data_["combineReducers"], with_history({ + resetTypes: ['SETUP_EDITOR_STATE'], + ignoreTypes: ['RESET_POST', 'UPDATE_POST'], + shouldOverwriteState: reducer_shouldOverwriteState +})])({ + // Track whether changes exist, resetting at each post save. Relies on + // editor initialization firing post reset as an effect. + blocks: with_change_detection({ + resetTypes: ['SETUP_EDITOR_STATE', 'REQUEST_POST_UPDATE_START'] + })(function () { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { + value: [] + }; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'RESET_EDITOR_BLOCKS': + if (action.blocks === state.value) { + return state; + } + + return { + value: action.blocks + }; + } + + return state; + }), + edits: function edits() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'EDIT_POST': + return Object(external_lodash_["reduce"])(action.edits, function (result, value, key) { + // Only assign into result if not already same value + if (value !== state[key]) { + result = getMutateSafeObject(state, result); + + if (EDIT_MERGE_PROPERTIES.has(key)) { + // Merge properties should assign to current value. + result[key] = Object(objectSpread["a" /* default */])({}, result[key], value); + } else { + // Otherwise override. + result[key] = value; + } + } + + return result; + }, state); + + case 'UPDATE_POST': + case 'RESET_POST': + var getCanonicalValue = action.type === 'UPDATE_POST' ? function (key) { + return action.edits[key]; + } : function (key) { + return getPostRawValue(action.post[key]); + }; + return Object(external_lodash_["reduce"])(state, function (result, value, key) { + if (!Object(external_lodash_["isEqual"])(value, getCanonicalValue(key))) { + return result; + } + + result = getMutateSafeObject(state, result); + delete result[key]; + return result; + }, state); + + case 'RESET_EDITOR_BLOCKS': + if ('content' in state) { + return Object(external_lodash_["omit"])(state, 'content'); + } + + return state; + } + + return state; + } +}); +/** + * Reducer returning the initial edits state. With matching shape to that of + * `editor.edits`, the initial edits are those applied programmatically, are + * not considered in prompting the user for unsaved changes, and are included + * in (and reset by) the next save payload. + * + * @param {Object} state Current state. + * @param {Object} action Action object. + * + * @return {Object} Next state. + */ + +function initialEdits() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : INITIAL_EDITS_DEFAULTS; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'SETUP_EDITOR': + if (!action.edits) { + break; + } + + return action.edits; + + case 'SETUP_EDITOR_STATE': + if ('content' in state) { + return Object(external_lodash_["omit"])(state, 'content'); + } + + return state; + + case 'UPDATE_POST': + return Object(external_lodash_["reduce"])(action.edits, function (result, value, key) { + if (!result.hasOwnProperty(key)) { + return result; + } + + result = getMutateSafeObject(state, result); + delete result[key]; + return result; + }, state); + + case 'RESET_POST': + return INITIAL_EDITS_DEFAULTS; + } + + return state; +} +/** + * Reducer returning the last-known state of the current post, in the format + * returned by the WP REST API. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + +function currentPost() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'SETUP_EDITOR_STATE': + case 'RESET_POST': + case 'UPDATE_POST': + var post; + + if (action.post) { + post = action.post; + } else if (action.edits) { + post = Object(objectSpread["a" /* default */])({}, state, action.edits); + } else { + return state; + } + + return Object(external_lodash_["mapValues"])(post, getPostRawValue); + } + + return state; +} +/** + * Reducer returning typing state. + * + * @param {boolean} state Current state. + * @param {Object} action Dispatched action. + * + * @return {boolean} Updated state. + */ + +function isTyping() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'START_TYPING': + return true; + + case 'STOP_TYPING': + return false; + } + + return state; +} +/** + * Reducer returning whether the caret is within formatted text. + * + * @param {boolean} state Current state. + * @param {Object} action Dispatched action. + * + * @return {boolean} Updated state. + */ + +function isCaretWithinFormattedText() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'ENTER_FORMATTED_TEXT': + return true; + + case 'EXIT_FORMATTED_TEXT': + return false; + } + + return state; +} +/** + * Reducer returning the block selection's state. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + +function blockSelection() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { + start: null, + end: null, + isMultiSelecting: false, + isEnabled: true, + initialPosition: null + }; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'CLEAR_SELECTED_BLOCK': + if (state.start === null && state.end === null && !state.isMultiSelecting) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + start: null, + end: null, + isMultiSelecting: false, + initialPosition: null + }); + + case 'START_MULTI_SELECT': + if (state.isMultiSelecting) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + isMultiSelecting: true, + initialPosition: null + }); + + case 'STOP_MULTI_SELECT': + if (!state.isMultiSelecting) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + isMultiSelecting: false, + initialPosition: null + }); + + case 'MULTI_SELECT': + return Object(objectSpread["a" /* default */])({}, state, { + start: action.start, + end: action.end, + initialPosition: null + }); + + case 'SELECT_BLOCK': + if (action.clientId === state.start && action.clientId === state.end) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + start: action.clientId, + end: action.clientId, + initialPosition: action.initialPosition + }); + + case 'INSERT_BLOCKS': + { + if (action.updateSelection) { + return Object(objectSpread["a" /* default */])({}, state, { + start: action.blocks[0].clientId, + end: action.blocks[0].clientId, + initialPosition: null, + isMultiSelecting: false + }); + } + + return state; + } + + case 'REMOVE_BLOCKS': + if (!action.clientIds || !action.clientIds.length || action.clientIds.indexOf(state.start) === -1) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + start: null, + end: null, + initialPosition: null, + isMultiSelecting: false + }); + + case 'REPLACE_BLOCKS': + if (action.clientIds.indexOf(state.start) === -1) { + return state; + } // If there are replacement blocks, assign last block as the next + // selected block, otherwise set to null. + + + var lastBlock = Object(external_lodash_["last"])(action.blocks); + var nextSelectedBlockClientId = lastBlock ? lastBlock.clientId : null; + + if (nextSelectedBlockClientId === state.start && nextSelectedBlockClientId === state.end) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + start: nextSelectedBlockClientId, + end: nextSelectedBlockClientId, + initialPosition: null, + isMultiSelecting: false + }); + + case 'TOGGLE_SELECTION': + return Object(objectSpread["a" /* default */])({}, state, { + isEnabled: action.isSelectionEnabled + }); + } + + return state; +} +function blocksMode() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + if (action.type === 'TOGGLE_BLOCK_MODE') { + var clientId = action.clientId; + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, clientId, state[clientId] && state[clientId] === 'html' ? 'visual' : 'html')); + } + + return state; +} +/** + * Reducer returning the block insertion point visibility, either null if there + * is not an explicit insertion point assigned, or an object of its `index` and + * `rootClientId`. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + +function insertionPoint() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'SHOW_INSERTION_POINT': + var rootClientId = action.rootClientId, + index = action.index; + return { + rootClientId: rootClientId, + index: index + }; + + case 'HIDE_INSERTION_POINT': + return null; + } + + return state; +} +/** + * Reducer returning whether the post blocks match the defined template or not. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {boolean} Updated state. + */ + +function reducer_template() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { + isValid: true + }; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'SET_TEMPLATE_VALIDITY': + return Object(objectSpread["a" /* default */])({}, state, { + isValid: action.isValid + }); + } + + return state; +} +/** + * Reducer returning the user preferences. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {string} Updated state. + */ + +function preferences() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : PREFERENCES_DEFAULTS; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'ENABLE_PUBLISH_SIDEBAR': + return Object(objectSpread["a" /* default */])({}, state, { + isPublishSidebarEnabled: true + }); + + case 'DISABLE_PUBLISH_SIDEBAR': + return Object(objectSpread["a" /* default */])({}, state, { + isPublishSidebarEnabled: false + }); + } + + return state; +} +/** + * Reducer returning current network request state (whether a request to + * the WP REST API is in progress, successful, or failed). + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + +function saving() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'REQUEST_POST_UPDATE_START': + return { + requesting: true, + successful: false, + error: null, + options: action.options || {} + }; + + case 'REQUEST_POST_UPDATE_SUCCESS': + return { + requesting: false, + successful: true, + error: null, + options: action.options || {} + }; + + case 'REQUEST_POST_UPDATE_FAILURE': + return { + requesting: false, + successful: false, + error: action.error, + options: action.options || {} + }; + } + + return state; +} +/** + * Post Lock State. + * + * @typedef {Object} PostLockState + * + * @property {boolean} isLocked Whether the post is locked. + * @property {?boolean} isTakeover Whether the post editing has been taken over. + * @property {?boolean} activePostLock Active post lock value. + * @property {?Object} user User that took over the post. + */ + +/** + * Reducer returning the post lock status. + * + * @param {PostLockState} state Current state. + * @param {Object} action Dispatched action. + * + * @return {PostLockState} Updated state. + */ + +function postLock() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { + isLocked: false + }; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'UPDATE_POST_LOCK': + return action.lock; + } + + return state; +} +/** + * Post saving lock. + * + * When post saving is locked, the post cannot be published or updated. + * + * @param {PostSavingLockState} state Current state. + * @param {Object} action Dispatched action. + * + * @return {PostLockState} Updated state. + */ + +function postSavingLock() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'LOCK_POST_SAVING': + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.lockName, true)); + + case 'UNLOCK_POST_SAVING': + return Object(external_lodash_["omit"])(state, action.lockName); + } + + return state; +} +var reducer_reusableBlocks = Object(external_this_wp_data_["combineReducers"])({ + data: function data() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'RECEIVE_REUSABLE_BLOCKS': + { + return Object(external_lodash_["reduce"])(action.results, function (nextState, result) { + var _result$reusableBlock = result.reusableBlock, + id = _result$reusableBlock.id, + title = _result$reusableBlock.title; + var clientId = result.parsedBlock.clientId; + var value = { + clientId: clientId, + title: title + }; + + if (!Object(external_lodash_["isEqual"])(nextState[id], value)) { + nextState = getMutateSafeObject(state, nextState); + nextState[id] = value; + } + + return nextState; + }, state); + } + + case 'UPDATE_REUSABLE_BLOCK_TITLE': + { + var id = action.id, + title = action.title; + + if (!state[id] || state[id].title === title) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, id, Object(objectSpread["a" /* default */])({}, state[id], { + title: title + }))); + } + + case 'SAVE_REUSABLE_BLOCK_SUCCESS': + { + var _id = action.id, + updatedId = action.updatedId; // If a temporary reusable block is saved, we swap the temporary id with the final one + + if (_id === updatedId) { + return state; + } + + var value = state[_id]; + return Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(state, _id), Object(defineProperty["a" /* default */])({}, updatedId, value)); + } + + case 'REMOVE_REUSABLE_BLOCK': + { + var _id2 = action.id; + return Object(external_lodash_["omit"])(state, _id2); + } + } + + return state; + }, + isFetching: function isFetching() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'FETCH_REUSABLE_BLOCKS': + { + var id = action.id; + + if (!id) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, id, true)); + } + + case 'FETCH_REUSABLE_BLOCKS_SUCCESS': + case 'FETCH_REUSABLE_BLOCKS_FAILURE': + { + var _id3 = action.id; + return Object(external_lodash_["omit"])(state, _id3); + } + } + + return state; + }, + isSaving: function isSaving() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'SAVE_REUSABLE_BLOCK': + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.id, true)); + + case 'SAVE_REUSABLE_BLOCK_SUCCESS': + case 'SAVE_REUSABLE_BLOCK_FAILURE': + { + var id = action.id; + return Object(external_lodash_["omit"])(state, id); + } + } + + return state; + } +}); +/** + * Reducer returning an object where each key is a block client ID, its value + * representing the settings for its nested blocks. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + +var reducer_blockListSettings = function blockListSettings() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + // Even if the replaced blocks have the same client ID, our logic + // should correct the state. + case 'REPLACE_BLOCKS': + case 'REMOVE_BLOCKS': + { + return Object(external_lodash_["omit"])(state, action.clientIds); + } + + case 'UPDATE_BLOCK_LIST_SETTINGS': + { + var clientId = action.clientId; + + if (!action.settings) { + if (state.hasOwnProperty(clientId)) { + return Object(external_lodash_["omit"])(state, clientId); + } + + return state; + } + + if (Object(external_lodash_["isEqual"])(state[clientId], action.settings)) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, clientId, action.settings)); + } + } + + return state; +}; +/** + * Reducer returning the most recent autosave. + * + * @param {Object} state The autosave object. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + +function autosave() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'RESET_AUTOSAVE': + var post = action.post; + + var _map = ['title', 'excerpt', 'content'].map(function (field) { + return getPostRawValue(post[field]); + }), + _map2 = Object(slicedToArray["a" /* default */])(_map, 3), + title = _map2[0], + excerpt = _map2[1], + content = _map2[2]; + + return { + title: title, + excerpt: excerpt, + content: content + }; + } + + return state; +} +/** + * Reducer returning the post preview link. + * + * @param {string?} state The preview link + * @param {Object} action Dispatched action. + * + * @return {string?} Updated state. + */ + +function reducer_previewLink() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'REQUEST_POST_UPDATE_SUCCESS': + if (action.post.preview_link) { + return action.post.preview_link; + } else if (action.post.link) { + return Object(external_this_wp_url_["addQueryArgs"])(action.post.link, { + preview: true + }); + } + + return state; + + case 'REQUEST_POST_UPDATE_START': + // Invalidate known preview link when autosave starts. + if (state && action.options.isPreview) { + return null; + } + + break; + } + + return state; +} +/** + * Reducer returning whether the editor is ready to be rendered. + * The editor is considered ready to be rendered once + * the post object is loaded properly and the initial blocks parsed. + * + * @param {boolean} state + * @param {Object} action + * + * @return {boolean} Updated state. + */ + +function reducer_isReady() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'SETUP_EDITOR_STATE': + return true; + } + + return state; +} +/** + * Reducer returning the post editor setting. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + +function reducer_editorSettings() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : EDITOR_SETTINGS_DEFAULTS; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'UPDATE_EDITOR_SETTINGS': + return Object(objectSpread["a" /* default */])({}, state, action.settings); + } + + return state; +} +/* harmony default export */ var store_reducer = (redux_optimist_default()(Object(external_this_wp_data_["combineReducers"])({ + editor: editor, + initialEdits: initialEdits, + currentPost: currentPost, + preferences: preferences, + saving: saving, + postLock: postLock, + reusableBlocks: reducer_reusableBlocks, + template: reducer_template, + autosave: autosave, + previewLink: reducer_previewLink, + postSavingLock: postSavingLock, + isReady: reducer_isReady, + editorSettings: reducer_editorSettings +}))); + +// EXTERNAL MODULE: ./node_modules/refx/refx.js +var refx = __webpack_require__(70); +var refx_default = /*#__PURE__*/__webpack_require__.n(refx); + +// EXTERNAL MODULE: ./node_modules/redux-multi/lib/index.js +var lib = __webpack_require__(97); +var lib_default = /*#__PURE__*/__webpack_require__.n(lib); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/regenerator/index.js +var regenerator = __webpack_require__(23); +var regenerator_default = /*#__PURE__*/__webpack_require__.n(regenerator); + +// EXTERNAL MODULE: external {"this":["wp","apiFetch"]} +var external_this_wp_apiFetch_ = __webpack_require__(33); +var external_this_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_apiFetch_); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/controls.js + + +/** + * WordPress dependencies + */ + + +/** + * Dispatches a control action for triggering an api fetch call. + * + * @param {Object} request Arguments for the fetch request. + * + * @return {Object} control descriptor. + */ + +function apiFetch(request) { + return { + type: 'API_FETCH', + request: request + }; +} +/** + * Dispatches a control action for triggering a registry select. + * + * @param {string} storeKey + * @param {string} selectorName + * @param {Array} args Arguments for the select. + * + * @return {Object} control descriptor. + */ + +function controls_select(storeKey, selectorName) { + for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { + args[_key - 2] = arguments[_key]; + } + + return { + type: 'SELECT', + storeKey: storeKey, + selectorName: selectorName, + args: args + }; +} +/** + * Dispatches a control action for triggering a registry select that has a + * resolver. + * + * @param {string} storeKey + * @param {string} selectorName + * @param {Array} args Arguments for the select. + * + * @return {Object} control descriptor. + */ + +function resolveSelect(storeKey, selectorName) { + for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { + args[_key2 - 2] = arguments[_key2]; + } + + return { + type: 'RESOLVE_SELECT', + storeKey: storeKey, + selectorName: selectorName, + args: args + }; +} +/** + * Dispatches a control action for triggering a registry dispatch. + * + * @param {string} storeKey + * @param {string} actionName + * @param {Array} args Arguments for the dispatch action. + * + * @return {Object} control descriptor. + */ + +function controls_dispatch(storeKey, actionName) { + for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) { + args[_key3 - 2] = arguments[_key3]; + } + + return { + type: 'DISPATCH', + storeKey: storeKey, + actionName: actionName, + args: args + }; +} +/* harmony default export */ var controls = ({ + API_FETCH: function API_FETCH(_ref) { + var request = _ref.request; + return external_this_wp_apiFetch_default()(request); + }, + SELECT: Object(external_this_wp_data_["createRegistryControl"])(function (registry) { + return function (_ref2) { + var _registry$select; + + var storeKey = _ref2.storeKey, + selectorName = _ref2.selectorName, + args = _ref2.args; + return (_registry$select = registry.select(storeKey))[selectorName].apply(_registry$select, Object(toConsumableArray["a" /* default */])(args)); + }; + }), + DISPATCH: Object(external_this_wp_data_["createRegistryControl"])(function (registry) { + return function (_ref3) { + var _registry$dispatch; + + var storeKey = _ref3.storeKey, + actionName = _ref3.actionName, + args = _ref3.args; + return (_registry$dispatch = registry.dispatch(storeKey))[actionName].apply(_registry$dispatch, Object(toConsumableArray["a" /* default */])(args)); + }; + }), + RESOLVE_SELECT: Object(external_this_wp_data_["createRegistryControl"])(function (registry) { + return function (_ref4) { + var storeKey = _ref4.storeKey, + selectorName = _ref4.selectorName, + args = _ref4.args; + return new Promise(function (resolve) { + var hasFinished = function hasFinished() { + return registry.select('core/data').hasFinishedResolution(storeKey, selectorName, args); + }; + + var getResult = function getResult() { + return registry.select(storeKey)[selectorName].apply(null, args); + }; // trigger the selector (to trigger the resolver) + + + var result = getResult(); + + if (hasFinished()) { + return resolve(result); + } + + var unsubscribe = registry.subscribe(function () { + if (hasFinished()) { + unsubscribe(); + resolve(getResult()); + } + }); + }); + }; + }) +}); + +// EXTERNAL MODULE: external {"this":["wp","i18n"]} +var external_this_wp_i18n_ = __webpack_require__(1); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/utils/notice-builder.js +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + +/** + * External dependencies + */ + + +/** + * Builds the arguments for a success notification dispatch. + * + * @param {Object} data Incoming data to build the arguments from. + * + * @return {Array} Arguments for dispatch. An empty array signals no + * notification should be sent. + */ + +function getNotificationArgumentsForSaveSuccess(data) { + var previousPost = data.previousPost, + post = data.post, + postType = data.postType; // Autosaves are neither shown a notice nor redirected. + + if (Object(external_lodash_["get"])(data.options, ['isAutosave'])) { + return []; + } + + var publishStatus = ['publish', 'private', 'future']; + var isPublished = Object(external_lodash_["includes"])(publishStatus, previousPost.status); + var willPublish = Object(external_lodash_["includes"])(publishStatus, post.status); + var noticeMessage; + var shouldShowLink = Object(external_lodash_["get"])(postType, ['viewable'], false); + + if (!isPublished && !willPublish) { + // If saving a non-published post, don't show notice. + noticeMessage = null; + } else if (isPublished && !willPublish) { + // If undoing publish status, show specific notice + noticeMessage = postType.labels.item_reverted_to_draft; + shouldShowLink = false; + } else if (!isPublished && willPublish) { + // If publishing or scheduling a post, show the corresponding + // publish message + noticeMessage = { + publish: postType.labels.item_published, + private: postType.labels.item_published_privately, + future: postType.labels.item_scheduled + }[post.status]; + } else { + // Generic fallback notice + noticeMessage = postType.labels.item_updated; + } + + if (noticeMessage) { + var actions = []; + + if (shouldShowLink) { + actions.push({ + label: postType.labels.view_item, + url: post.link + }); + } + + return [noticeMessage, { + id: SAVE_POST_NOTICE_ID, + actions: actions + }]; + } + + return []; +} +/** + * Builds the fail notification arguments for dispatch. + * + * @param {Object} data Incoming data to build the arguments with. + * + * @return {Array} Arguments for dispatch. An empty array signals no + * notification should be sent. + */ + +function getNotificationArgumentsForSaveFail(data) { + var post = data.post, + edits = data.edits, + error = data.error; + + if (error && 'rest_autosave_no_changes' === error.code) { + // Autosave requested a new autosave, but there were no changes. This shouldn't + // result in an error notice for the user. + return []; + } + + var publishStatus = ['publish', 'private', 'future']; + var isPublished = publishStatus.indexOf(post.status) !== -1; // If the post was being published, we show the corresponding publish error message + // Unless we publish an "updating failed" message + + var messages = { + publish: Object(external_this_wp_i18n_["__"])('Publishing failed'), + private: Object(external_this_wp_i18n_["__"])('Publishing failed'), + future: Object(external_this_wp_i18n_["__"])('Scheduling failed') + }; + var noticeMessage = !isPublished && publishStatus.indexOf(edits.status) !== -1 ? messages[edits.status] : Object(external_this_wp_i18n_["__"])('Updating failed'); + return [noticeMessage, { + id: SAVE_POST_NOTICE_ID + }]; +} +/** + * Builds the trash fail notification arguments for dispatch. + * + * @param {Object} data + * + * @return {Array} Arguments for dispatch. + */ + +function getNotificationArgumentsForTrashFail(data) { + return [data.error.message && data.error.code !== 'unknown_error' ? data.error.message : Object(external_this_wp_i18n_["__"])('Trashing failed'), { + id: TRASH_POST_NOTICE_ID + }]; +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/actions.js + + + + +var _marked = +/*#__PURE__*/ +regenerator_default.a.mark(savePost), + _marked2 = +/*#__PURE__*/ +regenerator_default.a.mark(refreshPost), + _marked3 = +/*#__PURE__*/ +regenerator_default.a.mark(trashPost), + _marked4 = +/*#__PURE__*/ +regenerator_default.a.mark(actions_autosave); + +/** + * External dependencies + */ + + +/** + * Internal dependencies + */ + + + + +/** + * Returns an action object used in signalling that editor has initialized with + * the specified post object and editor settings. + * + * @param {Object} post Post object. + * @param {Object} edits Initial edited attributes object. + * @param {Array?} template Block Template. + * + * @return {Object} Action object. + */ + +function setupEditor(post, edits, template) { + return { + type: 'SETUP_EDITOR', + post: post, + edits: edits, + template: template + }; +} +/** + * Returns an action object used in signalling that the latest version of the + * post has been received, either by initialization or save. + * + * @param {Object} post Post object. + * + * @return {Object} Action object. + */ + +function resetPost(post) { + return { + type: 'RESET_POST', + post: post + }; +} +/** + * Returns an action object used in signalling that the latest autosave of the + * post has been received, by initialization or autosave. + * + * @param {Object} post Autosave post object. + * + * @return {Object} Action object. + */ + +function resetAutosave(post) { + return { + type: 'RESET_AUTOSAVE', + post: post + }; +} +/** + * Optimistic action for dispatching that a post update request has started. + * + * @param {Object} options + * + * @return {Object} An action object + */ + +function __experimentalRequestPostUpdateStart() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + return { + type: 'REQUEST_POST_UPDATE_START', + optimist: { + type: redux_optimist["BEGIN"], + id: POST_UPDATE_TRANSACTION_ID + }, + options: options + }; +} +/** + * Optimistic action for indicating that the request post update has completed + * successfully. + * + * @param {Object} data The data for the action. + * @param {Object} data.previousPost The previous post prior to update. + * @param {Object} data.post The new post after update + * @param {boolean} data.isRevision Whether the post is a revision or not. + * @param {Object} data.options Options passed through from the original + * action dispatch. + * @param {Object} data.postType The post type object. + * + * @return {Object} Action object. + */ + +function __experimentalRequestPostUpdateSuccess(_ref) { + var previousPost = _ref.previousPost, + post = _ref.post, + isRevision = _ref.isRevision, + options = _ref.options, + postType = _ref.postType; + return { + type: 'REQUEST_POST_UPDATE_SUCCESS', + previousPost: previousPost, + post: post, + optimist: { + // Note: REVERT is not a failure case here. Rather, it + // is simply reversing the assumption that the updates + // were applied to the post proper, such that the post + // treated as having unsaved changes. + type: isRevision ? redux_optimist["REVERT"] : redux_optimist["COMMIT"], + id: POST_UPDATE_TRANSACTION_ID + }, + options: options, + postType: postType + }; +} +/** + * Optimistic action for indicating that the request post update has completed + * with a failure. + * + * @param {Object} data The data for the action + * @param {Object} data.post The post that failed updating. + * @param {Object} data.edits The fields that were being updated. + * @param {*} data.error The error from the failed call. + * @param {Object} data.options Options passed through from the original + * action dispatch. + * @return {Object} An action object + */ + +function __experimentalRequestPostUpdateFailure(_ref2) { + var post = _ref2.post, + edits = _ref2.edits, + error = _ref2.error, + options = _ref2.options; + return { + type: 'REQUEST_POST_UPDATE_FAILURE', + optimist: { + type: redux_optimist["REVERT"], + id: POST_UPDATE_TRANSACTION_ID + }, + post: post, + edits: edits, + error: error, + options: options + }; +} +/** + * Returns an action object used in signalling that a patch of updates for the + * latest version of the post have been received. + * + * @param {Object} edits Updated post fields. + * + * @return {Object} Action object. + */ + +function updatePost(edits) { + return { + type: 'UPDATE_POST', + edits: edits + }; +} +/** + * Returns an action object used to setup the editor state when first opening + * an editor. + * + * @param {Object} post Post object. + * + * @return {Object} Action object. + */ + +function setupEditorState(post) { + return { + type: 'SETUP_EDITOR_STATE', + post: post + }; +} +/** + * Returns an action object used in signalling that attributes of the post have + * been edited. + * + * @param {Object} edits Post attributes to edit. + * + * @return {Object} Action object. + */ + +function actions_editPost(edits) { + return { + type: 'EDIT_POST', + edits: edits + }; +} +/** + * Returns action object produced by the updatePost creator augmented by + * an optimist option that signals optimistically applying updates. + * + * @param {Object} edits Updated post fields. + * + * @return {Object} Action object. + */ + +function __experimentalOptimisticUpdatePost(edits) { + return Object(objectSpread["a" /* default */])({}, updatePost(edits), { + optimist: { + id: POST_UPDATE_TRANSACTION_ID + } + }); +} +/** + * Action generator for saving the current post in the editor. + * + * @param {Object} options + */ + +function savePost() { + var options, + isEditedPostSaveable, + edits, + isAutosave, + isEditedPostNew, + post, + editedPostContent, + toSend, + currentPostType, + postType, + path, + method, + autoSavePost, + newPost, + resetAction, + notifySuccessArgs, + notifyFailArgs, + _args = arguments; + return regenerator_default.a.wrap(function savePost$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + options = _args.length > 0 && _args[0] !== undefined ? _args[0] : {}; + _context.next = 3; + return controls_select(STORE_KEY, 'isEditedPostSaveable'); + + case 3: + isEditedPostSaveable = _context.sent; + + if (isEditedPostSaveable) { + _context.next = 6; + break; + } + + return _context.abrupt("return"); + + case 6: + _context.next = 8; + return controls_select(STORE_KEY, 'getPostEdits'); + + case 8: + edits = _context.sent; + isAutosave = !!options.isAutosave; + + if (isAutosave) { + edits = Object(external_lodash_["pick"])(edits, ['title', 'content', 'excerpt']); + } + + _context.next = 13; + return controls_select(STORE_KEY, 'isEditedPostNew'); + + case 13: + isEditedPostNew = _context.sent; + + // New posts (with auto-draft status) must be explicitly assigned draft + // status if there is not already a status assigned in edits (publish). + // Otherwise, they are wrongly left as auto-draft. Status is not always + // respected for autosaves, so it cannot simply be included in the pick + // above. This behavior relies on an assumption that an auto-draft post + // would never be saved by anyone other than the owner of the post, per + // logic within autosaves REST controller to save status field only for + // draft/auto-draft by current user. + // + // See: https://core.trac.wordpress.org/ticket/43316#comment:88 + // See: https://core.trac.wordpress.org/ticket/43316#comment:89 + if (isEditedPostNew) { + edits = Object(objectSpread["a" /* default */])({ + status: 'draft' + }, edits); + } + + _context.next = 17; + return controls_select(STORE_KEY, 'getCurrentPost'); + + case 17: + post = _context.sent; + _context.next = 20; + return controls_select(STORE_KEY, 'getEditedPostContent'); + + case 20: + editedPostContent = _context.sent; + toSend = Object(objectSpread["a" /* default */])({}, edits, { + content: editedPostContent, + id: post.id + }); + _context.next = 24; + return controls_select(STORE_KEY, 'getCurrentPostType'); + + case 24: + currentPostType = _context.sent; + _context.next = 27; + return resolveSelect('core', 'getPostType', currentPostType); + + case 27: + postType = _context.sent; + _context.next = 30; + return controls_dispatch(STORE_KEY, '__experimentalRequestPostUpdateStart', options); + + case 30: + _context.next = 32; + return controls_dispatch(STORE_KEY, '__experimentalOptimisticUpdatePost', toSend); + + case 32: + path = "/wp/v2/".concat(postType.rest_base, "/").concat(post.id); + method = 'PUT'; + + if (!isAutosave) { + _context.next = 43; + break; + } + + _context.next = 37; + return controls_select(STORE_KEY, 'getAutosave'); + + case 37: + autoSavePost = _context.sent; + // Ensure autosaves contain all expected fields, using autosave or + // post values as fallback if not otherwise included in edits. + toSend = Object(objectSpread["a" /* default */])({}, Object(external_lodash_["pick"])(post, ['title', 'content', 'excerpt']), autoSavePost, toSend); + path += '/autosaves'; + method = 'POST'; + _context.next = 47; + break; + + case 43: + _context.next = 45; + return controls_dispatch('core/notices', 'removeNotice', SAVE_POST_NOTICE_ID); + + case 45: + _context.next = 47; + return controls_dispatch('core/notices', 'removeNotice', 'autosave-exists'); + + case 47: + _context.prev = 47; + _context.next = 50; + return apiFetch({ + path: path, + method: method, + data: toSend + }); + + case 50: + newPost = _context.sent; + resetAction = isAutosave ? 'resetAutosave' : 'resetPost'; + _context.next = 54; + return controls_dispatch(STORE_KEY, resetAction, newPost); + + case 54: + _context.next = 56; + return controls_dispatch(STORE_KEY, '__experimentalRequestPostUpdateSuccess', { + previousPost: post, + post: newPost, + options: options, + postType: postType, + // An autosave may be processed by the server as a regular save + // when its update is requested by the author and the post was + // draft or auto-draft. + isRevision: newPost.id !== post.id + }); + + case 56: + notifySuccessArgs = getNotificationArgumentsForSaveSuccess({ + previousPost: post, + post: newPost, + postType: postType, + options: options + }); + + if (!(notifySuccessArgs.length > 0)) { + _context.next = 60; + break; + } + + _context.next = 60; + return controls_dispatch.apply(void 0, ['core/notices', 'createSuccessNotice'].concat(Object(toConsumableArray["a" /* default */])(notifySuccessArgs))); + + case 60: + _context.next = 70; + break; + + case 62: + _context.prev = 62; + _context.t0 = _context["catch"](47); + _context.next = 66; + return controls_dispatch(STORE_KEY, '__experimentalRequestPostUpdateFailure', { + post: post, + edits: edits, + error: _context.t0, + options: options + }); + + case 66: + notifyFailArgs = getNotificationArgumentsForSaveFail({ + post: post, + edits: edits, + error: _context.t0 + }); + + if (!(notifyFailArgs.length > 0)) { + _context.next = 70; + break; + } + + _context.next = 70; + return controls_dispatch.apply(void 0, ['core/notices', 'createErrorNotice'].concat(Object(toConsumableArray["a" /* default */])(notifyFailArgs))); + + case 70: + case "end": + return _context.stop(); + } + } + }, _marked, this, [[47, 62]]); +} +/** + * Action generator for handling refreshing the current post. + */ + +function refreshPost() { + var post, postTypeSlug, postType, newPost; + return regenerator_default.a.wrap(function refreshPost$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + _context2.next = 2; + return controls_select(STORE_KEY, 'getCurrentPost'); + + case 2: + post = _context2.sent; + _context2.next = 5; + return controls_select(STORE_KEY, 'getCurrentPostType'); + + case 5: + postTypeSlug = _context2.sent; + _context2.next = 8; + return resolveSelect('core', 'getPostType', postTypeSlug); + + case 8: + postType = _context2.sent; + _context2.next = 11; + return apiFetch({ + // Timestamp arg allows caller to bypass browser caching, which is + // expected for this specific function. + path: "/wp/v2/".concat(postType.rest_base, "/").concat(post.id) + "?context=edit&_timestamp=".concat(Date.now()) + }); + + case 11: + newPost = _context2.sent; + _context2.next = 14; + return controls_dispatch(STORE_KEY, 'resetPost', newPost); + + case 14: + case "end": + return _context2.stop(); + } + } + }, _marked2, this); +} +/** + * Action generator for trashing the current post in the editor. + */ + +function trashPost() { + var postTypeSlug, postType, post; + return regenerator_default.a.wrap(function trashPost$(_context3) { + while (1) { + switch (_context3.prev = _context3.next) { + case 0: + _context3.next = 2; + return controls_select(STORE_KEY, 'getCurrentPostType'); + + case 2: + postTypeSlug = _context3.sent; + _context3.next = 5; + return resolveSelect('core', 'getPostType', postTypeSlug); + + case 5: + postType = _context3.sent; + _context3.next = 8; + return controls_dispatch('core/notices', 'removeNotice', TRASH_POST_NOTICE_ID); + + case 8: + _context3.prev = 8; + _context3.next = 11; + return controls_select(STORE_KEY, 'getCurrentPost'); + + case 11: + post = _context3.sent; + _context3.next = 14; + return apiFetch({ + path: "/wp/v2/".concat(postType.rest_base, "/").concat(post.id), + method: 'DELETE' + }); + + case 14: + _context3.next = 16; + return controls_dispatch(STORE_KEY, 'resetPost', Object(objectSpread["a" /* default */])({}, post, { + status: 'trash' + })); + + case 16: + _context3.next = 22; + break; + + case 18: + _context3.prev = 18; + _context3.t0 = _context3["catch"](8); + _context3.next = 22; + return controls_dispatch.apply(void 0, ['core/notices', 'createErrorNotice'].concat(Object(toConsumableArray["a" /* default */])(getNotificationArgumentsForTrashFail({ + error: _context3.t0 + })))); + + case 22: + case "end": + return _context3.stop(); + } + } + }, _marked3, this, [[8, 18]]); +} +/** + * Action generator used in signalling that the post should autosave. + * + * @param {Object?} options Extra flags to identify the autosave. + */ + +function actions_autosave(options) { + return regenerator_default.a.wrap(function autosave$(_context4) { + while (1) { + switch (_context4.prev = _context4.next) { + case 0: + _context4.next = 2; + return controls_dispatch(STORE_KEY, 'savePost', Object(objectSpread["a" /* default */])({ + isAutosave: true + }, options)); + + case 2: + case "end": + return _context4.stop(); + } + } + }, _marked4, this); +} +/** + * Returns an action object used in signalling that undo history should + * restore last popped state. + * + * @return {Object} Action object. + */ + +function actions_redo() { + return { + type: 'REDO' + }; +} +/** + * Returns an action object used in signalling that undo history should pop. + * + * @return {Object} Action object. + */ + +function actions_undo() { + return { + type: 'UNDO' + }; +} +/** + * Returns an action object used in signalling that undo history record should + * be created. + * + * @return {Object} Action object. + */ + +function createUndoLevel() { + return { + type: 'CREATE_UNDO_LEVEL' + }; +} +/** + * Returns an action object used to lock the editor. + * + * @param {Object} lock Details about the post lock status, user, and nonce. + * + * @return {Object} Action object. + */ + +function updatePostLock(lock) { + return { + type: 'UPDATE_POST_LOCK', + lock: lock + }; +} +/** + * Returns an action object used to fetch a single reusable block or all + * reusable blocks from the REST API into the store. + * + * @param {?string} id If given, only a single reusable block with this ID will + * be fetched. + * + * @return {Object} Action object. + */ + +function __experimentalFetchReusableBlocks(id) { + return { + type: 'FETCH_REUSABLE_BLOCKS', + id: id + }; +} +/** + * Returns an action object used in signalling that reusable blocks have been + * received. `results` is an array of objects containing: + * - `reusableBlock` - Details about how the reusable block is persisted. + * - `parsedBlock` - The original block. + * + * @param {Object[]} results Reusable blocks received. + * + * @return {Object} Action object. + */ + +function __experimentalReceiveReusableBlocks(results) { + return { + type: 'RECEIVE_REUSABLE_BLOCKS', + results: results + }; +} +/** + * Returns an action object used to save a reusable block that's in the store to + * the REST API. + * + * @param {Object} id The ID of the reusable block to save. + * + * @return {Object} Action object. + */ + +function __experimentalSaveReusableBlock(id) { + return { + type: 'SAVE_REUSABLE_BLOCK', + id: id + }; +} +/** + * Returns an action object used to delete a reusable block via the REST API. + * + * @param {number} id The ID of the reusable block to delete. + * + * @return {Object} Action object. + */ + +function __experimentalDeleteReusableBlock(id) { + return { + type: 'DELETE_REUSABLE_BLOCK', + id: id + }; +} +/** + * Returns an action object used in signalling that a reusable block's title is + * to be updated. + * + * @param {number} id The ID of the reusable block to update. + * @param {string} title The new title. + * + * @return {Object} Action object. + */ + +function __experimentalUpdateReusableBlockTitle(id, title) { + return { + type: 'UPDATE_REUSABLE_BLOCK_TITLE', + id: id, + title: title + }; +} +/** + * Returns an action object used to convert a reusable block into a static + * block. + * + * @param {string} clientId The client ID of the block to attach. + * + * @return {Object} Action object. + */ + +function __experimentalConvertBlockToStatic(clientId) { + return { + type: 'CONVERT_BLOCK_TO_STATIC', + clientId: clientId + }; +} +/** + * Returns an action object used to convert a static block into a reusable + * block. + * + * @param {string} clientIds The client IDs of the block to detach. + * + * @return {Object} Action object. + */ + +function __experimentalConvertBlockToReusable(clientIds) { + return { + type: 'CONVERT_BLOCK_TO_REUSABLE', + clientIds: Object(external_lodash_["castArray"])(clientIds) + }; +} +/** + * Returns an action object used in signalling that the user has enabled the + * publish sidebar. + * + * @return {Object} Action object + */ + +function enablePublishSidebar() { + return { + type: 'ENABLE_PUBLISH_SIDEBAR' + }; +} +/** + * Returns an action object used in signalling that the user has disabled the + * publish sidebar. + * + * @return {Object} Action object + */ + +function disablePublishSidebar() { + return { + type: 'DISABLE_PUBLISH_SIDEBAR' + }; +} +/** + * Returns an action object used to signal that post saving is locked. + * + * @param {string} lockName The lock name. + * + * @return {Object} Action object + */ + +function lockPostSaving(lockName) { + return { + type: 'LOCK_POST_SAVING', + lockName: lockName + }; +} +/** + * Returns an action object used to signal that post saving is unlocked. + * + * @param {string} lockName The lock name. + * + * @return {Object} Action object + */ + +function unlockPostSaving(lockName) { + return { + type: 'UNLOCK_POST_SAVING', + lockName: lockName + }; +} +/** + * Returns an action object used to signal that the blocks have been updated. + * + * @param {Array} blocks Block Array. + * @param {?Object} options Optional options. + * + * @return {Object} Action object + */ + +function actions_resetEditorBlocks(blocks) { + var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + return { + type: 'RESET_EDITOR_BLOCKS', + blocks: blocks, + shouldCreateUndoLevel: options.__unstableShouldCreateUndoLevel !== false + }; +} +/* + * Returns an action object used in signalling that the post editor settings have been updated. + * + * @param {Object} settings Updated settings + * + * @return {Object} Action object + */ + +function updateEditorSettings(settings) { + return { + type: 'UPDATE_EDITOR_SETTINGS', + settings: settings + }; +} +/** + * Backward compatibility + */ + +var actions_getBlockEditorAction = function getBlockEditorAction(name) { + return ( + /*#__PURE__*/ + regenerator_default.a.mark(function _callee() { + var _len, + args, + _key, + _args5 = arguments; + + return regenerator_default.a.wrap(function _callee$(_context5) { + while (1) { + switch (_context5.prev = _context5.next) { + case 0: + for (_len = _args5.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = _args5[_key]; + } + + _context5.next = 3; + return controls_dispatch.apply(void 0, ['core/block-editor', name].concat(args)); + + case 3: + case "end": + return _context5.stop(); + } + } + }, _callee, this); + }) + ); +}; + +var resetBlocks = actions_getBlockEditorAction('resetBlocks'); +var receiveBlocks = actions_getBlockEditorAction('receiveBlocks'); +var updateBlock = actions_getBlockEditorAction('updateBlock'); +var updateBlockAttributes = actions_getBlockEditorAction('updateBlockAttributes'); +var selectBlock = actions_getBlockEditorAction('selectBlock'); +var startMultiSelect = actions_getBlockEditorAction('startMultiSelect'); +var stopMultiSelect = actions_getBlockEditorAction('stopMultiSelect'); +var multiSelect = actions_getBlockEditorAction('multiSelect'); +var clearSelectedBlock = actions_getBlockEditorAction('clearSelectedBlock'); +var toggleSelection = actions_getBlockEditorAction('toggleSelection'); +var replaceBlocks = actions_getBlockEditorAction('replaceBlocks'); +var replaceBlock = actions_getBlockEditorAction('replaceBlock'); +var moveBlocksDown = actions_getBlockEditorAction('moveBlocksDown'); +var moveBlocksUp = actions_getBlockEditorAction('moveBlocksUp'); +var moveBlockToPosition = actions_getBlockEditorAction('moveBlockToPosition'); +var insertBlock = actions_getBlockEditorAction('insertBlock'); +var insertBlocks = actions_getBlockEditorAction('insertBlocks'); +var showInsertionPoint = actions_getBlockEditorAction('showInsertionPoint'); +var hideInsertionPoint = actions_getBlockEditorAction('hideInsertionPoint'); +var setTemplateValidity = actions_getBlockEditorAction('setTemplateValidity'); +var synchronizeTemplate = actions_getBlockEditorAction('synchronizeTemplate'); +var mergeBlocks = actions_getBlockEditorAction('mergeBlocks'); +var removeBlocks = actions_getBlockEditorAction('removeBlocks'); +var removeBlock = actions_getBlockEditorAction('removeBlock'); +var toggleBlockMode = actions_getBlockEditorAction('toggleBlockMode'); +var startTyping = actions_getBlockEditorAction('startTyping'); +var stopTyping = actions_getBlockEditorAction('stopTyping'); +var enterFormattedText = actions_getBlockEditorAction('enterFormattedText'); +var exitFormattedText = actions_getBlockEditorAction('exitFormattedText'); +var insertDefaultBlock = actions_getBlockEditorAction('insertDefaultBlock'); +var updateBlockListSettings = actions_getBlockEditorAction('updateBlockListSettings'); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js +var asyncToGenerator = __webpack_require__(44); + +// EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js +var rememo = __webpack_require__(30); + +// EXTERNAL MODULE: external {"this":["wp","date"]} +var external_this_wp_date_ = __webpack_require__(50); + +// EXTERNAL MODULE: external {"this":["wp","autop"]} +var external_this_wp_autop_ = __webpack_require__(66); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/selectors.js + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + +/** + * Shared reference to an empty object for cases where it is important to avoid + * returning a new object reference on every invocation, as in a connected or + * other pure component which performs `shouldComponentUpdate` check on props. + * This should be used as a last resort, since the normalized data should be + * maintained by the reducer result in state. + */ + +var EMPTY_OBJECT = {}; +/** + * Returns true if any past editor history snapshots exist, or false otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether undo history exists. + */ + +function hasEditorUndo(state) { + return state.editor.past.length > 0; +} +/** + * Returns true if any future editor history snapshots exist, or false + * otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether redo history exists. + */ + +function hasEditorRedo(state) { + return state.editor.future.length > 0; +} +/** + * Returns true if the currently edited post is yet to be saved, or false if + * the post has been saved. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post is new. + */ + +function selectors_isEditedPostNew(state) { + return selectors_getCurrentPost(state).status === 'auto-draft'; +} +/** + * Returns true if content includes unsaved changes, or false otherwise. + * + * @param {Object} state Editor state. + * + * @return {boolean} Whether content includes unsaved changes. + */ + +function hasChangedContent(state) { + return state.editor.present.blocks.isDirty || // `edits` is intended to contain only values which are different from + // the saved post, so the mere presence of a property is an indicator + // that the value is different than what is known to be saved. While + // content in Visual mode is represented by the blocks state, in Text + // mode it is tracked by `edits.content`. + 'content' in state.editor.present.edits; +} +/** + * Returns true if there are unsaved values for the current edit session, or + * false if the editing state matches the saved or new post. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether unsaved values exist. + */ + +function selectors_isEditedPostDirty(state) { + if (hasChangedContent(state)) { + return true; + } // Edits should contain only fields which differ from the saved post (reset + // at initial load and save complete). Thus, a non-empty edits state can be + // inferred to contain unsaved values. + + + if (Object.keys(state.editor.present.edits).length > 0) { + return true; + } // Edits and change detection are reset at the start of a save, but a post + // is still considered dirty until the point at which the save completes. + // Because the save is performed optimistically, the prior states are held + // until committed. These can be referenced to determine whether there's a + // chance that state may be reverted into one considered dirty. + + + return inSomeHistory(state, selectors_isEditedPostDirty); +} +/** + * Returns true if there are no unsaved values for the current edit session and + * if the currently edited post is new (has never been saved before). + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether new post and unsaved values exist. + */ + +function selectors_isCleanNewPost(state) { + return !selectors_isEditedPostDirty(state) && selectors_isEditedPostNew(state); +} +/** + * Returns the post currently being edited in its last known saved state, not + * including unsaved edits. Returns an object containing relevant default post + * values if the post has not yet been saved. + * + * @param {Object} state Global application state. + * + * @return {Object} Post object. + */ + +function selectors_getCurrentPost(state) { + return state.currentPost; +} +/** + * Returns the post type of the post currently being edited. + * + * @param {Object} state Global application state. + * + * @return {string} Post type. + */ + +function selectors_getCurrentPostType(state) { + return state.currentPost.type; +} +/** + * Returns the ID of the post currently being edited, or null if the post has + * not yet been saved. + * + * @param {Object} state Global application state. + * + * @return {?number} ID of current post. + */ + +function selectors_getCurrentPostId(state) { + return selectors_getCurrentPost(state).id || null; +} +/** + * Returns the number of revisions of the post currently being edited. + * + * @param {Object} state Global application state. + * + * @return {number} Number of revisions. + */ + +function getCurrentPostRevisionsCount(state) { + return Object(external_lodash_["get"])(selectors_getCurrentPost(state), ['_links', 'version-history', 0, 'count'], 0); +} +/** + * Returns the last revision ID of the post currently being edited, + * or null if the post has no revisions. + * + * @param {Object} state Global application state. + * + * @return {?number} ID of the last revision. + */ + +function getCurrentPostLastRevisionId(state) { + return Object(external_lodash_["get"])(selectors_getCurrentPost(state), ['_links', 'predecessor-version', 0, 'id'], null); +} +/** + * Returns any post values which have been changed in the editor but not yet + * been saved. + * + * @param {Object} state Global application state. + * + * @return {Object} Object of key value pairs comprising unsaved edits. + */ + +var getPostEdits = Object(rememo["a" /* default */])(function (state) { + return Object(objectSpread["a" /* default */])({}, state.initialEdits, state.editor.present.edits); +}, function (state) { + return [state.editor.present.edits, state.initialEdits]; +}); +/** + * Returns a new reference when edited values have changed. This is useful in + * inferring where an edit has been made between states by comparison of the + * return values using strict equality. + * + * @example + * + * ``` + * const hasEditOccurred = ( + * getReferenceByDistinctEdits( beforeState ) !== + * getReferenceByDistinctEdits( afterState ) + * ); + * ``` + * + * @param {Object} state Editor state. + * + * @return {*} A value whose reference will change only when an edit occurs. + */ + +var getReferenceByDistinctEdits = Object(rememo["a" /* default */])(function () { + return []; +}, function (state) { + return [state.editor]; +}); +/** + * Returns an attribute value of the saved post. + * + * @param {Object} state Global application state. + * @param {string} attributeName Post attribute name. + * + * @return {*} Post attribute value. + */ + +function selectors_getCurrentPostAttribute(state, attributeName) { + var post = selectors_getCurrentPost(state); + + if (post.hasOwnProperty(attributeName)) { + return post[attributeName]; + } +} +/** + * Returns a single attribute of the post being edited, preferring the unsaved + * edit if one exists, but merging with the attribute value for the last known + * saved state of the post (this is needed for some nested attributes like meta). + * + * @param {Object} state Global application state. + * @param {string} attributeName Post attribute name. + * + * @return {*} Post attribute value. + */ + +var getNestedEditedPostProperty = Object(rememo["a" /* default */])(function (state, attributeName) { + var edits = getPostEdits(state); + + if (!edits.hasOwnProperty(attributeName)) { + return selectors_getCurrentPostAttribute(state, attributeName); + } + + return Object(objectSpread["a" /* default */])({}, selectors_getCurrentPostAttribute(state, attributeName), edits[attributeName]); +}, function (state, attributeName) { + return [Object(external_lodash_["get"])(state.editor.present.edits, [attributeName], EMPTY_OBJECT), Object(external_lodash_["get"])(state.currentPost, [attributeName], EMPTY_OBJECT)]; +}); +/** + * Returns a single attribute of the post being edited, preferring the unsaved + * edit if one exists, but falling back to the attribute for the last known + * saved state of the post. + * + * @param {Object} state Global application state. + * @param {string} attributeName Post attribute name. + * + * @return {*} Post attribute value. + */ + +function selectors_getEditedPostAttribute(state, attributeName) { + // Special cases + switch (attributeName) { + case 'content': + return getEditedPostContent(state); + } // Fall back to saved post value if not edited. + + + var edits = getPostEdits(state); + + if (!edits.hasOwnProperty(attributeName)) { + return selectors_getCurrentPostAttribute(state, attributeName); + } // Merge properties are objects which contain only the patch edit in state, + // and thus must be merged with the current post attribute. + + + if (EDIT_MERGE_PROPERTIES.has(attributeName)) { + return getNestedEditedPostProperty(state, attributeName); + } + + return edits[attributeName]; +} +/** + * Returns an attribute value of the current autosave revision for a post, or + * null if there is no autosave for the post. + * + * @param {Object} state Global application state. + * @param {string} attributeName Autosave attribute name. + * + * @return {*} Autosave attribute value. + */ + +function getAutosaveAttribute(state, attributeName) { + if (!hasAutosave(state)) { + return null; + } + + var autosave = getAutosave(state); + + if (autosave.hasOwnProperty(attributeName)) { + return autosave[attributeName]; + } +} +/** + * Returns the current visibility of the post being edited, preferring the + * unsaved value if different than the saved post. The return value is one of + * "private", "password", or "public". + * + * @param {Object} state Global application state. + * + * @return {string} Post visibility. + */ + +function selectors_getEditedPostVisibility(state) { + var status = selectors_getEditedPostAttribute(state, 'status'); + + if (status === 'private') { + return 'private'; + } + + var password = selectors_getEditedPostAttribute(state, 'password'); + + if (password) { + return 'password'; + } + + return 'public'; +} +/** + * Returns true if post is pending review. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether current post is pending review. + */ + +function isCurrentPostPending(state) { + return selectors_getCurrentPost(state).status === 'pending'; +} +/** + * Return true if the current post has already been published. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post has been published. + */ + +function selectors_isCurrentPostPublished(state) { + var post = selectors_getCurrentPost(state); + return ['publish', 'private'].indexOf(post.status) !== -1 || post.status === 'future' && !Object(external_this_wp_date_["isInTheFuture"])(new Date(Number(Object(external_this_wp_date_["getDate"])(post.date)) - ONE_MINUTE_IN_MS)); +} +/** + * Returns true if post is already scheduled. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether current post is scheduled to be posted. + */ + +function selectors_isCurrentPostScheduled(state) { + return selectors_getCurrentPost(state).status === 'future' && !selectors_isCurrentPostPublished(state); +} +/** + * Return true if the post being edited can be published. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post can been published. + */ + +function selectors_isEditedPostPublishable(state) { + var post = selectors_getCurrentPost(state); // TODO: Post being publishable should be superset of condition of post + // being saveable. Currently this restriction is imposed at UI. + // + // See: (`isButtonEnabled` assigned by `isSaveable`) + + return selectors_isEditedPostDirty(state) || ['publish', 'private', 'future'].indexOf(post.status) === -1; +} +/** + * Returns true if the post can be saved, or false otherwise. A post must + * contain a title, an excerpt, or non-empty content to be valid for save. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post can be saved. + */ + +function selectors_isEditedPostSaveable(state) { + if (selectors_isSavingPost(state)) { + return false; + } // TODO: Post should not be saveable if not dirty. Cannot be added here at + // this time since posts where meta boxes are present can be saved even if + // the post is not dirty. Currently this restriction is imposed at UI, but + // should be moved here. + // + // See: `isEditedPostPublishable` (includes `isEditedPostDirty` condition) + // See: (`forceIsDirty` prop) + // See: (`forceIsDirty` prop) + // See: https://github.com/WordPress/gutenberg/pull/4184 + + + return !!selectors_getEditedPostAttribute(state, 'title') || !!selectors_getEditedPostAttribute(state, 'excerpt') || !isEditedPostEmpty(state); +} +/** + * Returns true if the edited post has content. A post has content if it has at + * least one saveable block or otherwise has a non-empty content property + * assigned. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether post has content. + */ + +function isEditedPostEmpty(state) { + // While the condition of truthy content string is sufficient to determine + // emptiness, testing saveable blocks length is a trivial operation. Since + // this function can be called frequently, optimize for the fast case as a + // condition of the mere existence of blocks. Note that the value of edited + // content takes precedent over block content, and must fall through to the + // default logic. + var blocks = state.editor.present.blocks.value; + + if (blocks.length && !('content' in getPostEdits(state))) { + // Pierce the abstraction of the serializer in knowing that blocks are + // joined with with newlines such that even if every individual block + // produces an empty save result, the serialized content is non-empty. + if (blocks.length > 1) { + return false; + } // There are two conditions under which the optimization cannot be + // assumed, and a fallthrough to getEditedPostContent must occur: + // + // 1. getBlocksForSerialization has special treatment in omitting a + // single unmodified default block. + // 2. Comment delimiters are omitted for a freeform or unregistered + // block in its serialization. The freeform block specifically may + // produce an empty string in its saved output. + // + // For all other content, the single block is assumed to make a post + // non-empty, if only by virtue of its own comment delimiters. + + + var blockName = blocks[0].name; + + if (blockName !== Object(external_this_wp_blocks_["getDefaultBlockName"])() && blockName !== Object(external_this_wp_blocks_["getFreeformContentHandlerName"])()) { + return false; + } + } + + return !getEditedPostContent(state); +} +/** + * Returns true if the post can be autosaved, or false otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post can be autosaved. + */ + +function selectors_isEditedPostAutosaveable(state) { + // A post must contain a title, an excerpt, or non-empty content to be valid for autosaving. + if (!selectors_isEditedPostSaveable(state)) { + return false; + } // If we don't already have an autosave, the post is autosaveable. + + + if (!hasAutosave(state)) { + return true; + } // To avoid an expensive content serialization, use the content dirtiness + // flag in place of content field comparison against the known autosave. + // This is not strictly accurate, and relies on a tolerance toward autosave + // request failures for unnecessary saves. + + + if (hasChangedContent(state)) { + return true; + } // If the title, excerpt or content has changed, the post is autosaveable. + + + var autosave = getAutosave(state); + return ['title', 'excerpt'].some(function (field) { + return autosave[field] !== selectors_getEditedPostAttribute(state, field); + }); +} +/** + * Returns the current autosave, or null if one is not set (i.e. if the post + * has yet to be autosaved, or has been saved or published since the last + * autosave). + * + * @param {Object} state Editor state. + * + * @return {?Object} Current autosave, if exists. + */ + +function getAutosave(state) { + return state.autosave; +} +/** + * Returns the true if there is an existing autosave, otherwise false. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether there is an existing autosave. + */ + +function hasAutosave(state) { + return !!getAutosave(state); +} +/** + * Return true if the post being edited is being scheduled. Preferring the + * unsaved status values. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post has been published. + */ + +function selectors_isEditedPostBeingScheduled(state) { + var date = selectors_getEditedPostAttribute(state, 'date'); // Offset the date by one minute (network latency) + + var checkedDate = new Date(Number(Object(external_this_wp_date_["getDate"])(date)) - ONE_MINUTE_IN_MS); + return Object(external_this_wp_date_["isInTheFuture"])(checkedDate); +} +/** + * Returns whether the current post should be considered to have a "floating" + * date (i.e. that it would publish "Immediately" rather than at a set time). + * + * Unlike in the PHP backend, the REST API returns a full date string for posts + * where the 0000-00-00T00:00:00 placeholder is present in the database. To + * infer that a post is set to publish "Immediately" we check whether the date + * and modified date are the same. + * + * @param {Object} state Editor state. + * + * @return {boolean} Whether the edited post has a floating date value. + */ + +function isEditedPostDateFloating(state) { + var date = selectors_getEditedPostAttribute(state, 'date'); + var modified = selectors_getEditedPostAttribute(state, 'modified'); + var status = selectors_getEditedPostAttribute(state, 'status'); + + if (status === 'draft' || status === 'auto-draft' || status === 'pending') { + return date === modified; + } + + return false; +} +/** + * Returns true if the post is currently being saved, or false otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether post is being saved. + */ + +function selectors_isSavingPost(state) { + return state.saving.requesting; +} +/** + * Returns true if a previous post save was attempted successfully, or false + * otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post was saved successfully. + */ + +function didPostSaveRequestSucceed(state) { + return state.saving.successful; +} +/** + * Returns true if a previous post save was attempted but failed, or false + * otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post save failed. + */ + +function didPostSaveRequestFail(state) { + return !!state.saving.error; +} +/** + * Returns true if the post is autosaving, or false otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post is autosaving. + */ + +function selectors_isAutosavingPost(state) { + return selectors_isSavingPost(state) && !!state.saving.options.isAutosave; +} +/** + * Returns true if the post is being previewed, or false otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the post is being previewed. + */ + +function isPreviewingPost(state) { + return selectors_isSavingPost(state) && !!state.saving.options.isPreview; +} +/** + * Returns the post preview link + * + * @param {Object} state Global application state. + * + * @return {string?} Preview Link. + */ + +function selectors_getEditedPostPreviewLink(state) { + var featuredImageId = selectors_getEditedPostAttribute(state, 'featured_media'); + var previewLink = state.previewLink; + + if (previewLink && featuredImageId) { + return Object(external_this_wp_url_["addQueryArgs"])(previewLink, { + _thumbnail_id: featuredImageId + }); + } + + return previewLink; +} +/** + * Returns a suggested post format for the current post, inferred only if there + * is a single block within the post and it is of a type known to match a + * default post format. Returns null if the format cannot be determined. + * + * @param {Object} state Global application state. + * + * @return {?string} Suggested post format. + */ + +function selectors_getSuggestedPostFormat(state) { + var blocks = state.editor.present.blocks.value; + var name; // If there is only one block in the content of the post grab its name + // so we can derive a suitable post format from it. + + if (blocks.length === 1) { + name = blocks[0].name; + } // If there are two blocks in the content and the last one is a text blocks + // grab the name of the first one to also suggest a post format from it. + + + if (blocks.length === 2) { + if (blocks[1].name === 'core/paragraph') { + name = blocks[0].name; + } + } // We only convert to default post formats in core. + + + switch (name) { + case 'core/image': + return 'image'; + + case 'core/quote': + case 'core/pullquote': + return 'quote'; + + case 'core/gallery': + return 'gallery'; + + case 'core/video': + case 'core-embed/youtube': + case 'core-embed/vimeo': + return 'video'; + + case 'core/audio': + case 'core-embed/spotify': + case 'core-embed/soundcloud': + return 'audio'; + } + + return null; +} +/** + * Returns a set of blocks which are to be used in consideration of the post's + * generated save content. + * + * @param {Object} state Editor state. + * + * @return {WPBlock[]} Filtered set of blocks for save. + */ + +function getBlocksForSerialization(state) { + var blocks = state.editor.present.blocks.value; // WARNING: Any changes to the logic of this function should be verified + // against the implementation of isEditedPostEmpty, which bypasses this + // function for performance' sake, in an assumption of this current logic + // being irrelevant to the optimized condition of emptiness. + // A single unmodified default block is assumed to be equivalent to an + // empty post. + + var isSingleUnmodifiedDefaultBlock = blocks.length === 1 && Object(external_this_wp_blocks_["isUnmodifiedDefaultBlock"])(blocks[0]); + + if (isSingleUnmodifiedDefaultBlock) { + return []; + } + + return blocks; +} +/** + * Returns the content of the post being edited, preferring raw string edit + * before falling back to serialization of block state. + * + * @param {Object} state Global application state. + * + * @return {string} Post content. + */ + +var getEditedPostContent = Object(rememo["a" /* default */])(function (state) { + var edits = getPostEdits(state); + + if ('content' in edits) { + return edits.content; + } + + var blocks = getBlocksForSerialization(state); + var content = Object(external_this_wp_blocks_["serialize"])(blocks); // For compatibility purposes, treat a post consisting of a single + // freeform block as legacy content and downgrade to a pre-block-editor + // removep'd content format. + + var isSingleFreeformBlock = blocks.length === 1 && blocks[0].name === Object(external_this_wp_blocks_["getFreeformContentHandlerName"])(); + + if (isSingleFreeformBlock) { + return Object(external_this_wp_autop_["removep"])(content); + } + + return content; +}, function (state) { + return [state.editor.present.blocks.value, state.editor.present.edits.content, state.initialEdits.content]; +}); +/** + * Returns the reusable block with the given ID. + * + * @param {Object} state Global application state. + * @param {number|string} ref The reusable block's ID. + * + * @return {Object} The reusable block, or null if none exists. + */ + +var __experimentalGetReusableBlock = Object(rememo["a" /* default */])(function (state, ref) { + var block = state.reusableBlocks.data[ref]; + + if (!block) { + return null; + } + + var isTemporary = isNaN(parseInt(ref)); + return Object(objectSpread["a" /* default */])({}, block, { + id: isTemporary ? ref : +ref, + isTemporary: isTemporary + }); +}, function (state, ref) { + return [state.reusableBlocks.data[ref]]; +}); +/** + * Returns whether or not the reusable block with the given ID is being saved. + * + * @param {Object} state Global application state. + * @param {string} ref The reusable block's ID. + * + * @return {boolean} Whether or not the reusable block is being saved. + */ + +function __experimentalIsSavingReusableBlock(state, ref) { + return state.reusableBlocks.isSaving[ref] || false; +} +/** + * Returns true if the reusable block with the given ID is being fetched, or + * false otherwise. + * + * @param {Object} state Global application state. + * @param {string} ref The reusable block's ID. + * + * @return {boolean} Whether the reusable block is being fetched. + */ + +function __experimentalIsFetchingReusableBlock(state, ref) { + return !!state.reusableBlocks.isFetching[ref]; +} +/** + * Returns an array of all reusable blocks. + * + * @param {Object} state Global application state. + * + * @return {Array} An array of all reusable blocks. + */ + +var __experimentalGetReusableBlocks = Object(rememo["a" /* default */])(function (state) { + return Object(external_lodash_["map"])(state.reusableBlocks.data, function (value, ref) { + return __experimentalGetReusableBlock(state, ref); + }); +}, function (state) { + return [state.reusableBlocks.data]; +}); +/** + * Returns state object prior to a specified optimist transaction ID, or `null` + * if the transaction corresponding to the given ID cannot be found. + * + * @param {Object} state Current global application state. + * @param {Object} transactionId Optimist transaction ID. + * + * @return {Object} Global application state prior to transaction. + */ + +function getStateBeforeOptimisticTransaction(state, transactionId) { + var transaction = Object(external_lodash_["find"])(state.optimist, function (entry) { + return entry.beforeState && Object(external_lodash_["get"])(entry.action, ['optimist', 'id']) === transactionId; + }); + return transaction ? transaction.beforeState : null; +} +/** + * Returns true if the post is being published, or false otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether post is being published. + */ + +function selectors_isPublishingPost(state) { + if (!selectors_isSavingPost(state)) { + return false; + } // Saving is optimistic, so assume that current post would be marked as + // published if publishing + + + if (!selectors_isCurrentPostPublished(state)) { + return false; + } // Use post update transaction ID to retrieve the state prior to the + // optimistic transaction + + + var stateBeforeRequest = getStateBeforeOptimisticTransaction(state, POST_UPDATE_TRANSACTION_ID); // Consider as publishing when current post prior to request was not + // considered published + + return !!stateBeforeRequest && !selectors_isCurrentPostPublished(stateBeforeRequest); +} +/** + * Returns whether the permalink is editable or not. + * + * @param {Object} state Editor state. + * + * @return {boolean} Whether or not the permalink is editable. + */ + +function selectors_isPermalinkEditable(state) { + var permalinkTemplate = selectors_getEditedPostAttribute(state, 'permalink_template'); + return PERMALINK_POSTNAME_REGEX.test(permalinkTemplate); +} +/** + * Returns the permalink for the post. + * + * @param {Object} state Editor state. + * + * @return {?string} The permalink, or null if the post is not viewable. + */ + +function getPermalink(state) { + var permalinkParts = selectors_getPermalinkParts(state); + + if (!permalinkParts) { + return null; + } + + var prefix = permalinkParts.prefix, + postName = permalinkParts.postName, + suffix = permalinkParts.suffix; + + if (selectors_isPermalinkEditable(state)) { + return prefix + postName + suffix; + } + + return prefix; +} +/** + * Returns the permalink for a post, split into it's three parts: the prefix, + * the postName, and the suffix. + * + * @param {Object} state Editor state. + * + * @return {Object} An object containing the prefix, postName, and suffix for + * the permalink, or null if the post is not viewable. + */ + +function selectors_getPermalinkParts(state) { + var permalinkTemplate = selectors_getEditedPostAttribute(state, 'permalink_template'); + + if (!permalinkTemplate) { + return null; + } + + var postName = selectors_getEditedPostAttribute(state, 'slug') || selectors_getEditedPostAttribute(state, 'generated_slug'); + + var _permalinkTemplate$sp = permalinkTemplate.split(PERMALINK_POSTNAME_REGEX), + _permalinkTemplate$sp2 = Object(slicedToArray["a" /* default */])(_permalinkTemplate$sp, 2), + prefix = _permalinkTemplate$sp2[0], + suffix = _permalinkTemplate$sp2[1]; + + return { + prefix: prefix, + postName: postName, + suffix: suffix + }; +} +/** + * Returns true if an optimistic transaction is pending commit, for which the + * before state satisfies the given predicate function. + * + * @param {Object} state Editor state. + * @param {Function} predicate Function given state, returning true if match. + * + * @return {boolean} Whether predicate matches for some history. + */ + +function inSomeHistory(state, predicate) { + var optimist = state.optimist; // In recursion, optimist state won't exist. Assume exhausted options. + + if (!optimist) { + return false; + } + + return optimist.some(function (_ref) { + var beforeState = _ref.beforeState; + return beforeState && predicate(beforeState); + }); +} +/** + * Returns whether the post is locked. + * + * @param {Object} state Global application state. + * + * @return {boolean} Is locked. + */ + +function isPostLocked(state) { + return state.postLock.isLocked; +} +/** + * Returns whether post saving is locked. + * + * @param {Object} state Global application state. + * + * @return {boolean} Is locked. + */ + +function selectors_isPostSavingLocked(state) { + return Object.keys(state.postSavingLock).length > 0; +} +/** + * Returns whether the edition of the post has been taken over. + * + * @param {Object} state Global application state. + * + * @return {boolean} Is post lock takeover. + */ + +function isPostLockTakeover(state) { + return state.postLock.isTakeover; +} +/** + * Returns details about the post lock user. + * + * @param {Object} state Global application state. + * + * @return {Object} A user object. + */ + +function getPostLockUser(state) { + return state.postLock.user; +} +/** + * Returns the active post lock. + * + * @param {Object} state Global application state. + * + * @return {Object} The lock object. + */ + +function getActivePostLock(state) { + return state.postLock.activePostLock; +} +/** + * Returns whether or not the user has the unfiltered_html capability. + * + * @param {Object} state Editor state. + * + * @return {boolean} Whether the user can or can't post unfiltered HTML. + */ + +function canUserUseUnfilteredHTML(state) { + return Object(external_lodash_["has"])(selectors_getCurrentPost(state), ['_links', 'wp:action-unfiltered-html']); +} +/** + * Returns whether the pre-publish panel should be shown + * or skipped when the user clicks the "publish" button. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the pre-publish panel should be shown or not. + */ + +function selectors_isPublishSidebarEnabled(state) { + if (state.preferences.hasOwnProperty('isPublishSidebarEnabled')) { + return state.preferences.isPublishSidebarEnabled; + } + + return PREFERENCES_DEFAULTS.isPublishSidebarEnabled; +} +/** + * Return the current block list. + * + * @param {Object} state + * @return {Array} Block list. + */ + +function getEditorBlocks(state) { + return state.editor.present.blocks.value; +} +/** + * Is the editor ready + * + * @param {Object} state + * @return {boolean} is Ready. + */ + +function __unstableIsEditorReady(state) { + return state.isReady; +} +/** + * Returns the post editor settings. + * + * @param {Object} state Editor state. + * + * @return {Object} The editor settings object. + */ + +function selectors_getEditorSettings(state) { + return state.editorSettings; +} +/* + * Backward compatibility + */ + +function getBlockEditorSelector(name) { + return Object(external_this_wp_data_["createRegistrySelector"])(function (select) { + return function (state) { + var _select; + + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return (_select = select('core/block-editor'))[name].apply(_select, args); + }; + }); +} + +var getBlockDependantsCacheBust = getBlockEditorSelector('getBlockDependantsCacheBust'); +var selectors_getBlockName = getBlockEditorSelector('getBlockName'); +var isBlockValid = getBlockEditorSelector('isBlockValid'); +var getBlockAttributes = getBlockEditorSelector('getBlockAttributes'); +var getBlock = getBlockEditorSelector('getBlock'); +var selectors_getBlocks = getBlockEditorSelector('getBlocks'); +var __unstableGetBlockWithoutInnerBlocks = getBlockEditorSelector('__unstableGetBlockWithoutInnerBlocks'); +var getClientIdsOfDescendants = getBlockEditorSelector('getClientIdsOfDescendants'); +var getClientIdsWithDescendants = getBlockEditorSelector('getClientIdsWithDescendants'); +var getGlobalBlockCount = getBlockEditorSelector('getGlobalBlockCount'); +var getBlocksByClientId = getBlockEditorSelector('getBlocksByClientId'); +var getBlockCount = getBlockEditorSelector('getBlockCount'); +var getBlockSelectionStart = getBlockEditorSelector('getBlockSelectionStart'); +var getBlockSelectionEnd = getBlockEditorSelector('getBlockSelectionEnd'); +var getSelectedBlockCount = getBlockEditorSelector('getSelectedBlockCount'); +var hasSelectedBlock = getBlockEditorSelector('hasSelectedBlock'); +var selectors_getSelectedBlockClientId = getBlockEditorSelector('getSelectedBlockClientId'); +var getSelectedBlock = getBlockEditorSelector('getSelectedBlock'); +var getBlockRootClientId = getBlockEditorSelector('getBlockRootClientId'); +var getBlockHierarchyRootClientId = getBlockEditorSelector('getBlockHierarchyRootClientId'); +var getAdjacentBlockClientId = getBlockEditorSelector('getAdjacentBlockClientId'); +var getPreviousBlockClientId = getBlockEditorSelector('getPreviousBlockClientId'); +var getNextBlockClientId = getBlockEditorSelector('getNextBlockClientId'); +var getSelectedBlocksInitialCaretPosition = getBlockEditorSelector('getSelectedBlocksInitialCaretPosition'); +var getMultiSelectedBlockClientIds = getBlockEditorSelector('getMultiSelectedBlockClientIds'); +var getMultiSelectedBlocks = getBlockEditorSelector('getMultiSelectedBlocks'); +var getFirstMultiSelectedBlockClientId = getBlockEditorSelector('getFirstMultiSelectedBlockClientId'); +var getLastMultiSelectedBlockClientId = getBlockEditorSelector('getLastMultiSelectedBlockClientId'); +var isFirstMultiSelectedBlock = getBlockEditorSelector('isFirstMultiSelectedBlock'); +var isBlockMultiSelected = getBlockEditorSelector('isBlockMultiSelected'); +var isAncestorMultiSelected = getBlockEditorSelector('isAncestorMultiSelected'); +var getMultiSelectedBlocksStartClientId = getBlockEditorSelector('getMultiSelectedBlocksStartClientId'); +var getMultiSelectedBlocksEndClientId = getBlockEditorSelector('getMultiSelectedBlocksEndClientId'); +var getBlockOrder = getBlockEditorSelector('getBlockOrder'); +var getBlockIndex = getBlockEditorSelector('getBlockIndex'); +var isBlockSelected = getBlockEditorSelector('isBlockSelected'); +var hasSelectedInnerBlock = getBlockEditorSelector('hasSelectedInnerBlock'); +var isBlockWithinSelection = getBlockEditorSelector('isBlockWithinSelection'); +var hasMultiSelection = getBlockEditorSelector('hasMultiSelection'); +var isMultiSelecting = getBlockEditorSelector('isMultiSelecting'); +var isSelectionEnabled = getBlockEditorSelector('isSelectionEnabled'); +var getBlockMode = getBlockEditorSelector('getBlockMode'); +var selectors_isTyping = getBlockEditorSelector('isTyping'); +var selectors_isCaretWithinFormattedText = getBlockEditorSelector('isCaretWithinFormattedText'); +var getBlockInsertionPoint = getBlockEditorSelector('getBlockInsertionPoint'); +var isBlockInsertionPointVisible = getBlockEditorSelector('isBlockInsertionPointVisible'); +var isValidTemplate = getBlockEditorSelector('isValidTemplate'); +var getTemplate = getBlockEditorSelector('getTemplate'); +var getTemplateLock = getBlockEditorSelector('getTemplateLock'); +var canInsertBlockType = getBlockEditorSelector('canInsertBlockType'); +var selectors_getInserterItems = getBlockEditorSelector('getInserterItems'); +var hasInserterItems = getBlockEditorSelector('hasInserterItems'); +var getBlockListSettings = getBlockEditorSelector('getBlockListSettings'); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/effects/reusable-blocks.js + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + // TODO: Ideally this would be the only dispatch in scope. This requires either +// refactoring editor actions to yielded controls, or replacing direct dispatch +// on the editor store with action creators (e.g. `REMOVE_REUSABLE_BLOCK`). + + +/** + * Internal dependencies + */ + + + + +/** + * Module Constants + */ + +var REUSABLE_BLOCK_NOTICE_ID = 'REUSABLE_BLOCK_NOTICE_ID'; +/** + * Fetch Reusable Blocks Effect Handler. + * + * @param {Object} action action object. + * @param {Object} store Redux Store. + */ + +var fetchReusableBlocks = +/*#__PURE__*/ +function () { + var _ref = Object(asyncToGenerator["a" /* default */])( + /*#__PURE__*/ + regenerator_default.a.mark(function _callee(action, store) { + var id, dispatch, postType, posts, results; + return regenerator_default.a.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + id = action.id; + dispatch = store.dispatch; // TODO: these are potentially undefined, this fix is in place + // until there is a filter to not use reusable blocks if undefined + + _context.next = 4; + return external_this_wp_apiFetch_default()({ + path: '/wp/v2/types/wp_block' + }); + + case 4: + postType = _context.sent; + + if (postType) { + _context.next = 7; + break; + } + + return _context.abrupt("return"); + + case 7: + _context.prev = 7; + + if (!id) { + _context.next = 15; + break; + } + + _context.next = 11; + return external_this_wp_apiFetch_default()({ + path: "/wp/v2/".concat(postType.rest_base, "/").concat(id) + }); + + case 11: + _context.t0 = _context.sent; + posts = [_context.t0]; + _context.next = 18; + break; + + case 15: + _context.next = 17; + return external_this_wp_apiFetch_default()({ + path: "/wp/v2/".concat(postType.rest_base, "?per_page=-1") + }); + + case 17: + posts = _context.sent; + + case 18: + results = Object(external_lodash_["compact"])(Object(external_lodash_["map"])(posts, function (post) { + if (post.status !== 'publish' || post.content.protected) { + return null; + } + + var parsedBlocks = Object(external_this_wp_blocks_["parse"])(post.content.raw); + return { + reusableBlock: { + id: post.id, + title: getPostRawValue(post.title) + }, + parsedBlock: parsedBlocks.length === 1 ? parsedBlocks[0] : Object(external_this_wp_blocks_["createBlock"])('core/template', {}, parsedBlocks) + }; + })); + + if (results.length) { + dispatch(__experimentalReceiveReusableBlocks(results)); + } + + dispatch({ + type: 'FETCH_REUSABLE_BLOCKS_SUCCESS', + id: id + }); + _context.next = 26; + break; + + case 23: + _context.prev = 23; + _context.t1 = _context["catch"](7); + dispatch({ + type: 'FETCH_REUSABLE_BLOCKS_FAILURE', + id: id, + error: _context.t1 + }); + + case 26: + case "end": + return _context.stop(); + } + } + }, _callee, this, [[7, 23]]); + })); + + return function fetchReusableBlocks(_x, _x2) { + return _ref.apply(this, arguments); + }; +}(); +/** + * Save Reusable Blocks Effect Handler. + * + * @param {Object} action action object. + * @param {Object} store Redux Store. + */ + +var saveReusableBlocks = +/*#__PURE__*/ +function () { + var _ref2 = Object(asyncToGenerator["a" /* default */])( + /*#__PURE__*/ + regenerator_default.a.mark(function _callee2(action, store) { + var postType, id, dispatch, state, _getReusableBlock, clientId, title, isTemporary, reusableBlock, content, data, path, method, updatedReusableBlock, message; + + return regenerator_default.a.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + _context2.next = 2; + return external_this_wp_apiFetch_default()({ + path: '/wp/v2/types/wp_block' + }); + + case 2: + postType = _context2.sent; + + if (postType) { + _context2.next = 5; + break; + } + + return _context2.abrupt("return"); + + case 5: + id = action.id; + dispatch = store.dispatch; + state = store.getState(); + _getReusableBlock = __experimentalGetReusableBlock(state, id), clientId = _getReusableBlock.clientId, title = _getReusableBlock.title, isTemporary = _getReusableBlock.isTemporary; + reusableBlock = Object(external_this_wp_data_["select"])('core/block-editor').getBlock(clientId); + content = Object(external_this_wp_blocks_["serialize"])(reusableBlock.name === 'core/template' ? reusableBlock.innerBlocks : reusableBlock); + data = isTemporary ? { + title: title, + content: content, + status: 'publish' + } : { + id: id, + title: title, + content: content, + status: 'publish' + }; + path = isTemporary ? "/wp/v2/".concat(postType.rest_base) : "/wp/v2/".concat(postType.rest_base, "/").concat(id); + method = isTemporary ? 'POST' : 'PUT'; + _context2.prev = 14; + _context2.next = 17; + return external_this_wp_apiFetch_default()({ + path: path, + data: data, + method: method + }); + + case 17: + updatedReusableBlock = _context2.sent; + dispatch({ + type: 'SAVE_REUSABLE_BLOCK_SUCCESS', + updatedId: updatedReusableBlock.id, + id: id + }); + message = isTemporary ? Object(external_this_wp_i18n_["__"])('Block created.') : Object(external_this_wp_i18n_["__"])('Block updated.'); + Object(external_this_wp_data_["dispatch"])('core/notices').createSuccessNotice(message, { + id: REUSABLE_BLOCK_NOTICE_ID + }); + + Object(external_this_wp_data_["dispatch"])('core/block-editor').__unstableSaveReusableBlock(id, updatedReusableBlock.id); + + _context2.next = 28; + break; + + case 24: + _context2.prev = 24; + _context2.t0 = _context2["catch"](14); + dispatch({ + type: 'SAVE_REUSABLE_BLOCK_FAILURE', + id: id + }); + Object(external_this_wp_data_["dispatch"])('core/notices').createErrorNotice(_context2.t0.message, { + id: REUSABLE_BLOCK_NOTICE_ID + }); + + case 28: + case "end": + return _context2.stop(); + } + } + }, _callee2, this, [[14, 24]]); + })); + + return function saveReusableBlocks(_x3, _x4) { + return _ref2.apply(this, arguments); + }; +}(); +/** + * Delete Reusable Blocks Effect Handler. + * + * @param {Object} action action object. + * @param {Object} store Redux Store. + */ + +var deleteReusableBlocks = +/*#__PURE__*/ +function () { + var _ref3 = Object(asyncToGenerator["a" /* default */])( + /*#__PURE__*/ + regenerator_default.a.mark(function _callee3(action, store) { + var postType, id, getState, dispatch, reusableBlock, allBlocks, associatedBlocks, associatedBlockClientIds, transactionId, message; + return regenerator_default.a.wrap(function _callee3$(_context3) { + while (1) { + switch (_context3.prev = _context3.next) { + case 0: + _context3.next = 2; + return external_this_wp_apiFetch_default()({ + path: '/wp/v2/types/wp_block' + }); + + case 2: + postType = _context3.sent; + + if (postType) { + _context3.next = 5; + break; + } + + return _context3.abrupt("return"); + + case 5: + id = action.id; + getState = store.getState, dispatch = store.dispatch; // Don't allow a reusable block with a temporary ID to be deleted + + reusableBlock = __experimentalGetReusableBlock(getState(), id); + + if (!(!reusableBlock || reusableBlock.isTemporary)) { + _context3.next = 10; + break; + } + + return _context3.abrupt("return"); + + case 10: + // Remove any other blocks that reference this reusable block + allBlocks = Object(external_this_wp_data_["select"])('core/block-editor').getBlocks(); + associatedBlocks = allBlocks.filter(function (block) { + return Object(external_this_wp_blocks_["isReusableBlock"])(block) && block.attributes.ref === id; + }); + associatedBlockClientIds = associatedBlocks.map(function (block) { + return block.clientId; + }); + transactionId = Object(external_lodash_["uniqueId"])(); + dispatch({ + type: 'REMOVE_REUSABLE_BLOCK', + id: id, + optimist: { + type: redux_optimist["BEGIN"], + id: transactionId + } + }); // Remove the parsed block. + + Object(external_this_wp_data_["dispatch"])('core/block-editor').removeBlocks([].concat(Object(toConsumableArray["a" /* default */])(associatedBlockClientIds), [reusableBlock.clientId])); + _context3.prev = 16; + _context3.next = 19; + return external_this_wp_apiFetch_default()({ + path: "/wp/v2/".concat(postType.rest_base, "/").concat(id), + method: 'DELETE' + }); + + case 19: + dispatch({ + type: 'DELETE_REUSABLE_BLOCK_SUCCESS', + id: id, + optimist: { + type: redux_optimist["COMMIT"], + id: transactionId + } + }); + message = Object(external_this_wp_i18n_["__"])('Block deleted.'); + Object(external_this_wp_data_["dispatch"])('core/notices').createSuccessNotice(message, { + id: REUSABLE_BLOCK_NOTICE_ID + }); + _context3.next = 28; + break; + + case 24: + _context3.prev = 24; + _context3.t0 = _context3["catch"](16); + dispatch({ + type: 'DELETE_REUSABLE_BLOCK_FAILURE', + id: id, + optimist: { + type: redux_optimist["REVERT"], + id: transactionId + } + }); + Object(external_this_wp_data_["dispatch"])('core/notices').createErrorNotice(_context3.t0.message, { + id: REUSABLE_BLOCK_NOTICE_ID + }); + + case 28: + case "end": + return _context3.stop(); + } + } + }, _callee3, this, [[16, 24]]); + })); + + return function deleteReusableBlocks(_x5, _x6) { + return _ref3.apply(this, arguments); + }; +}(); +/** + * Receive Reusable Blocks Effect Handler. + * + * @param {Object} action action object. + */ + +var reusable_blocks_receiveReusableBlocks = function receiveReusableBlocks(action) { + Object(external_this_wp_data_["dispatch"])('core/block-editor').receiveBlocks(Object(external_lodash_["map"])(action.results, 'parsedBlock')); +}; +/** + * Convert a reusable block to a static block effect handler + * + * @param {Object} action action object. + * @param {Object} store Redux Store. + */ + +var reusable_blocks_convertBlockToStatic = function convertBlockToStatic(action, store) { + var state = store.getState(); + var oldBlock = Object(external_this_wp_data_["select"])('core/block-editor').getBlock(action.clientId); + var reusableBlock = __experimentalGetReusableBlock(state, oldBlock.attributes.ref); + var referencedBlock = Object(external_this_wp_data_["select"])('core/block-editor').getBlock(reusableBlock.clientId); + var newBlocks; + + if (referencedBlock.name === 'core/template') { + newBlocks = referencedBlock.innerBlocks.map(function (innerBlock) { + return Object(external_this_wp_blocks_["cloneBlock"])(innerBlock); + }); + } else { + newBlocks = [Object(external_this_wp_blocks_["cloneBlock"])(referencedBlock)]; + } + + Object(external_this_wp_data_["dispatch"])('core/block-editor').replaceBlocks(oldBlock.clientId, newBlocks); +}; +/** + * Convert a static block to a reusable block effect handler + * + * @param {Object} action action object. + * @param {Object} store Redux Store. + */ + +var reusable_blocks_convertBlockToReusable = function convertBlockToReusable(action, store) { + var dispatch = store.dispatch; + var parsedBlock; + + if (action.clientIds.length === 1) { + parsedBlock = Object(external_this_wp_data_["select"])('core/block-editor').getBlock(action.clientIds[0]); + } else { + parsedBlock = Object(external_this_wp_blocks_["createBlock"])('core/template', {}, Object(external_this_wp_data_["select"])('core/block-editor').getBlocksByClientId(action.clientIds)); // This shouldn't be necessary but at the moment + // we expect the content of the shared blocks to live in the blocks state. + + Object(external_this_wp_data_["dispatch"])('core/block-editor').receiveBlocks([parsedBlock]); + } + + var reusableBlock = { + id: Object(external_lodash_["uniqueId"])('reusable'), + clientId: parsedBlock.clientId, + title: Object(external_this_wp_i18n_["__"])('Untitled Reusable Block') + }; + dispatch(__experimentalReceiveReusableBlocks([{ + reusableBlock: reusableBlock, + parsedBlock: parsedBlock + }])); + dispatch(__experimentalSaveReusableBlock(reusableBlock.id)); + Object(external_this_wp_data_["dispatch"])('core/block-editor').replaceBlocks(action.clientIds, Object(external_this_wp_blocks_["createBlock"])('core/block', { + ref: reusableBlock.id + })); // Re-add the original block to the store, since replaceBlock() will have removed it + + Object(external_this_wp_data_["dispatch"])('core/block-editor').receiveBlocks([parsedBlock]); +}; + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/effects.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + + +/* harmony default export */ var effects = ({ + SETUP_EDITOR: function SETUP_EDITOR(action) { + var post = action.post, + edits = action.edits, + template = action.template; // In order to ensure maximum of a single parse during setup, edits are + // included as part of editor setup action. Assume edited content as + // canonical if provided, falling back to post. + + var content; + + if (Object(external_lodash_["has"])(edits, ['content'])) { + content = edits.content; + } else { + content = post.content.raw; + } + + var blocks = Object(external_this_wp_blocks_["parse"])(content); // Apply a template for new posts only, if exists. + + var isNewPost = post.status === 'auto-draft'; + + if (isNewPost && template) { + blocks = Object(external_this_wp_blocks_["synchronizeBlocksWithTemplate"])(blocks, template); + } + + return [actions_resetEditorBlocks(blocks), setupEditorState(post)]; + }, + FETCH_REUSABLE_BLOCKS: function FETCH_REUSABLE_BLOCKS(action, store) { + fetchReusableBlocks(action, store); + }, + SAVE_REUSABLE_BLOCK: function SAVE_REUSABLE_BLOCK(action, store) { + saveReusableBlocks(action, store); + }, + DELETE_REUSABLE_BLOCK: function DELETE_REUSABLE_BLOCK(action, store) { + deleteReusableBlocks(action, store); + }, + RECEIVE_REUSABLE_BLOCKS: reusable_blocks_receiveReusableBlocks, + CONVERT_BLOCK_TO_STATIC: reusable_blocks_convertBlockToStatic, + CONVERT_BLOCK_TO_REUSABLE: reusable_blocks_convertBlockToReusable +}); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/middlewares.js + + +/** + * External dependencies + */ + + + +/** + * Internal dependencies + */ + + +/** + * Applies the custom middlewares used specifically in the editor module. + * + * @param {Object} store Store Object. + * + * @return {Object} Update Store Object. + */ + +function applyMiddlewares(store) { + var middlewares = [refx_default()(effects), lib_default.a]; + + var enhancedDispatch = function enhancedDispatch() { + throw new Error('Dispatching while constructing your middleware is not allowed. ' + 'Other middleware would not be applied to this dispatch.'); + }; + + var chain = []; + var middlewareAPI = { + getState: store.getState, + dispatch: function dispatch() { + return enhancedDispatch.apply(void 0, arguments); + } + }; + chain = middlewares.map(function (middleware) { + return middleware(middlewareAPI); + }); + enhancedDispatch = external_lodash_["flowRight"].apply(void 0, Object(toConsumableArray["a" /* default */])(chain))(store.dispatch); + store.dispatch = enhancedDispatch; + return store; +} + +/* harmony default export */ var store_middlewares = (applyMiddlewares); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/store/index.js +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + + + + + +var store_store = Object(external_this_wp_data_["registerStore"])(STORE_KEY, { + reducer: store_reducer, + selectors: selectors_namespaceObject, + actions: actions_namespaceObject, + controls: controls, + persist: ['preferences'] +}); +store_middlewares(store_store); +/* harmony default export */ var build_module_store = (store_store); + +// EXTERNAL MODULE: external {"this":["wp","hooks"]} +var external_this_wp_hooks_ = __webpack_require__(26); + +// EXTERNAL MODULE: external {"this":["wp","element"]} +var external_this_wp_element_ = __webpack_require__(0); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/autocompleters/block.js + + + +/** + * WordPress dependencies + */ + + + +/** + * Returns the client ID of the parent where a newly inserted block would be + * placed. + * + * @return {string} Client ID of the parent where a newly inserted block would + * be placed. + */ + +function defaultGetBlockInsertionParentClientId() { + return Object(external_this_wp_data_["select"])('core/block-editor').getBlockInsertionPoint().rootClientId; +} +/** + * Returns the inserter items for the specified parent block. + * + * @param {string} rootClientId Client ID of the block for which to retrieve + * inserter items. + * + * @return {Array} The inserter items for the specified + * parent. + */ + + +function defaultGetInserterItems(rootClientId) { + return Object(external_this_wp_data_["select"])('core/block-editor').getInserterItems(rootClientId); +} +/** + * Returns the name of the currently selected block. + * + * @return {string?} The name of the currently selected block or `null` if no + * block is selected. + */ + + +function defaultGetSelectedBlockName() { + var _select = Object(external_this_wp_data_["select"])('core/block-editor'), + getSelectedBlockClientId = _select.getSelectedBlockClientId, + getBlockName = _select.getBlockName; + + var selectedBlockClientId = getSelectedBlockClientId(); + return selectedBlockClientId ? getBlockName(selectedBlockClientId) : null; +} +/** + * Creates a blocks repeater for replacing the current block with a selected block type. + * + * @return {Completer} A blocks completer. + */ + + +function createBlockCompleter() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + _ref$getBlockInsertio = _ref.getBlockInsertionParentClientId, + getBlockInsertionParentClientId = _ref$getBlockInsertio === void 0 ? defaultGetBlockInsertionParentClientId : _ref$getBlockInsertio, + _ref$getInserterItems = _ref.getInserterItems, + getInserterItems = _ref$getInserterItems === void 0 ? defaultGetInserterItems : _ref$getInserterItems, + _ref$getSelectedBlock = _ref.getSelectedBlockName, + getSelectedBlockName = _ref$getSelectedBlock === void 0 ? defaultGetSelectedBlockName : _ref$getSelectedBlock; + + return { + name: 'blocks', + className: 'editor-autocompleters__block', + triggerPrefix: '/', + options: function options() { + var selectedBlockName = getSelectedBlockName(); + return getInserterItems(getBlockInsertionParentClientId()).filter( // Avoid offering to replace the current block with a block of the same type. + function (inserterItem) { + return selectedBlockName !== inserterItem.name; + }); + }, + getOptionKeywords: function getOptionKeywords(inserterItem) { + var title = inserterItem.title, + _inserterItem$keyword = inserterItem.keywords, + keywords = _inserterItem$keyword === void 0 ? [] : _inserterItem$keyword, + category = inserterItem.category; + return [category].concat(Object(toConsumableArray["a" /* default */])(keywords), [title]); + }, + getOptionLabel: function getOptionLabel(inserterItem) { + var icon = inserterItem.icon, + title = inserterItem.title; + return [Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["BlockIcon"], { + key: "icon", + icon: icon, + showColors: true + }), title]; + }, + allowContext: function allowContext(before, after) { + return !(/\S/.test(before) || /\S/.test(after)); + }, + getOptionCompletion: function getOptionCompletion(inserterItem) { + var name = inserterItem.name, + initialAttributes = inserterItem.initialAttributes; + return { + action: 'replace', + value: Object(external_this_wp_blocks_["createBlock"])(name, initialAttributes) + }; + }, + isOptionDisabled: function isOptionDisabled(inserterItem) { + return inserterItem.isDisabled; + } + }; +} +/** + * Creates a blocks repeater for replacing the current block with a selected block type. + * + * @return {Completer} A blocks completer. + */ + +/* harmony default export */ var autocompleters_block = (createBlockCompleter()); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/autocompleters/user.js + + +/** + * WordPress dependencies + */ + +/** +* A user mentions completer. +* +* @type {Completer} +*/ + +/* harmony default export */ var autocompleters_user = ({ + name: 'users', + className: 'editor-autocompleters__user', + triggerPrefix: '@', + options: function options(search) { + var payload = ''; + + if (search) { + payload = '?search=' + encodeURIComponent(search); + } + + return external_this_wp_apiFetch_default()({ + path: '/wp/v2/users' + payload + }); + }, + isDebounced: true, + getOptionKeywords: function getOptionKeywords(user) { + return [user.slug, user.name]; + }, + getOptionLabel: function getOptionLabel(user) { + return [Object(external_this_wp_element_["createElement"])("img", { + key: "avatar", + className: "editor-autocompleters__user-avatar", + alt: "", + src: user.avatar_urls[24] + }), Object(external_this_wp_element_["createElement"])("span", { + key: "name", + className: "editor-autocompleters__user-name" + }, user.name), Object(external_this_wp_element_["createElement"])("span", { + key: "slug", + className: "editor-autocompleters__user-slug" + }, user.slug)]; + }, + getOptionCompletion: function getOptionCompletion(user) { + return "@".concat(user.slug); + } +}); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/autocompleters/index.js + + + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js +var esm_extends = __webpack_require__(19); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js + 1 modules +var objectWithoutProperties = __webpack_require__(21); + +// EXTERNAL MODULE: external {"this":["wp","components"]} +var external_this_wp_components_ = __webpack_require__(4); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/server-side-render/index.js + + + + + +/** + * WordPress dependencies + */ + + +/* harmony default export */ var server_side_render = (function (_ref) { + var _ref$urlQueryArgs = _ref.urlQueryArgs, + urlQueryArgs = _ref$urlQueryArgs === void 0 ? {} : _ref$urlQueryArgs, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["urlQueryArgs"]); + + var _select = Object(external_this_wp_data_["select"])('core/editor'), + getCurrentPostId = _select.getCurrentPostId; + + urlQueryArgs = Object(objectSpread["a" /* default */])({ + post_id: getCurrentPostId() + }, urlQueryArgs); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ServerSideRender"], Object(esm_extends["a" /* default */])({ + urlQueryArgs: urlQueryArgs + }, props)); +}); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js +var classCallCheck = __webpack_require__(10); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js +var createClass = __webpack_require__(9); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js +var possibleConstructorReturn = __webpack_require__(11); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js +var getPrototypeOf = __webpack_require__(12); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules +var inherits = __webpack_require__(13); + +// EXTERNAL MODULE: external {"this":["wp","compose"]} +var external_this_wp_compose_ = __webpack_require__(6); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/autosave-monitor/index.js + + + + + + +/** + * WordPress dependencies + */ + + + +var autosave_monitor_AutosaveMonitor = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(AutosaveMonitor, _Component); + + function AutosaveMonitor() { + Object(classCallCheck["a" /* default */])(this, AutosaveMonitor); + + return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(AutosaveMonitor).apply(this, arguments)); + } + + Object(createClass["a" /* default */])(AutosaveMonitor, [{ + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var _this$props = this.props, + isDirty = _this$props.isDirty, + editsReference = _this$props.editsReference, + isAutosaveable = _this$props.isAutosaveable, + isAutosaving = _this$props.isAutosaving; // The edits reference is held for comparison to avoid scheduling an + // autosave if an edit has not been made since the last autosave + // completion. This is assigned when the autosave completes, and reset + // when an edit occurs. + // + // See: https://github.com/WordPress/gutenberg/issues/12318 + + if (editsReference !== prevProps.editsReference) { + this.didAutosaveForEditsReference = false; + } + + if (!isAutosaving && prevProps.isAutosaving) { + this.didAutosaveForEditsReference = true; + } + + if (prevProps.isDirty !== isDirty || prevProps.isAutosaveable !== isAutosaveable || prevProps.editsReference !== editsReference) { + this.toggleTimer(isDirty && isAutosaveable && !this.didAutosaveForEditsReference); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + this.toggleTimer(false); + } + }, { + key: "toggleTimer", + value: function toggleTimer(isPendingSave) { + var _this = this; + + clearTimeout(this.pendingSave); + var autosaveInterval = this.props.autosaveInterval; + + if (isPendingSave) { + this.pendingSave = setTimeout(function () { + return _this.props.autosave(); + }, autosaveInterval * 1000); + } + } + }, { + key: "render", + value: function render() { + return null; + } + }]); + + return AutosaveMonitor; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var autosave_monitor = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isEditedPostDirty = _select.isEditedPostDirty, + isEditedPostAutosaveable = _select.isEditedPostAutosaveable, + getReferenceByDistinctEdits = _select.getReferenceByDistinctEdits, + isAutosavingPost = _select.isAutosavingPost; + + var _select$getEditorSett = select('core/editor').getEditorSettings(), + autosaveInterval = _select$getEditorSett.autosaveInterval; + + return { + isDirty: isEditedPostDirty(), + isAutosaveable: isEditedPostAutosaveable(), + editsReference: getReferenceByDistinctEdits(), + isAutosaving: isAutosavingPost(), + autosaveInterval: autosaveInterval + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + autosave: dispatch('core/editor').autosave + }; +})])(autosave_monitor_AutosaveMonitor)); + +// EXTERNAL MODULE: ./node_modules/classnames/index.js +var classnames = __webpack_require__(16); +var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/document-outline/item.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +var item_TableOfContentsItem = function TableOfContentsItem(_ref) { + var children = _ref.children, + isValid = _ref.isValid, + level = _ref.level, + _ref$path = _ref.path, + path = _ref$path === void 0 ? [] : _ref$path, + href = _ref.href, + onSelect = _ref.onSelect; + return Object(external_this_wp_element_["createElement"])("li", { + className: classnames_default()('document-outline__item', "is-".concat(level.toLowerCase()), { + 'is-invalid': !isValid + }) + }, Object(external_this_wp_element_["createElement"])("a", { + href: href, + className: "document-outline__button", + onClick: onSelect + }, Object(external_this_wp_element_["createElement"])("span", { + className: "document-outline__emdash", + "aria-hidden": "true" + }), // path is an array of nodes that are ancestors of the heading starting in the top level node. + // This mapping renders each ancestor to make it easier for the user to know where the headings are nested. + path.map(function (_ref2, index) { + var clientId = _ref2.clientId; + return Object(external_this_wp_element_["createElement"])("strong", { + key: index, + className: "document-outline__level" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["BlockTitle"], { + clientId: clientId + })); + }), Object(external_this_wp_element_["createElement"])("strong", { + className: "document-outline__level" + }, level), Object(external_this_wp_element_["createElement"])("span", { + className: "document-outline__item-content" + }, children))); +}; + +/* harmony default export */ var document_outline_item = (item_TableOfContentsItem); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/document-outline/index.js + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + +/** + * Module constants + */ + +var emptyHeadingContent = Object(external_this_wp_element_["createElement"])("em", null, Object(external_this_wp_i18n_["__"])('(Empty heading)')); +var incorrectLevelContent = [Object(external_this_wp_element_["createElement"])("br", { + key: "incorrect-break" +}), Object(external_this_wp_element_["createElement"])("em", { + key: "incorrect-message" +}, Object(external_this_wp_i18n_["__"])('(Incorrect heading level)'))]; +var singleH1Headings = [Object(external_this_wp_element_["createElement"])("br", { + key: "incorrect-break-h1" +}), Object(external_this_wp_element_["createElement"])("em", { + key: "incorrect-message-h1" +}, Object(external_this_wp_i18n_["__"])('(Your theme may already use a H1 for the post title)'))]; +var multipleH1Headings = [Object(external_this_wp_element_["createElement"])("br", { + key: "incorrect-break-multiple-h1" +}), Object(external_this_wp_element_["createElement"])("em", { + key: "incorrect-message-multiple-h1" +}, Object(external_this_wp_i18n_["__"])('(Multiple H1 headings are not recommended)'))]; +/** + * Returns an array of heading blocks enhanced with the following properties: + * path - An array of blocks that are ancestors of the heading starting from a top-level node. + * Can be an empty array if the heading is a top-level node (is not nested inside another block). + * level - An integer with the heading level. + * isEmpty - Flag indicating if the heading has no content. + * + * @param {?Array} blocks An array of blocks. + * @param {?Array} path An array of blocks that are ancestors of the blocks passed as blocks. + * + * @return {Array} An array of heading blocks enhanced with the properties described above. + */ + +var document_outline_computeOutlineHeadings = function computeOutlineHeadings() { + var blocks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + return Object(external_lodash_["flatMap"])(blocks, function () { + var block = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + if (block.name === 'core/heading') { + return Object(objectSpread["a" /* default */])({}, block, { + path: path, + level: block.attributes.level, + isEmpty: isEmptyHeading(block) + }); + } + + return computeOutlineHeadings(block.innerBlocks, [].concat(Object(toConsumableArray["a" /* default */])(path), [block])); + }); +}; + +var isEmptyHeading = function isEmptyHeading(heading) { + return !heading.attributes.content || heading.attributes.content.length === 0; +}; + +var document_outline_DocumentOutline = function DocumentOutline(_ref) { + var _ref$blocks = _ref.blocks, + blocks = _ref$blocks === void 0 ? [] : _ref$blocks, + title = _ref.title, + onSelect = _ref.onSelect, + isTitleSupported = _ref.isTitleSupported, + hasOutlineItemsDisabled = _ref.hasOutlineItemsDisabled; + var headings = document_outline_computeOutlineHeadings(blocks); + + if (headings.length < 1) { + return null; + } + + var prevHeadingLevel = 1; // Not great but it's the simplest way to locate the title right now. + + var titleNode = document.querySelector('.editor-post-title__input'); + var hasTitle = isTitleSupported && title && titleNode; + var countByLevel = Object(external_lodash_["countBy"])(headings, 'level'); + var hasMultipleH1 = countByLevel[1] > 1; + return Object(external_this_wp_element_["createElement"])("div", { + className: "document-outline" + }, Object(external_this_wp_element_["createElement"])("ul", null, hasTitle && Object(external_this_wp_element_["createElement"])(document_outline_item, { + level: Object(external_this_wp_i18n_["__"])('Title'), + isValid: true, + onSelect: onSelect, + href: "#".concat(titleNode.id), + isDisabled: hasOutlineItemsDisabled + }, title), headings.map(function (item, index) { + // Headings remain the same, go up by one, or down by any amount. + // Otherwise there are missing levels. + var isIncorrectLevel = item.level > prevHeadingLevel + 1; + var isValid = !item.isEmpty && !isIncorrectLevel && !!item.level && (item.level !== 1 || !hasMultipleH1 && !hasTitle); + prevHeadingLevel = item.level; + return Object(external_this_wp_element_["createElement"])(document_outline_item, { + key: index, + level: "H".concat(item.level), + isValid: isValid, + path: item.path, + isDisabled: hasOutlineItemsDisabled, + href: "#block-".concat(item.clientId), + onSelect: onSelect + }, item.isEmpty ? emptyHeadingContent : Object(external_this_wp_richText_["getTextContent"])(Object(external_this_wp_richText_["create"])({ + html: item.attributes.content + })), isIncorrectLevel && incorrectLevelContent, item.level === 1 && hasMultipleH1 && multipleH1Headings, hasTitle && item.level === 1 && !hasMultipleH1 && singleH1Headings); + }))); +}; +/* harmony default export */ var document_outline = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getBlocks = _select.getBlocks; + + var _select2 = select('core/editor'), + getEditedPostAttribute = _select2.getEditedPostAttribute; + + var _select3 = select('core'), + getPostType = _select3.getPostType; + + var postType = getPostType(getEditedPostAttribute('type')); + return { + title: getEditedPostAttribute('title'), + blocks: getBlocks(), + isTitleSupported: Object(external_lodash_["get"])(postType, ['supports', 'title'], false) + }; +}))(document_outline_DocumentOutline)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/document-outline/check.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +function DocumentOutlineCheck(_ref) { + var blocks = _ref.blocks, + children = _ref.children; + var headings = Object(external_lodash_["filter"])(blocks, function (block) { + return block.name === 'core/heading'; + }); + + if (headings.length < 1) { + return null; + } + + return children; +} + +/* harmony default export */ var check = (Object(external_this_wp_data_["withSelect"])(function (select) { + return { + blocks: select('core/block-editor').getBlocks() + }; +})(DocumentOutlineCheck)); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js +var assertThisInitialized = __webpack_require__(3); + +// EXTERNAL MODULE: external {"this":["wp","keycodes"]} +var external_this_wp_keycodes_ = __webpack_require__(18); + +// EXTERNAL MODULE: external {"this":["wp","deprecated"]} +var external_this_wp_deprecated_ = __webpack_require__(49); +var external_this_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_deprecated_); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/global-keyboard-shortcuts/save-shortcut.js + + + +/** + * WordPress dependencies + */ + + + + +function SaveShortcut(_ref) { + var onSave = _ref.onSave; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["KeyboardShortcuts"], { + bindGlobal: true, + shortcuts: Object(defineProperty["a" /* default */])({}, external_this_wp_keycodes_["rawShortcut"].primary('s'), function (event) { + event.preventDefault(); + onSave(); + }) + }); +} +/* harmony default export */ var save_shortcut = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isEditedPostDirty = _select.isEditedPostDirty; + + return { + isDirty: isEditedPostDirty() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, ownProps, _ref3) { + var select = _ref3.select; + + var _dispatch = dispatch('core/editor'), + savePost = _dispatch.savePost; + + return { + onSave: function onSave() { + // TODO: This should be handled in the `savePost` effect in + // considering `isSaveable`. See note on `isEditedPostSaveable` + // selector about dirtiness and meta-boxes. + // + // See: `isEditedPostSaveable` + var _select2 = select('core/editor'), + isEditedPostDirty = _select2.isEditedPostDirty; + + if (!isEditedPostDirty()) { + return; + } + + savePost(); + } + }; +})])(SaveShortcut)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/global-keyboard-shortcuts/visual-editor-shortcuts.js + + + + + + + + + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + +var visual_editor_shortcuts_VisualEditorGlobalKeyboardShortcuts = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(VisualEditorGlobalKeyboardShortcuts, _Component); + + function VisualEditorGlobalKeyboardShortcuts() { + var _this; + + Object(classCallCheck["a" /* default */])(this, VisualEditorGlobalKeyboardShortcuts); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(VisualEditorGlobalKeyboardShortcuts).apply(this, arguments)); + _this.undoOrRedo = _this.undoOrRedo.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + return _this; + } + + Object(createClass["a" /* default */])(VisualEditorGlobalKeyboardShortcuts, [{ + key: "undoOrRedo", + value: function undoOrRedo(event) { + var _this$props = this.props, + onRedo = _this$props.onRedo, + onUndo = _this$props.onUndo; + + if (event.shiftKey) { + onRedo(); + } else { + onUndo(); + } + + event.preventDefault(); + } + }, { + key: "render", + value: function render() { + var _ref; + + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["BlockEditorKeyboardShortcuts"], null), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["KeyboardShortcuts"], { + shortcuts: (_ref = {}, Object(defineProperty["a" /* default */])(_ref, external_this_wp_keycodes_["rawShortcut"].primary('z'), this.undoOrRedo), Object(defineProperty["a" /* default */])(_ref, external_this_wp_keycodes_["rawShortcut"].primaryShift('z'), this.undoOrRedo), _ref) + }), Object(external_this_wp_element_["createElement"])(save_shortcut, null)); + } + }]); + + return VisualEditorGlobalKeyboardShortcuts; +}(external_this_wp_element_["Component"]); + +var EnhancedVisualEditorGlobalKeyboardShortcuts = Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + redo = _dispatch.redo, + undo = _dispatch.undo; + + return { + onRedo: redo, + onUndo: undo + }; +})(visual_editor_shortcuts_VisualEditorGlobalKeyboardShortcuts); +/* harmony default export */ var visual_editor_shortcuts = (EnhancedVisualEditorGlobalKeyboardShortcuts); +function EditorGlobalKeyboardShortcuts() { + external_this_wp_deprecated_default()('EditorGlobalKeyboardShortcuts', { + alternative: 'VisualEditorGlobalKeyboardShortcuts', + plugin: 'Gutenberg' + }); + return Object(external_this_wp_element_["createElement"])(EnhancedVisualEditorGlobalKeyboardShortcuts, null); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/global-keyboard-shortcuts/text-editor-shortcuts.js + + +/** + * Internal dependencies + */ + +function TextEditorGlobalKeyboardShortcuts() { + return Object(external_this_wp_element_["createElement"])(save_shortcut, null); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/editor-history/redo.js + + +/** + * WordPress dependencies + */ + + + + + + +function EditorHistoryRedo(_ref) { + var hasRedo = _ref.hasRedo, + redo = _ref.redo; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + icon: "redo", + label: Object(external_this_wp_i18n_["__"])('Redo'), + shortcut: external_this_wp_keycodes_["displayShortcut"].primaryShift('z') // If there are no redo levels we don't want to actually disable this + // button, because it will remove focus for keyboard users. + // See: https://github.com/WordPress/gutenberg/issues/3486 + , + "aria-disabled": !hasRedo, + onClick: hasRedo ? redo : undefined, + className: "editor-history__redo" + }); +} + +/* harmony default export */ var editor_history_redo = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + hasRedo: select('core/editor').hasEditorRedo() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + redo: dispatch('core/editor').redo + }; +})])(EditorHistoryRedo)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/editor-history/undo.js + + +/** + * WordPress dependencies + */ + + + + + + +function EditorHistoryUndo(_ref) { + var hasUndo = _ref.hasUndo, + undo = _ref.undo; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + icon: "undo", + label: Object(external_this_wp_i18n_["__"])('Undo'), + shortcut: external_this_wp_keycodes_["displayShortcut"].primary('z') // If there are no undo levels we don't want to actually disable this + // button, because it will remove focus for keyboard users. + // See: https://github.com/WordPress/gutenberg/issues/3486 + , + "aria-disabled": !hasUndo, + onClick: hasUndo ? undo : undefined, + className: "editor-history__undo" + }); +} + +/* harmony default export */ var editor_history_undo = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + hasUndo: select('core/editor').hasEditorUndo() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + undo: dispatch('core/editor').undo + }; +})])(EditorHistoryUndo)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/template-validation-notice/index.js + + + +/** + * WordPress dependencies + */ + + + + + +function TemplateValidationNotice(_ref) { + var isValid = _ref.isValid, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["isValid"]); + + if (isValid) { + return null; + } + + var confirmSynchronization = function confirmSynchronization() { + // eslint-disable-next-line no-alert + if (window.confirm(Object(external_this_wp_i18n_["__"])('Resetting the template may result in loss of content, do you want to continue?'))) { + props.synchronizeTemplate(); + } + }; + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Notice"], { + className: "editor-template-validation-notice", + isDismissible: false, + status: "warning" + }, Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_i18n_["__"])('The content of your post doesn’t match the template assigned to your post type.')), Object(external_this_wp_element_["createElement"])("div", null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isDefault: true, + onClick: props.resetTemplateValidity + }, Object(external_this_wp_i18n_["__"])('Keep it as is')), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + onClick: confirmSynchronization, + isPrimary: true + }, Object(external_this_wp_i18n_["__"])('Reset the template')))); +} + +/* harmony default export */ var template_validation_notice = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + isValid: select('core/block-editor').isValidTemplate() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/block-editor'), + setTemplateValidity = _dispatch.setTemplateValidity, + synchronizeTemplate = _dispatch.synchronizeTemplate; + + return { + resetTemplateValidity: function resetTemplateValidity() { + return setTemplateValidity(true); + }, + synchronizeTemplate: synchronizeTemplate + }; +})])(TemplateValidationNotice)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/editor-notices/index.js + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +function EditorNotices(_ref) { + var dismissible = _ref.dismissible, + notices = _ref.notices, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["dismissible", "notices"]); + + if (dismissible !== undefined) { + notices = Object(external_lodash_["filter"])(notices, { + isDismissible: dismissible + }); + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["NoticeList"], Object(esm_extends["a" /* default */])({ + notices: notices + }, props), dismissible !== false && Object(external_this_wp_element_["createElement"])(template_validation_notice, null)); +} +/* harmony default export */ var editor_notices = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + notices: select('core/notices').getNotices() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onRemove: dispatch('core/notices').removeNotice + }; +})])(EditorNotices)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/error-boundary/index.js + + + + + + + + +/** + * WordPress dependencies + */ + + + + + + +var error_boundary_ErrorBoundary = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(ErrorBoundary, _Component); + + function ErrorBoundary() { + var _this; + + Object(classCallCheck["a" /* default */])(this, ErrorBoundary); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(ErrorBoundary).apply(this, arguments)); + _this.reboot = _this.reboot.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.getContent = _this.getContent.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.state = { + error: null + }; + return _this; + } + + Object(createClass["a" /* default */])(ErrorBoundary, [{ + key: "componentDidCatch", + value: function componentDidCatch(error) { + this.setState({ + error: error + }); + } + }, { + key: "reboot", + value: function reboot() { + this.props.onError(); + } + }, { + key: "getContent", + value: function getContent() { + try { + // While `select` in a component is generally discouraged, it is + // used here because it (a) reduces the chance of data loss in the + // case of additional errors by performing a direct retrieval and + // (b) avoids the performance cost associated with unnecessary + // content serialization throughout the lifetime of a non-erroring + // application. + return Object(external_this_wp_data_["select"])('core/editor').getEditedPostContent(); + } catch (error) {} + } + }, { + key: "render", + value: function render() { + var error = this.state.error; + + if (!error) { + return this.props.children; + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["Warning"], { + className: "editor-error-boundary", + actions: [Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + key: "recovery", + onClick: this.reboot, + isLarge: true + }, Object(external_this_wp_i18n_["__"])('Attempt Recovery')), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ClipboardButton"], { + key: "copy-post", + text: this.getContent, + isLarge: true + }, Object(external_this_wp_i18n_["__"])('Copy Post Text')), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ClipboardButton"], { + key: "copy-error", + text: error.stack, + isLarge: true + }, Object(external_this_wp_i18n_["__"])('Copy Error'))] + }, Object(external_this_wp_i18n_["__"])('The editor has encountered an unexpected error.')); + } + }]); + + return ErrorBoundary; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var error_boundary = (error_boundary_ErrorBoundary); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/page-attributes/check.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +function PageAttributesCheck(_ref) { + var availableTemplates = _ref.availableTemplates, + postType = _ref.postType, + children = _ref.children; + var supportsPageAttributes = Object(external_lodash_["get"])(postType, ['supports', 'page-attributes'], false); // Only render fields if post type supports page attributes or available templates exist. + + if (!supportsPageAttributes && Object(external_lodash_["isEmpty"])(availableTemplates)) { + return null; + } + + return children; +} +/* harmony default export */ var page_attributes_check = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getEditedPostAttribute = _select.getEditedPostAttribute, + getEditorSettings = _select.getEditorSettings; + + var _select2 = select('core'), + getPostType = _select2.getPostType; + + var _getEditorSettings = getEditorSettings(), + availableTemplates = _getEditorSettings.availableTemplates; + + return { + postType: getPostType(getEditedPostAttribute('type')), + availableTemplates: availableTemplates + }; +})(PageAttributesCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-type-support-check/index.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * A component which renders its own children only if the current editor post + * type supports one of the given `supportKeys` prop. + * + * @param {?Object} props.postType Current post type. + * @param {WPElement} props.children Children to be rendered if post + * type supports. + * @param {(string|string[])} props.supportKeys String or string array of keys + * to test. + * + * @return {WPElement} Rendered element. + */ + +function PostTypeSupportCheck(_ref) { + var postType = _ref.postType, + children = _ref.children, + supportKeys = _ref.supportKeys; + var isSupported = true; + + if (postType) { + isSupported = Object(external_lodash_["some"])(Object(external_lodash_["castArray"])(supportKeys), function (key) { + return !!postType.supports[key]; + }); + } + + if (!isSupported) { + return null; + } + + return children; +} +/* harmony default export */ var post_type_support_check = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getEditedPostAttribute = _select.getEditedPostAttribute; + + var _select2 = select('core'), + getPostType = _select2.getPostType; + + return { + postType: getPostType(getEditedPostAttribute('type')) + }; +})(PostTypeSupportCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/page-attributes/order.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + +var PageAttributesOrder = Object(external_this_wp_compose_["withState"])({ + orderInput: null +})(function (_ref) { + var onUpdateOrder = _ref.onUpdateOrder, + _ref$order = _ref.order, + order = _ref$order === void 0 ? 0 : _ref$order, + orderInput = _ref.orderInput, + setState = _ref.setState; + + var setUpdatedOrder = function setUpdatedOrder(value) { + setState({ + orderInput: value + }); + var newOrder = Number(value); + + if (Number.isInteger(newOrder) && Object(external_lodash_["invoke"])(value, ['trim']) !== '') { + onUpdateOrder(Number(value)); + } + }; + + var value = orderInput === null ? order : orderInput; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["TextControl"], { + className: "editor-page-attributes__order", + type: "number", + label: Object(external_this_wp_i18n_["__"])('Order'), + value: value, + onChange: setUpdatedOrder, + size: 6, + onBlur: function onBlur() { + setState({ + orderInput: null + }); + } + }); +}); + +function PageAttributesOrderWithChecks(props) { + return Object(external_this_wp_element_["createElement"])(post_type_support_check, { + supportKeys: "page-attributes" + }, Object(external_this_wp_element_["createElement"])(PageAttributesOrder, props)); +} + +/* harmony default export */ var page_attributes_order = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + order: select('core/editor').getEditedPostAttribute('menu_order') + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdateOrder: function onUpdateOrder(order) { + dispatch('core/editor').editPost({ + menu_order: order + }); + } + }; +})])(PageAttributesOrderWithChecks)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/utils/terms.js + + +/** + * External dependencies + */ + +/** + * Returns terms in a tree form. + * + * @param {Array} flatTerms Array of terms in flat format. + * + * @return {Array} Array of terms in tree format. + */ + +function buildTermsTree(flatTerms) { + var flatTermsWithParentAndChildren = flatTerms.map(function (term) { + return Object(objectSpread["a" /* default */])({ + children: [], + parent: null + }, term); + }); + var termsByParent = Object(external_lodash_["groupBy"])(flatTermsWithParentAndChildren, 'parent'); + + if (termsByParent.null && termsByParent.null.length) { + return flatTermsWithParentAndChildren; + } + + var fillWithChildren = function fillWithChildren(terms) { + return terms.map(function (term) { + var children = termsByParent[term.id]; + return Object(objectSpread["a" /* default */])({}, term, { + children: children && children.length ? fillWithChildren(children) : [] + }); + }); + }; + + return fillWithChildren(termsByParent['0'] || []); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/page-attributes/parent.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + +function PageAttributesParent(_ref) { + var parent = _ref.parent, + postType = _ref.postType, + items = _ref.items, + onUpdateParent = _ref.onUpdateParent; + var isHierarchical = Object(external_lodash_["get"])(postType, ['hierarchical'], false); + var parentPageLabel = Object(external_lodash_["get"])(postType, ['labels', 'parent_item_colon']); + var pageItems = items || []; + + if (!isHierarchical || !parentPageLabel || !pageItems.length) { + return null; + } + + var pagesTree = buildTermsTree(pageItems.map(function (item) { + return { + id: item.id, + parent: item.parent, + name: item.title.raw ? item.title.raw : "#".concat(item.id, " (").concat(Object(external_this_wp_i18n_["__"])('no title'), ")") + }; + })); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["TreeSelect"], { + className: "editor-page-attributes__parent", + label: parentPageLabel, + noOptionLabel: "(".concat(Object(external_this_wp_i18n_["__"])('no parent'), ")"), + tree: pagesTree, + selectedId: parent, + onChange: onUpdateParent + }); +} +var applyWithSelect = Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core'), + getPostType = _select.getPostType, + getEntityRecords = _select.getEntityRecords; + + var _select2 = select('core/editor'), + getCurrentPostId = _select2.getCurrentPostId, + getEditedPostAttribute = _select2.getEditedPostAttribute; + + var postTypeSlug = getEditedPostAttribute('type'); + var postType = getPostType(postTypeSlug); + var postId = getCurrentPostId(); + var isHierarchical = Object(external_lodash_["get"])(postType, ['hierarchical'], false); + var query = { + per_page: -1, + exclude: postId, + parent_exclude: postId, + orderby: 'menu_order', + order: 'asc' + }; + return { + parent: getEditedPostAttribute('parent'), + items: isHierarchical ? getEntityRecords('postType', postTypeSlug, query) : [], + postType: postType + }; +}); +var applyWithDispatch = Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + editPost = _dispatch.editPost; + + return { + onUpdateParent: function onUpdateParent(parent) { + editPost({ + parent: parent || 0 + }); + } + }; +}); +/* harmony default export */ var page_attributes_parent = (Object(external_this_wp_compose_["compose"])([applyWithSelect, applyWithDispatch])(PageAttributesParent)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/page-attributes/template.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +function PageTemplate(_ref) { + var availableTemplates = _ref.availableTemplates, + selectedTemplate = _ref.selectedTemplate, + onUpdate = _ref.onUpdate; + + if (Object(external_lodash_["isEmpty"])(availableTemplates)) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SelectControl"], { + label: Object(external_this_wp_i18n_["__"])('Template:'), + value: selectedTemplate, + onChange: onUpdate, + className: "editor-page-attributes__template", + options: Object(external_lodash_["map"])(availableTemplates, function (templateName, templateSlug) { + return { + value: templateSlug, + label: templateName + }; + }) + }); +} +/* harmony default export */ var page_attributes_template = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getEditedPostAttribute = _select.getEditedPostAttribute, + getEditorSettings = _select.getEditorSettings; + + var _getEditorSettings = getEditorSettings(), + availableTemplates = _getEditorSettings.availableTemplates; + + return { + selectedTemplate: getEditedPostAttribute('template'), + availableTemplates: availableTemplates + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdate: function onUpdate(templateSlug) { + dispatch('core/editor').editPost({ + template: templateSlug || '' + }); + } + }; +}))(PageTemplate)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-author/check.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + +function PostAuthorCheck(_ref) { + var hasAssignAuthorAction = _ref.hasAssignAuthorAction, + authors = _ref.authors, + children = _ref.children; + + if (!hasAssignAuthorAction || authors.length < 2) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(post_type_support_check, { + supportKeys: "author" + }, children); +} +/* harmony default export */ var post_author_check = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var post = select('core/editor').getCurrentPost(); + return { + hasAssignAuthorAction: Object(external_lodash_["get"])(post, ['_links', 'wp:action-assign-author'], false), + postType: select('core/editor').getCurrentPostType(), + authors: select('core').getAuthors() + }; +}), external_this_wp_compose_["withInstanceId"]])(PostAuthorCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-author/index.js + + + + + + + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +var post_author_PostAuthor = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostAuthor, _Component); + + function PostAuthor() { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostAuthor); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostAuthor).apply(this, arguments)); + _this.setAuthorId = _this.setAuthorId.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + return _this; + } + + Object(createClass["a" /* default */])(PostAuthor, [{ + key: "setAuthorId", + value: function setAuthorId(event) { + var onUpdateAuthor = this.props.onUpdateAuthor; + var value = event.target.value; + onUpdateAuthor(Number(value)); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + postAuthor = _this$props.postAuthor, + instanceId = _this$props.instanceId, + authors = _this$props.authors; + var selectId = 'post-author-selector-' + instanceId; // Disable reason: A select with an onchange throws a warning + + /* eslint-disable jsx-a11y/no-onchange */ + + return Object(external_this_wp_element_["createElement"])(post_author_check, null, Object(external_this_wp_element_["createElement"])("label", { + htmlFor: selectId + }, Object(external_this_wp_i18n_["__"])('Author')), Object(external_this_wp_element_["createElement"])("select", { + id: selectId, + value: postAuthor, + onChange: this.setAuthorId, + className: "editor-post-author__select" + }, authors.map(function (author) { + return Object(external_this_wp_element_["createElement"])("option", { + key: author.id, + value: author.id + }, author.name); + }))); + /* eslint-enable jsx-a11y/no-onchange */ + } + }]); + + return PostAuthor; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var post_author = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + postAuthor: select('core/editor').getEditedPostAttribute('author'), + authors: select('core').getAuthors() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdateAuthor: function onUpdateAuthor(author) { + dispatch('core/editor').editPost({ + author: author + }); + } + }; +}), external_this_wp_compose_["withInstanceId"]])(post_author_PostAuthor)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-comments/index.js + + + +/** + * WordPress dependencies + */ + + + + + +function PostComments(_ref) { + var _ref$commentStatus = _ref.commentStatus, + commentStatus = _ref$commentStatus === void 0 ? 'open' : _ref$commentStatus, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["commentStatus"]); + + var onToggleComments = function onToggleComments() { + return props.editPost({ + comment_status: commentStatus === 'open' ? 'closed' : 'open' + }); + }; + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["CheckboxControl"], { + label: Object(external_this_wp_i18n_["__"])('Allow Comments'), + checked: commentStatus === 'open', + onChange: onToggleComments + }); +} + +/* harmony default export */ var post_comments = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + commentStatus: select('core/editor').getEditedPostAttribute('comment_status') + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + editPost: dispatch('core/editor').editPost + }; +})])(PostComments)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-excerpt/index.js + + +/** + * WordPress dependencies + */ + + + + + +function PostExcerpt(_ref) { + var excerpt = _ref.excerpt, + onUpdateExcerpt = _ref.onUpdateExcerpt; + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-excerpt" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["TextareaControl"], { + label: Object(external_this_wp_i18n_["__"])('Write an excerpt (optional)'), + className: "editor-post-excerpt__textarea", + onChange: function onChange(value) { + return onUpdateExcerpt(value); + }, + value: excerpt + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ExternalLink"], { + href: Object(external_this_wp_i18n_["__"])('https://codex.wordpress.org/Excerpt') + }, Object(external_this_wp_i18n_["__"])('Learn more about manual excerpts'))); +} + +/* harmony default export */ var post_excerpt = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + excerpt: select('core/editor').getEditedPostAttribute('excerpt') + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdateExcerpt: function onUpdateExcerpt(excerpt) { + dispatch('core/editor').editPost({ + excerpt: excerpt + }); + } + }; +})])(PostExcerpt)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-excerpt/check.js + + + +/** + * Internal dependencies + */ + + +function PostExcerptCheck(props) { + return Object(external_this_wp_element_["createElement"])(post_type_support_check, Object(esm_extends["a" /* default */])({}, props, { + supportKeys: "excerpt" + })); +} + +/* harmony default export */ var post_excerpt_check = (PostExcerptCheck); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/theme-support-check/index.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +function ThemeSupportCheck(_ref) { + var themeSupports = _ref.themeSupports, + children = _ref.children, + postType = _ref.postType, + supportKeys = _ref.supportKeys; + var isSupported = Object(external_lodash_["some"])(Object(external_lodash_["castArray"])(supportKeys), function (key) { + var supported = Object(external_lodash_["get"])(themeSupports, [key], false); // 'post-thumbnails' can be boolean or an array of post types. + // In the latter case, we need to verify `postType` exists + // within `supported`. If `postType` isn't passed, then the check + // should fail. + + if ('post-thumbnails' === key && Object(external_lodash_["isArray"])(supported)) { + return Object(external_lodash_["includes"])(supported, postType); + } + + return supported; + }); + + if (!isSupported) { + return null; + } + + return children; +} +/* harmony default export */ var theme_support_check = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core'), + getThemeSupports = _select.getThemeSupports; + + var _select2 = select('core/editor'), + getEditedPostAttribute = _select2.getEditedPostAttribute; + + return { + postType: getEditedPostAttribute('type'), + themeSupports: getThemeSupports() + }; +})(ThemeSupportCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-featured-image/check.js + + + +/** + * Internal dependencies + */ + + + +function PostFeaturedImageCheck(props) { + return Object(external_this_wp_element_["createElement"])(theme_support_check, { + supportKeys: "post-thumbnails" + }, Object(external_this_wp_element_["createElement"])(post_type_support_check, Object(esm_extends["a" /* default */])({}, props, { + supportKeys: "thumbnail" + }))); +} + +/* harmony default export */ var post_featured_image_check = (PostFeaturedImageCheck); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-featured-image/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + + +/** + * Internal dependencies + */ + + +var ALLOWED_MEDIA_TYPES = ['image']; // Used when labels from post type were not yet loaded or when they are not present. + +var DEFAULT_FEATURE_IMAGE_LABEL = Object(external_this_wp_i18n_["__"])('Featured Image'); + +var DEFAULT_SET_FEATURE_IMAGE_LABEL = Object(external_this_wp_i18n_["__"])('Set featured image'); + +var DEFAULT_REMOVE_FEATURE_IMAGE_LABEL = Object(external_this_wp_i18n_["__"])('Remove image'); + +function PostFeaturedImage(_ref) { + var currentPostId = _ref.currentPostId, + featuredImageId = _ref.featuredImageId, + onUpdateImage = _ref.onUpdateImage, + onRemoveImage = _ref.onRemoveImage, + media = _ref.media, + postType = _ref.postType; + var postLabel = Object(external_lodash_["get"])(postType, ['labels'], {}); + var instructions = Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_i18n_["__"])('To edit the featured image, you need permission to upload media.')); + var mediaWidth, mediaHeight, mediaSourceUrl; + + if (media) { + var mediaSize = Object(external_this_wp_hooks_["applyFilters"])('editor.PostFeaturedImage.imageSize', 'post-thumbnail', media.id, currentPostId); + + if (Object(external_lodash_["has"])(media, ['media_details', 'sizes', mediaSize])) { + mediaWidth = media.media_details.sizes[mediaSize].width; + mediaHeight = media.media_details.sizes[mediaSize].height; + mediaSourceUrl = media.media_details.sizes[mediaSize].source_url; + } else { + mediaWidth = media.media_details.width; + mediaHeight = media.media_details.height; + mediaSourceUrl = media.source_url; + } + } + + return Object(external_this_wp_element_["createElement"])(post_featured_image_check, null, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-featured-image" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["MediaUploadCheck"], { + fallback: instructions + }, Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["MediaUpload"], { + title: postLabel.featured_image || DEFAULT_FEATURE_IMAGE_LABEL, + onSelect: onUpdateImage, + allowedTypes: ALLOWED_MEDIA_TYPES, + modalClass: !featuredImageId ? 'editor-post-featured-image__media-modal' : 'editor-post-featured-image__media-modal', + render: function render(_ref2) { + var open = _ref2.open; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: !featuredImageId ? 'editor-post-featured-image__toggle' : 'editor-post-featured-image__preview', + onClick: open, + "aria-label": !featuredImageId ? null : Object(external_this_wp_i18n_["__"])('Edit or update the image') + }, !!featuredImageId && media && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ResponsiveWrapper"], { + naturalWidth: mediaWidth, + naturalHeight: mediaHeight + }, Object(external_this_wp_element_["createElement"])("img", { + src: mediaSourceUrl, + alt: "" + })), !!featuredImageId && !media && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Spinner"], null), !featuredImageId && (postLabel.set_featured_image || DEFAULT_SET_FEATURE_IMAGE_LABEL)); + }, + value: featuredImageId + })), !!featuredImageId && media && !media.isLoading && Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["MediaUploadCheck"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["MediaUpload"], { + title: postLabel.featured_image || DEFAULT_FEATURE_IMAGE_LABEL, + onSelect: onUpdateImage, + allowedTypes: ALLOWED_MEDIA_TYPES, + modalClass: "editor-post-featured-image__media-modal", + render: function render(_ref3) { + var open = _ref3.open; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + onClick: open, + isDefault: true, + isLarge: true + }, Object(external_this_wp_i18n_["__"])('Replace image')); + } + })), !!featuredImageId && Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["MediaUploadCheck"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + onClick: onRemoveImage, + isLink: true, + isDestructive: true + }, postLabel.remove_featured_image || DEFAULT_REMOVE_FEATURE_IMAGE_LABEL)))); +} + +var post_featured_image_applyWithSelect = Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core'), + getMedia = _select.getMedia, + getPostType = _select.getPostType; + + var _select2 = select('core/editor'), + getCurrentPostId = _select2.getCurrentPostId, + getEditedPostAttribute = _select2.getEditedPostAttribute; + + var featuredImageId = getEditedPostAttribute('featured_media'); + return { + media: featuredImageId ? getMedia(featuredImageId) : null, + currentPostId: getCurrentPostId(), + postType: getPostType(getEditedPostAttribute('type')), + featuredImageId: featuredImageId + }; +}); +var post_featured_image_applyWithDispatch = Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + editPost = _dispatch.editPost; + + return { + onUpdateImage: function onUpdateImage(image) { + editPost({ + featured_media: image.id + }); + }, + onRemoveImage: function onRemoveImage() { + editPost({ + featured_media: 0 + }); + } + }; +}); +/* harmony default export */ var post_featured_image = (Object(external_this_wp_compose_["compose"])(post_featured_image_applyWithSelect, post_featured_image_applyWithDispatch, Object(external_this_wp_components_["withFilters"])('editor.PostFeaturedImage'))(PostFeaturedImage)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-format/check.js + + + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + +function PostFormatCheck(_ref) { + var disablePostFormats = _ref.disablePostFormats, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["disablePostFormats"]); + + return !disablePostFormats && Object(external_this_wp_element_["createElement"])(post_type_support_check, Object(esm_extends["a" /* default */])({}, props, { + supportKeys: "post-formats" + })); +} + +/* harmony default export */ var post_format_check = (Object(external_this_wp_data_["withSelect"])(function (select) { + var editorSettings = select('core/editor').getEditorSettings(); + return { + disablePostFormats: editorSettings.disablePostFormats + }; +})(PostFormatCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-format/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + +var POST_FORMATS = [{ + id: 'aside', + caption: Object(external_this_wp_i18n_["__"])('Aside') +}, { + id: 'gallery', + caption: Object(external_this_wp_i18n_["__"])('Gallery') +}, { + id: 'link', + caption: Object(external_this_wp_i18n_["__"])('Link') +}, { + id: 'image', + caption: Object(external_this_wp_i18n_["__"])('Image') +}, { + id: 'quote', + caption: Object(external_this_wp_i18n_["__"])('Quote') +}, { + id: 'standard', + caption: Object(external_this_wp_i18n_["__"])('Standard') +}, { + id: 'status', + caption: Object(external_this_wp_i18n_["__"])('Status') +}, { + id: 'video', + caption: Object(external_this_wp_i18n_["__"])('Video') +}, { + id: 'audio', + caption: Object(external_this_wp_i18n_["__"])('Audio') +}, { + id: 'chat', + caption: Object(external_this_wp_i18n_["__"])('Chat') +}]; + +function PostFormat(_ref) { + var onUpdatePostFormat = _ref.onUpdatePostFormat, + _ref$postFormat = _ref.postFormat, + postFormat = _ref$postFormat === void 0 ? 'standard' : _ref$postFormat, + supportedFormats = _ref.supportedFormats, + suggestedFormat = _ref.suggestedFormat, + instanceId = _ref.instanceId; + var postFormatSelectorId = 'post-format-selector-' + instanceId; + var formats = POST_FORMATS.filter(function (format) { + return Object(external_lodash_["includes"])(supportedFormats, format.id); + }); + var suggestion = Object(external_lodash_["find"])(formats, function (format) { + return format.id === suggestedFormat; + }); // Disable reason: We need to change the value immiediately to show/hide the suggestion if needed + + /* eslint-disable jsx-a11y/no-onchange */ + + return Object(external_this_wp_element_["createElement"])(post_format_check, null, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-format" + }, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-format__content" + }, Object(external_this_wp_element_["createElement"])("label", { + htmlFor: postFormatSelectorId + }, Object(external_this_wp_i18n_["__"])('Post Format')), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SelectControl"], { + value: postFormat, + onChange: function onChange(format) { + return onUpdatePostFormat(format); + }, + id: postFormatSelectorId, + options: formats.map(function (format) { + return { + label: format.caption, + value: format.id + }; + }) + })), suggestion && suggestion.id !== postFormat && Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-format__suggestion" + }, Object(external_this_wp_i18n_["__"])('Suggestion:'), ' ', Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isLink: true, + onClick: function onClick() { + return onUpdatePostFormat(suggestion.id); + } + }, suggestion.caption)))); + /* eslint-enable jsx-a11y/no-onchange */ +} + +/* harmony default export */ var post_format = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getEditedPostAttribute = _select.getEditedPostAttribute, + getSuggestedPostFormat = _select.getSuggestedPostFormat; + + var postFormat = getEditedPostAttribute('format'); + var themeSupports = select('core').getThemeSupports(); // Ensure current format is always in the set. + // The current format may not be a format supported by the theme. + + var supportedFormats = Object(external_lodash_["union"])([postFormat], Object(external_lodash_["get"])(themeSupports, ['formats'], [])); + return { + postFormat: postFormat, + supportedFormats: supportedFormats, + suggestedFormat: getSuggestedPostFormat() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdatePostFormat: function onUpdatePostFormat(postFormat) { + dispatch('core/editor').editPost({ + format: postFormat + }); + } + }; +}), external_this_wp_compose_["withInstanceId"]])(PostFormat)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-last-revision/check.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + +function PostLastRevisionCheck(_ref) { + var lastRevisionId = _ref.lastRevisionId, + revisionsCount = _ref.revisionsCount, + children = _ref.children; + + if (!lastRevisionId || revisionsCount < 2) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(post_type_support_check, { + supportKeys: "revisions" + }, children); +} +/* harmony default export */ var post_last_revision_check = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getCurrentPostLastRevisionId = _select.getCurrentPostLastRevisionId, + getCurrentPostRevisionsCount = _select.getCurrentPostRevisionsCount; + + return { + lastRevisionId: getCurrentPostLastRevisionId(), + revisionsCount: getCurrentPostRevisionsCount() + }; +})(PostLastRevisionCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/utils/url.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Returns the URL of a WPAdmin Page. + * + * TODO: This should be moved to a module less specific to the editor. + * + * @param {string} page Page to navigate to. + * @param {Object} query Query Args. + * + * @return {string} WPAdmin URL. + */ + +function getWPAdminURL(page, query) { + return Object(external_this_wp_url_["addQueryArgs"])(page, query); +} +/** + * Performs some basic cleanup of a string for use as a post slug + * + * This replicates some of what santize_title() does in WordPress core, but + * is only designed to approximate what the slug will be. + * + * Converts whitespace, periods, forward slashes and underscores to hyphens. + * Converts Latin-1 Supplement and Latin Extended-A letters to basic Latin + * letters. Removes combining diacritical marks. Converts remaining string + * to lowercase. It does not touch octets, HTML entities, or other encoded + * characters. + * + * @param {string} string Title or slug to be processed + * + * @return {string} Processed string + */ + +function cleanForSlug(string) { + return Object(external_lodash_["toLower"])(Object(external_lodash_["deburr"])(Object(external_lodash_["trim"])(string.replace(/[\s\./_]+/g, '-'), '-'))); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-last-revision/index.js + + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + +function LastRevision(_ref) { + var lastRevisionId = _ref.lastRevisionId, + revisionsCount = _ref.revisionsCount; + return Object(external_this_wp_element_["createElement"])(post_last_revision_check, null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + href: getWPAdminURL('revision.php', { + revision: lastRevisionId, + gutenberg: true + }), + className: "editor-post-last-revision__title", + icon: "backup" + }, Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('%d Revision', '%d Revisions', revisionsCount), revisionsCount))); +} + +/* harmony default export */ var post_last_revision = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getCurrentPostLastRevisionId = _select.getCurrentPostLastRevisionId, + getCurrentPostRevisionsCount = _select.getCurrentPostRevisionsCount; + + return { + lastRevisionId: getCurrentPostLastRevisionId(), + revisionsCount: getCurrentPostRevisionsCount() + }; +})(LastRevision)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-preview-button/index.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + + + + +function writeInterstitialMessage(targetDocument) { + var markup = Object(external_this_wp_element_["renderToString"])(Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-preview-button__interstitial-message" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 96 96" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + className: "outer", + d: "M48 12c19.9 0 36 16.1 36 36S67.9 84 48 84 12 67.9 12 48s16.1-36 36-36", + fill: "none" + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + className: "inner", + d: "M69.5 46.4c0-3.9-1.4-6.7-2.6-8.8-1.6-2.6-3.1-4.9-3.1-7.5 0-2.9 2.2-5.7 5.4-5.7h.4C63.9 19.2 56.4 16 48 16c-11.2 0-21 5.7-26.7 14.4h2.1c3.3 0 8.5-.4 8.5-.4 1.7-.1 1.9 2.4.2 2.6 0 0-1.7.2-3.7.3L40 67.5l7-20.9L42 33c-1.7-.1-3.3-.3-3.3-.3-1.7-.1-1.5-2.7.2-2.6 0 0 5.3.4 8.4.4 3.3 0 8.5-.4 8.5-.4 1.7-.1 1.9 2.4.2 2.6 0 0-1.7.2-3.7.3l11.5 34.3 3.3-10.4c1.6-4.5 2.4-7.8 2.4-10.5zM16.1 48c0 12.6 7.3 23.5 18 28.7L18.8 35c-1.7 4-2.7 8.4-2.7 13zm32.5 2.8L39 78.6c2.9.8 5.9 1.3 9 1.3 3.7 0 7.3-.6 10.6-1.8-.1-.1-.2-.3-.2-.4l-9.8-26.9zM76.2 36c0 3.2-.6 6.9-2.4 11.4L64 75.6c9.5-5.5 15.9-15.8 15.9-27.6 0-5.5-1.4-10.8-3.9-15.3.1 1 .2 2.1.2 3.3z", + fill: "none" + })), Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_i18n_["__"])('Generating preview…')))); + markup += "\n\t\t\n\t"; + /** + * Filters the interstitial message shown when generating previews. + * + * @param {String} markup The preview interstitial markup. + */ + + markup = Object(external_this_wp_hooks_["applyFilters"])('editor.PostPreview.interstitialMarkup', markup); + targetDocument.write(markup); + targetDocument.title = Object(external_this_wp_i18n_["__"])('Generating preview…'); + targetDocument.close(); +} + +var post_preview_button_PostPreviewButton = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostPreviewButton, _Component); + + function PostPreviewButton() { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostPreviewButton); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostPreviewButton).apply(this, arguments)); + _this.openPreviewWindow = _this.openPreviewWindow.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + return _this; + } + + Object(createClass["a" /* default */])(PostPreviewButton, [{ + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var previewLink = this.props.previewLink; // This relies on the window being responsible to unset itself when + // navigation occurs or a new preview window is opened, to avoid + // unintentional forceful redirects. + + if (previewLink && !prevProps.previewLink) { + this.setPreviewWindowLink(previewLink); + } + } + /** + * Sets the preview window's location to the given URL, if a preview window + * exists and is not closed. + * + * @param {string} url URL to assign as preview window location. + */ + + }, { + key: "setPreviewWindowLink", + value: function setPreviewWindowLink(url) { + var previewWindow = this.previewWindow; + + if (previewWindow && !previewWindow.closed) { + previewWindow.location = url; + } + } + }, { + key: "getWindowTarget", + value: function getWindowTarget() { + var postId = this.props.postId; + return "wp-preview-".concat(postId); + } + }, { + key: "openPreviewWindow", + value: function openPreviewWindow(event) { + // Our Preview button has its 'href' and 'target' set correctly for a11y + // purposes. Unfortunately, though, we can't rely on the default 'click' + // handler since sometimes it incorrectly opens a new tab instead of reusing + // the existing one. + // https://github.com/WordPress/gutenberg/pull/8330 + event.preventDefault(); // Open up a Preview tab if needed. This is where we'll show the preview. + + if (!this.previewWindow || this.previewWindow.closed) { + this.previewWindow = window.open('', this.getWindowTarget()); + } // Focus the Preview tab. This might not do anything, depending on the browser's + // and user's preferences. + // https://html.spec.whatwg.org/multipage/interaction.html#dom-window-focus + + + this.previewWindow.focus(); // If we don't need to autosave the post before previewing, then we simply + // load the Preview URL in the Preview tab. + + if (!this.props.isAutosaveable) { + this.setPreviewWindowLink(event.target.href); + return; + } // Request an autosave. This happens asynchronously and causes the component + // to update when finished. + + + if (this.props.isDraft) { + this.props.savePost({ + isPreview: true + }); + } else { + this.props.autosave({ + isPreview: true + }); + } // Display a 'Generating preview' message in the Preview tab while we wait for the + // autosave to finish. + + + writeInterstitialMessage(this.previewWindow.document); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + previewLink = _this$props.previewLink, + currentPostLink = _this$props.currentPostLink, + isSaveable = _this$props.isSaveable; // Link to the `?preview=true` URL if we have it, since this lets us see + // changes that were autosaved since the post was last published. Otherwise, + // just link to the post's URL. + + var href = previewLink || currentPostLink; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isLarge: true, + className: "editor-post-preview", + href: href, + target: this.getWindowTarget(), + disabled: !isSaveable, + onClick: this.openPreviewWindow + }, Object(external_this_wp_i18n_["_x"])('Preview', 'imperative verb'), Object(external_this_wp_element_["createElement"])("span", { + className: "screen-reader-text" + }, + /* translators: accessibility text */ + Object(external_this_wp_i18n_["__"])('(opens in a new tab)')), Object(external_this_wp_element_["createElement"])(external_this_wp_nux_["DotTip"], { + tipId: "core/editor.preview" + }, Object(external_this_wp_i18n_["__"])('Click “Preview” to load a preview of this page, so you can make sure you’re happy with your blocks.'))); + } + }]); + + return PostPreviewButton; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var post_preview_button = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, _ref) { + var forcePreviewLink = _ref.forcePreviewLink, + forceIsAutosaveable = _ref.forceIsAutosaveable; + + var _select = select('core/editor'), + getCurrentPostId = _select.getCurrentPostId, + getCurrentPostAttribute = _select.getCurrentPostAttribute, + getEditedPostAttribute = _select.getEditedPostAttribute, + isEditedPostSaveable = _select.isEditedPostSaveable, + isEditedPostAutosaveable = _select.isEditedPostAutosaveable, + getEditedPostPreviewLink = _select.getEditedPostPreviewLink; + + var _select2 = select('core'), + getPostType = _select2.getPostType; + + var previewLink = getEditedPostPreviewLink(); + var postType = getPostType(getEditedPostAttribute('type')); + return { + postId: getCurrentPostId(), + currentPostLink: getCurrentPostAttribute('link'), + previewLink: forcePreviewLink !== undefined ? forcePreviewLink : previewLink, + isSaveable: isEditedPostSaveable(), + isAutosaveable: forceIsAutosaveable || isEditedPostAutosaveable(), + isViewable: Object(external_lodash_["get"])(postType, ['viewable'], false), + isDraft: ['draft', 'auto-draft'].indexOf(getEditedPostAttribute('status')) !== -1 + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + autosave: dispatch('core/editor').autosave, + savePost: dispatch('core/editor').savePost + }; +}), Object(external_this_wp_compose_["ifCondition"])(function (_ref2) { + var isViewable = _ref2.isViewable; + return isViewable; +})])(post_preview_button_PostPreviewButton)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-locked-modal/index.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + + + +/** + * Internal dependencies + */ + + + + +var post_locked_modal_PostLockedModal = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostLockedModal, _Component); + + function PostLockedModal() { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostLockedModal); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostLockedModal).apply(this, arguments)); + _this.sendPostLock = _this.sendPostLock.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.receivePostLock = _this.receivePostLock.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.releasePostLock = _this.releasePostLock.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + return _this; + } + + Object(createClass["a" /* default */])(PostLockedModal, [{ + key: "componentDidMount", + value: function componentDidMount() { + var hookName = this.getHookName(); // Details on these events on the Heartbeat API docs + // https://developer.wordpress.org/plugins/javascript/heartbeat-api/ + + Object(external_this_wp_hooks_["addAction"])('heartbeat.send', hookName, this.sendPostLock); + Object(external_this_wp_hooks_["addAction"])('heartbeat.tick', hookName, this.receivePostLock); + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + var hookName = this.getHookName(); + Object(external_this_wp_hooks_["removeAction"])('heartbeat.send', hookName); + Object(external_this_wp_hooks_["removeAction"])('heartbeat.tick', hookName); + } + /** + * Returns a `@wordpress/hooks` hook name specific to the instance of the + * component. + * + * @return {string} Hook name prefix. + */ + + }, { + key: "getHookName", + value: function getHookName() { + var instanceId = this.props.instanceId; + return 'core/editor/post-locked-modal-' + instanceId; + } + /** + * Keep the lock refreshed. + * + * When the user does not send a heartbeat in a heartbeat-tick + * the user is no longer editing and another user can start editing. + * + * @param {Object} data Data to send in the heartbeat request. + */ + + }, { + key: "sendPostLock", + value: function sendPostLock(data) { + var _this$props = this.props, + isLocked = _this$props.isLocked, + activePostLock = _this$props.activePostLock, + postId = _this$props.postId; + + if (isLocked) { + return; + } + + data['wp-refresh-post-lock'] = { + lock: activePostLock, + post_id: postId + }; + } + /** + * Refresh post locks: update the lock string or show the dialog if somebody has taken over editing. + * + * @param {Object} data Data received in the heartbeat request + */ + + }, { + key: "receivePostLock", + value: function receivePostLock(data) { + if (!data['wp-refresh-post-lock']) { + return; + } + + var _this$props2 = this.props, + autosave = _this$props2.autosave, + updatePostLock = _this$props2.updatePostLock; + var received = data['wp-refresh-post-lock']; + + if (received.lock_error) { + // Auto save and display the takeover modal. + autosave(); + updatePostLock({ + isLocked: true, + isTakeover: true, + user: { + avatar: received.lock_error.avatar_src + } + }); + } else if (received.new_lock) { + updatePostLock({ + isLocked: false, + activePostLock: received.new_lock + }); + } + } + /** + * Unlock the post before the window is exited. + */ + + }, { + key: "releasePostLock", + value: function releasePostLock() { + var _this$props3 = this.props, + isLocked = _this$props3.isLocked, + activePostLock = _this$props3.activePostLock, + postLockUtils = _this$props3.postLockUtils, + postId = _this$props3.postId; + + if (isLocked || !activePostLock) { + return; + } + + var data = new window.FormData(); + data.append('action', 'wp-remove-post-lock'); + data.append('_wpnonce', postLockUtils.unlockNonce); + data.append('post_ID', postId); + data.append('active_post_lock', activePostLock); + var xhr = new window.XMLHttpRequest(); + xhr.open('POST', postLockUtils.ajaxUrl, false); + xhr.send(data); + } + }, { + key: "render", + value: function render() { + var _this$props4 = this.props, + user = _this$props4.user, + postId = _this$props4.postId, + isLocked = _this$props4.isLocked, + isTakeover = _this$props4.isTakeover, + postLockUtils = _this$props4.postLockUtils, + postType = _this$props4.postType; + + if (!isLocked) { + return null; + } + + var userDisplayName = user.name; + var userAvatar = user.avatar; + var unlockUrl = Object(external_this_wp_url_["addQueryArgs"])('post.php', { + 'get-post-lock': '1', + lockKey: true, + post: postId, + action: 'edit', + _wpnonce: postLockUtils.nonce + }); + var allPostsUrl = getWPAdminURL('edit.php', { + post_type: Object(external_lodash_["get"])(postType, ['slug']) + }); + + var allPostsLabel = Object(external_this_wp_i18n_["__"])('Exit the Editor'); + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Modal"], { + title: isTakeover ? Object(external_this_wp_i18n_["__"])('Someone else has taken over this post.') : Object(external_this_wp_i18n_["__"])('This post is already being edited.'), + focusOnMount: true, + shouldCloseOnClickOutside: false, + shouldCloseOnEsc: false, + isDismissable: false, + className: "editor-post-locked-modal" + }, !!userAvatar && Object(external_this_wp_element_["createElement"])("img", { + src: userAvatar, + alt: Object(external_this_wp_i18n_["__"])('Avatar'), + className: "editor-post-locked-modal__avatar" + }), !!isTakeover && Object(external_this_wp_element_["createElement"])("div", null, Object(external_this_wp_element_["createElement"])("div", null, userDisplayName ? Object(external_this_wp_i18n_["sprintf"])( + /* translators: %s: user's display name */ + Object(external_this_wp_i18n_["__"])('%s now has editing control of this post. Don’t worry, your changes up to this moment have been saved.'), userDisplayName) : Object(external_this_wp_i18n_["__"])('Another user now has editing control of this post. Don’t worry, your changes up to this moment have been saved.')), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-locked-modal__buttons" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isPrimary: true, + isLarge: true, + href: allPostsUrl + }, allPostsLabel))), !isTakeover && Object(external_this_wp_element_["createElement"])("div", null, Object(external_this_wp_element_["createElement"])("div", null, userDisplayName ? Object(external_this_wp_i18n_["sprintf"])( + /* translators: %s: user's display name */ + Object(external_this_wp_i18n_["__"])('%s is currently working on this post, which means you cannot make changes, unless you take over.'), userDisplayName) : Object(external_this_wp_i18n_["__"])('Another user is currently working on this post, which means you cannot make changes, unless you take over.')), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-locked-modal__buttons" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isDefault: true, + isLarge: true, + href: allPostsUrl + }, allPostsLabel), Object(external_this_wp_element_["createElement"])(post_preview_button, null), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isPrimary: true, + isLarge: true, + href: unlockUrl + }, Object(external_this_wp_i18n_["__"])('Take Over'))))); + } + }]); + + return PostLockedModal; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var post_locked_modal = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isPostLocked = _select.isPostLocked, + isPostLockTakeover = _select.isPostLockTakeover, + getPostLockUser = _select.getPostLockUser, + getCurrentPostId = _select.getCurrentPostId, + getActivePostLock = _select.getActivePostLock, + getEditedPostAttribute = _select.getEditedPostAttribute, + getEditorSettings = _select.getEditorSettings; + + var _select2 = select('core'), + getPostType = _select2.getPostType; + + return { + isLocked: isPostLocked(), + isTakeover: isPostLockTakeover(), + user: getPostLockUser(), + postId: getCurrentPostId(), + postLockUtils: getEditorSettings().postLockUtils, + activePostLock: getActivePostLock(), + postType: getPostType(getEditedPostAttribute('type')) + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + autosave = _dispatch.autosave, + updatePostLock = _dispatch.updatePostLock; + + return { + autosave: autosave, + updatePostLock: updatePostLock + }; +}), external_this_wp_compose_["withInstanceId"], Object(external_this_wp_compose_["withGlobalEvents"])({ + beforeunload: 'releasePostLock' +}))(post_locked_modal_PostLockedModal)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-pending-status/check.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +function PostPendingStatusCheck(_ref) { + var hasPublishAction = _ref.hasPublishAction, + isPublished = _ref.isPublished, + children = _ref.children; + + if (isPublished || !hasPublishAction) { + return null; + } + + return children; +} +/* harmony default export */ var post_pending_status_check = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isCurrentPostPublished = _select.isCurrentPostPublished, + getCurrentPostType = _select.getCurrentPostType, + getCurrentPost = _select.getCurrentPost; + + return { + hasPublishAction: Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-publish'], false), + isPublished: isCurrentPostPublished(), + postType: getCurrentPostType() + }; +}))(PostPendingStatusCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-pending-status/index.js + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +function PostPendingStatus(_ref) { + var status = _ref.status, + onUpdateStatus = _ref.onUpdateStatus; + + var togglePendingStatus = function togglePendingStatus() { + var updatedStatus = status === 'pending' ? 'draft' : 'pending'; + onUpdateStatus(updatedStatus); + }; + + return Object(external_this_wp_element_["createElement"])(post_pending_status_check, null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["CheckboxControl"], { + label: Object(external_this_wp_i18n_["__"])('Pending Review'), + checked: status === 'pending', + onChange: togglePendingStatus + })); +} +/* harmony default export */ var post_pending_status = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select) { + return { + status: select('core/editor').getEditedPostAttribute('status') + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdateStatus: function onUpdateStatus(status) { + dispatch('core/editor').editPost({ + status: status + }); + } + }; +}))(PostPendingStatus)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-pingbacks/index.js + + + +/** + * WordPress dependencies + */ + + + + + +function PostPingbacks(_ref) { + var _ref$pingStatus = _ref.pingStatus, + pingStatus = _ref$pingStatus === void 0 ? 'open' : _ref$pingStatus, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["pingStatus"]); + + var onTogglePingback = function onTogglePingback() { + return props.editPost({ + ping_status: pingStatus === 'open' ? 'closed' : 'open' + }); + }; + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["CheckboxControl"], { + label: Object(external_this_wp_i18n_["__"])('Allow Pingbacks & Trackbacks'), + checked: pingStatus === 'open', + onChange: onTogglePingback + }); +} + +/* harmony default export */ var post_pingbacks = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + pingStatus: select('core/editor').getEditedPostAttribute('ping_status') + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + editPost: dispatch('core/editor').editPost + }; +})])(PostPingbacks)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-publish-button/label.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +function PublishButtonLabel(_ref) { + var isPublished = _ref.isPublished, + isBeingScheduled = _ref.isBeingScheduled, + isSaving = _ref.isSaving, + isPublishing = _ref.isPublishing, + hasPublishAction = _ref.hasPublishAction, + isAutosaving = _ref.isAutosaving; + + if (isPublishing) { + return Object(external_this_wp_i18n_["__"])('Publishing…'); + } else if (isPublished && isSaving && !isAutosaving) { + return Object(external_this_wp_i18n_["__"])('Updating…'); + } else if (isBeingScheduled && isSaving && !isAutosaving) { + return Object(external_this_wp_i18n_["__"])('Scheduling…'); + } + + if (!hasPublishAction) { + return Object(external_this_wp_i18n_["__"])('Submit for Review'); + } else if (isPublished) { + return Object(external_this_wp_i18n_["__"])('Update'); + } else if (isBeingScheduled) { + return Object(external_this_wp_i18n_["__"])('Schedule'); + } + + return Object(external_this_wp_i18n_["__"])('Publish'); +} +/* harmony default export */ var post_publish_button_label = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { + var forceIsSaving = _ref2.forceIsSaving; + + var _select = select('core/editor'), + isCurrentPostPublished = _select.isCurrentPostPublished, + isEditedPostBeingScheduled = _select.isEditedPostBeingScheduled, + isSavingPost = _select.isSavingPost, + isPublishingPost = _select.isPublishingPost, + getCurrentPost = _select.getCurrentPost, + getCurrentPostType = _select.getCurrentPostType, + isAutosavingPost = _select.isAutosavingPost; + + return { + isPublished: isCurrentPostPublished(), + isBeingScheduled: isEditedPostBeingScheduled(), + isSaving: forceIsSaving || isSavingPost(), + isPublishing: isPublishingPost(), + hasPublishAction: Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-publish'], false), + postType: getCurrentPostType(), + isAutosaving: isAutosavingPost() + }; +})])(PublishButtonLabel)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-publish-button/index.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + + +/** + * Internal dependencies + */ + + +var post_publish_button_PostPublishButton = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostPublishButton, _Component); + + function PostPublishButton(props) { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostPublishButton); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostPublishButton).call(this, props)); + _this.buttonNode = Object(external_this_wp_element_["createRef"])(); + return _this; + } + + Object(createClass["a" /* default */])(PostPublishButton, [{ + key: "componentDidMount", + value: function componentDidMount() { + if (this.props.focusOnMount) { + this.buttonNode.current.focus(); + } + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + forceIsDirty = _this$props.forceIsDirty, + forceIsSaving = _this$props.forceIsSaving, + hasPublishAction = _this$props.hasPublishAction, + isBeingScheduled = _this$props.isBeingScheduled, + isOpen = _this$props.isOpen, + isPostSavingLocked = _this$props.isPostSavingLocked, + isPublishable = _this$props.isPublishable, + isPublished = _this$props.isPublished, + isSaveable = _this$props.isSaveable, + isSaving = _this$props.isSaving, + isToggle = _this$props.isToggle, + onSave = _this$props.onSave, + onStatusChange = _this$props.onStatusChange, + _this$props$onSubmit = _this$props.onSubmit, + onSubmit = _this$props$onSubmit === void 0 ? external_lodash_["noop"] : _this$props$onSubmit, + onToggle = _this$props.onToggle, + visibility = _this$props.visibility; + var isButtonDisabled = isSaving || forceIsSaving || !isSaveable || isPostSavingLocked || !isPublishable && !forceIsDirty; + var isToggleDisabled = isPublished || isSaving || forceIsSaving || !isSaveable || !isPublishable && !forceIsDirty; + var publishStatus; + + if (!hasPublishAction) { + publishStatus = 'pending'; + } else if (isBeingScheduled) { + publishStatus = 'future'; + } else if (visibility === 'private') { + publishStatus = 'private'; + } else { + publishStatus = 'publish'; + } + + var onClickButton = function onClickButton() { + if (isButtonDisabled) { + return; + } + + onSubmit(); + onStatusChange(publishStatus); + onSave(); + }; + + var onClickToggle = function onClickToggle() { + if (isToggleDisabled) { + return; + } + + onToggle(); + }; + + var buttonProps = { + 'aria-disabled': isButtonDisabled, + className: 'editor-post-publish-button', + isBusy: isSaving && isPublished, + isLarge: true, + isPrimary: true, + onClick: onClickButton + }; + var toggleProps = { + 'aria-disabled': isToggleDisabled, + 'aria-expanded': isOpen, + className: 'editor-post-publish-panel__toggle', + isBusy: isSaving && isPublished, + isPrimary: true, + onClick: onClickToggle + }; + var toggleChildren = isBeingScheduled ? Object(external_this_wp_i18n_["__"])('Schedule…') : Object(external_this_wp_i18n_["__"])('Publish…'); + var buttonChildren = Object(external_this_wp_element_["createElement"])(post_publish_button_label, { + forceIsSaving: forceIsSaving + }); + var componentProps = isToggle ? toggleProps : buttonProps; + var componentChildren = isToggle ? toggleChildren : buttonChildren; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], Object(esm_extends["a" /* default */])({ + ref: this.buttonNode + }, componentProps), componentChildren, Object(external_this_wp_element_["createElement"])(external_this_wp_nux_["DotTip"], { + tipId: "core/editor.publish" + }, Object(external_this_wp_i18n_["__"])('Finished writing? That’s great, let’s get this published right now. Just click “Publish” and you’re good to go.'))); + } + }]); + + return PostPublishButton; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var post_publish_button = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isSavingPost = _select.isSavingPost, + isEditedPostBeingScheduled = _select.isEditedPostBeingScheduled, + getEditedPostVisibility = _select.getEditedPostVisibility, + isCurrentPostPublished = _select.isCurrentPostPublished, + isEditedPostSaveable = _select.isEditedPostSaveable, + isEditedPostPublishable = _select.isEditedPostPublishable, + isPostSavingLocked = _select.isPostSavingLocked, + getCurrentPost = _select.getCurrentPost, + getCurrentPostType = _select.getCurrentPostType; + + return { + isSaving: isSavingPost(), + isBeingScheduled: isEditedPostBeingScheduled(), + visibility: getEditedPostVisibility(), + isSaveable: isEditedPostSaveable(), + isPostSavingLocked: isPostSavingLocked(), + isPublishable: isEditedPostPublishable(), + isPublished: isCurrentPostPublished(), + hasPublishAction: Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-publish'], false), + postType: getCurrentPostType() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + editPost = _dispatch.editPost, + savePost = _dispatch.savePost; + + return { + onStatusChange: function onStatusChange(status) { + return editPost({ + status: status + }); + }, + onSave: savePost + }; +})])(post_publish_button_PostPublishButton)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-visibility/utils.js +/** + * WordPress dependencies + */ + +var visibilityOptions = [{ + value: 'public', + label: Object(external_this_wp_i18n_["__"])('Public'), + info: Object(external_this_wp_i18n_["__"])('Visible to everyone.') +}, { + value: 'private', + label: Object(external_this_wp_i18n_["__"])('Private'), + info: Object(external_this_wp_i18n_["__"])('Only visible to site admins and editors.') +}, { + value: 'password', + label: Object(external_this_wp_i18n_["__"])('Password Protected'), + info: Object(external_this_wp_i18n_["__"])('Protected with a password you choose. Only those with the password can view this post.') +}]; + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-visibility/index.js + + + + + + + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +var post_visibility_PostVisibility = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostVisibility, _Component); + + function PostVisibility(props) { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostVisibility); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostVisibility).apply(this, arguments)); + _this.setPublic = _this.setPublic.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.setPrivate = _this.setPrivate.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.setPasswordProtected = _this.setPasswordProtected.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.updatePassword = _this.updatePassword.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.state = { + hasPassword: !!props.password + }; + return _this; + } + + Object(createClass["a" /* default */])(PostVisibility, [{ + key: "setPublic", + value: function setPublic() { + var _this$props = this.props, + visibility = _this$props.visibility, + onUpdateVisibility = _this$props.onUpdateVisibility, + status = _this$props.status; + onUpdateVisibility(visibility === 'private' ? 'draft' : status); + this.setState({ + hasPassword: false + }); + } + }, { + key: "setPrivate", + value: function setPrivate() { + if (!window.confirm(Object(external_this_wp_i18n_["__"])('Would you like to privately publish this post now?'))) { + // eslint-disable-line no-alert + return; + } + + var _this$props2 = this.props, + onUpdateVisibility = _this$props2.onUpdateVisibility, + onSave = _this$props2.onSave; + onUpdateVisibility('private'); + this.setState({ + hasPassword: false + }); + onSave(); + } + }, { + key: "setPasswordProtected", + value: function setPasswordProtected() { + var _this$props3 = this.props, + visibility = _this$props3.visibility, + onUpdateVisibility = _this$props3.onUpdateVisibility, + status = _this$props3.status, + password = _this$props3.password; + onUpdateVisibility(visibility === 'private' ? 'draft' : status, password || ''); + this.setState({ + hasPassword: true + }); + } + }, { + key: "updatePassword", + value: function updatePassword(event) { + var _this$props4 = this.props, + status = _this$props4.status, + onUpdateVisibility = _this$props4.onUpdateVisibility; + onUpdateVisibility(status, event.target.value); + } + }, { + key: "render", + value: function render() { + var _this$props5 = this.props, + visibility = _this$props5.visibility, + password = _this$props5.password, + instanceId = _this$props5.instanceId; + var visibilityHandlers = { + public: { + onSelect: this.setPublic, + checked: visibility === 'public' && !this.state.hasPassword + }, + private: { + onSelect: this.setPrivate, + checked: visibility === 'private' + }, + password: { + onSelect: this.setPasswordProtected, + checked: this.state.hasPassword + } + }; + return [Object(external_this_wp_element_["createElement"])("fieldset", { + key: "visibility-selector", + className: "editor-post-visibility__dialog-fieldset" + }, Object(external_this_wp_element_["createElement"])("legend", { + className: "editor-post-visibility__dialog-legend" + }, Object(external_this_wp_i18n_["__"])('Post Visibility')), visibilityOptions.map(function (_ref) { + var value = _ref.value, + label = _ref.label, + info = _ref.info; + return Object(external_this_wp_element_["createElement"])("div", { + key: value, + className: "editor-post-visibility__choice" + }, Object(external_this_wp_element_["createElement"])("input", { + type: "radio", + name: "editor-post-visibility__setting-".concat(instanceId), + value: value, + onChange: visibilityHandlers[value].onSelect, + checked: visibilityHandlers[value].checked, + id: "editor-post-".concat(value, "-").concat(instanceId), + "aria-describedby": "editor-post-".concat(value, "-").concat(instanceId, "-description"), + className: "editor-post-visibility__dialog-radio" + }), Object(external_this_wp_element_["createElement"])("label", { + htmlFor: "editor-post-".concat(value, "-").concat(instanceId), + className: "editor-post-visibility__dialog-label" + }, label), Object(external_this_wp_element_["createElement"])("p", { + id: "editor-post-".concat(value, "-").concat(instanceId, "-description"), + className: "editor-post-visibility__dialog-info" + }, info)); + })), this.state.hasPassword && Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-visibility__dialog-password", + key: "password-selector" + }, Object(external_this_wp_element_["createElement"])("label", { + htmlFor: "editor-post-visibility__dialog-password-input-".concat(instanceId), + className: "screen-reader-text" + }, Object(external_this_wp_i18n_["__"])('Create password')), Object(external_this_wp_element_["createElement"])("input", { + className: "editor-post-visibility__dialog-password-input", + id: "editor-post-visibility__dialog-password-input-".concat(instanceId), + type: "text", + onChange: this.updatePassword, + value: password, + placeholder: Object(external_this_wp_i18n_["__"])('Use a secure password') + }))]; + } + }]); + + return PostVisibility; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var post_visibility = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getEditedPostAttribute = _select.getEditedPostAttribute, + getEditedPostVisibility = _select.getEditedPostVisibility; + + return { + status: getEditedPostAttribute('status'), + visibility: getEditedPostVisibility(), + password: getEditedPostAttribute('password') + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + savePost = _dispatch.savePost, + editPost = _dispatch.editPost; + + return { + onSave: savePost, + onUpdateVisibility: function onUpdateVisibility(status) { + var password = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + editPost({ + status: status, + password: password + }); + } + }; +}), external_this_wp_compose_["withInstanceId"]])(post_visibility_PostVisibility)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-visibility/label.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + + +function PostVisibilityLabel(_ref) { + var visibility = _ref.visibility; + + var getVisibilityLabel = function getVisibilityLabel() { + return Object(external_lodash_["find"])(visibilityOptions, { + value: visibility + }).label; + }; + + return getVisibilityLabel(visibility); +} + +/* harmony default export */ var post_visibility_label = (Object(external_this_wp_data_["withSelect"])(function (select) { + return { + visibility: select('core/editor').getEditedPostVisibility() + }; +})(PostVisibilityLabel)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-schedule/index.js + + +/** + * WordPress dependencies + */ + + + + +function PostSchedule(_ref) { + var date = _ref.date, + onUpdateDate = _ref.onUpdateDate; + + var settings = Object(external_this_wp_date_["__experimentalGetSettings"])(); // To know if the current timezone is a 12 hour time with look for "a" in the time format + // We also make sure this a is not escaped by a "/" + + + var is12HourTime = /a(?!\\)/i.test(settings.formats.time.toLowerCase() // Test only the lower case a + .replace(/\\\\/g, '') // Replace "//" with empty strings + .split('').reverse().join('') // Reverse the string and test for "a" not followed by a slash + ); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["DateTimePicker"], { + key: "date-time-picker", + currentDate: date, + onChange: onUpdateDate, + is12Hour: is12HourTime + }); +} +/* harmony default export */ var post_schedule = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + date: select('core/editor').getEditedPostAttribute('date') + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdateDate: function onUpdateDate(date) { + dispatch('core/editor').editPost({ + date: date + }); + } + }; +})])(PostSchedule)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-schedule/label.js +/** + * WordPress dependencies + */ + + + +function PostScheduleLabel(_ref) { + var date = _ref.date, + isFloating = _ref.isFloating; + + var settings = Object(external_this_wp_date_["__experimentalGetSettings"])(); + + return date && !isFloating ? Object(external_this_wp_date_["dateI18n"])(settings.formats.datetimeAbbreviated, date) : Object(external_this_wp_i18n_["__"])('Immediately'); +} +/* harmony default export */ var post_schedule_label = (Object(external_this_wp_data_["withSelect"])(function (select) { + return { + date: select('core/editor').getEditedPostAttribute('date'), + isFloating: select('core/editor').isEditedPostDateFloating() + }; +})(PostScheduleLabel)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-taxonomies/flat-term-selector.js + + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + + + +/** + * Module constants + */ + +var DEFAULT_QUERY = { + per_page: -1, + orderby: 'count', + order: 'desc', + _fields: 'id,name' +}; +var MAX_TERMS_SUGGESTIONS = 20; + +var isSameTermName = function isSameTermName(termA, termB) { + return termA.toLowerCase() === termB.toLowerCase(); +}; +/** + * Returns a term object with name unescaped. + * The unescape of the name propery is done using lodash unescape function. + * + * @param {Object} term The term object to unescape. + * + * @return {Object} Term object with name property unescaped. + */ + + +var flat_term_selector_unescapeTerm = function unescapeTerm(term) { + return Object(objectSpread["a" /* default */])({}, term, { + name: Object(external_lodash_["unescape"])(term.name) + }); +}; +/** + * Returns an array of term objects with names unescaped. + * The unescape of each term is performed using the unescapeTerm function. + * + * @param {Object[]} terms Array of term objects to unescape. + * + * @return {Object[]} Array of therm objects unscaped. + */ + + +var flat_term_selector_unescapeTerms = function unescapeTerms(terms) { + return Object(external_lodash_["map"])(terms, flat_term_selector_unescapeTerm); +}; + +var flat_term_selector_FlatTermSelector = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(FlatTermSelector, _Component); + + function FlatTermSelector() { + var _this; + + Object(classCallCheck["a" /* default */])(this, FlatTermSelector); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(FlatTermSelector).apply(this, arguments)); + _this.onChange = _this.onChange.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.searchTerms = Object(external_lodash_["throttle"])(_this.searchTerms.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))), 500); + _this.findOrCreateTerm = _this.findOrCreateTerm.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.state = { + loading: !Object(external_lodash_["isEmpty"])(_this.props.terms), + availableTerms: [], + selectedTerms: [] + }; + return _this; + } + + Object(createClass["a" /* default */])(FlatTermSelector, [{ + key: "componentDidMount", + value: function componentDidMount() { + var _this2 = this; + + if (!Object(external_lodash_["isEmpty"])(this.props.terms)) { + this.initRequest = this.fetchTerms({ + include: this.props.terms.join(','), + per_page: -1 + }); + this.initRequest.then(function () { + _this2.setState({ + loading: false + }); + }, function (xhr) { + if (xhr.statusText === 'abort') { + return; + } + + _this2.setState({ + loading: false + }); + }); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + Object(external_lodash_["invoke"])(this.initRequest, ['abort']); + Object(external_lodash_["invoke"])(this.searchRequest, ['abort']); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + if (prevProps.terms !== this.props.terms) { + this.updateSelectedTerms(this.props.terms); + } + } + }, { + key: "fetchTerms", + value: function fetchTerms() { + var _this3 = this; + + var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var taxonomy = this.props.taxonomy; + + var query = Object(objectSpread["a" /* default */])({}, DEFAULT_QUERY, params); + + var request = external_this_wp_apiFetch_default()({ + path: Object(external_this_wp_url_["addQueryArgs"])("/wp/v2/".concat(taxonomy.rest_base), query) + }); + request.then(flat_term_selector_unescapeTerms).then(function (terms) { + _this3.setState(function (state) { + return { + availableTerms: state.availableTerms.concat(terms.filter(function (term) { + return !Object(external_lodash_["find"])(state.availableTerms, function (availableTerm) { + return availableTerm.id === term.id; + }); + })) + }; + }); + + _this3.updateSelectedTerms(_this3.props.terms); + }); + return request; + } + }, { + key: "updateSelectedTerms", + value: function updateSelectedTerms() { + var _this4 = this; + + var terms = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + var selectedTerms = terms.reduce(function (result, termId) { + var termObject = Object(external_lodash_["find"])(_this4.state.availableTerms, function (term) { + return term.id === termId; + }); + + if (termObject) { + result.push(termObject.name); + } + + return result; + }, []); + this.setState({ + selectedTerms: selectedTerms + }); + } + }, { + key: "findOrCreateTerm", + value: function findOrCreateTerm(termName) { + var _this5 = this; + + var taxonomy = this.props.taxonomy; + var termNameEscaped = Object(external_lodash_["escape"])(termName); // Tries to create a term or fetch it if it already exists. + + return external_this_wp_apiFetch_default()({ + path: "/wp/v2/".concat(taxonomy.rest_base), + method: 'POST', + data: { + name: termNameEscaped + } + }).catch(function (error) { + var errorCode = error.code; + + if (errorCode === 'term_exists') { + // If the terms exist, fetch it instead of creating a new one. + _this5.addRequest = external_this_wp_apiFetch_default()({ + path: Object(external_this_wp_url_["addQueryArgs"])("/wp/v2/".concat(taxonomy.rest_base), Object(objectSpread["a" /* default */])({}, DEFAULT_QUERY, { + search: termNameEscaped + })) + }).then(flat_term_selector_unescapeTerms); + return _this5.addRequest.then(function (searchResult) { + return Object(external_lodash_["find"])(searchResult, function (result) { + return isSameTermName(result.name, termName); + }); + }); + } + + return Promise.reject(error); + }).then(flat_term_selector_unescapeTerm); + } + }, { + key: "onChange", + value: function onChange(termNames) { + var _this6 = this; + + var uniqueTerms = Object(external_lodash_["uniqBy"])(termNames, function (term) { + return term.toLowerCase(); + }); + this.setState({ + selectedTerms: uniqueTerms + }); + var newTermNames = uniqueTerms.filter(function (termName) { + return !Object(external_lodash_["find"])(_this6.state.availableTerms, function (term) { + return isSameTermName(term.name, termName); + }); + }); + + var termNamesToIds = function termNamesToIds(names, availableTerms) { + return names.map(function (termName) { + return Object(external_lodash_["find"])(availableTerms, function (term) { + return isSameTermName(term.name, termName); + }).id; + }); + }; + + if (newTermNames.length === 0) { + return this.props.onUpdateTerms(termNamesToIds(uniqueTerms, this.state.availableTerms), this.props.taxonomy.rest_base); + } + + Promise.all(newTermNames.map(this.findOrCreateTerm)).then(function (newTerms) { + var newAvailableTerms = _this6.state.availableTerms.concat(newTerms); + + _this6.setState({ + availableTerms: newAvailableTerms + }); + + return _this6.props.onUpdateTerms(termNamesToIds(uniqueTerms, newAvailableTerms), _this6.props.taxonomy.rest_base); + }); + } + }, { + key: "searchTerms", + value: function searchTerms() { + var search = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + Object(external_lodash_["invoke"])(this.searchRequest, ['abort']); + this.searchRequest = this.fetchTerms({ + search: search + }); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + slug = _this$props.slug, + taxonomy = _this$props.taxonomy, + hasAssignAction = _this$props.hasAssignAction; + + if (!hasAssignAction) { + return null; + } + + var _this$state = this.state, + loading = _this$state.loading, + availableTerms = _this$state.availableTerms, + selectedTerms = _this$state.selectedTerms; + var termNames = availableTerms.map(function (term) { + return term.name; + }); + var newTermLabel = Object(external_lodash_["get"])(taxonomy, ['labels', 'add_new_item'], slug === 'post_tag' ? Object(external_this_wp_i18n_["__"])('Add New Tag') : Object(external_this_wp_i18n_["__"])('Add New Term')); + var singularName = Object(external_lodash_["get"])(taxonomy, ['labels', 'singular_name'], slug === 'post_tag' ? Object(external_this_wp_i18n_["__"])('Tag') : Object(external_this_wp_i18n_["__"])('Term')); + var termAddedLabel = Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_x"])('%s added', 'term'), singularName); + var termRemovedLabel = Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_x"])('%s removed', 'term'), singularName); + var removeTermLabel = Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_x"])('Remove %s', 'term'), singularName); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["FormTokenField"], { + value: selectedTerms, + suggestions: termNames, + onChange: this.onChange, + onInputChange: this.searchTerms, + maxSuggestions: MAX_TERMS_SUGGESTIONS, + disabled: loading, + label: newTermLabel, + messages: { + added: termAddedLabel, + removed: termRemovedLabel, + remove: removeTermLabel + } + }); + } + }]); + + return FlatTermSelector; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var flat_term_selector = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select, _ref) { + var slug = _ref.slug; + + var _select = select('core/editor'), + getCurrentPost = _select.getCurrentPost; + + var _select2 = select('core'), + getTaxonomy = _select2.getTaxonomy; + + var taxonomy = getTaxonomy(slug); + return { + hasCreateAction: taxonomy ? Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-create-' + taxonomy.rest_base], false) : false, + hasAssignAction: taxonomy ? Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-assign-' + taxonomy.rest_base], false) : false, + terms: taxonomy ? select('core/editor').getEditedPostAttribute(taxonomy.rest_base) : [], + taxonomy: taxonomy + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdateTerms: function onUpdateTerms(terms, restBase) { + dispatch('core/editor').editPost(Object(defineProperty["a" /* default */])({}, restBase, terms)); + } + }; +}), Object(external_this_wp_components_["withFilters"])('editor.PostTaxonomyType'))(flat_term_selector_FlatTermSelector)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-publish-panel/maybe-tags-panel.js + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + +var maybe_tags_panel_TagsPanel = function TagsPanel() { + var panelBodyTitle = [Object(external_this_wp_i18n_["__"])('Suggestion:'), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-publish-panel__link", + key: "label" + }, Object(external_this_wp_i18n_["__"])('Add tags'))]; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + initialOpen: false, + title: panelBodyTitle + }, Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_i18n_["__"])('Tags help users and search engines navigate your site and find your content. Add a few keywords to describe your post.')), Object(external_this_wp_element_["createElement"])(flat_term_selector, { + slug: 'post_tag' + })); +}; + +var maybe_tags_panel_MaybeTagsPanel = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(MaybeTagsPanel, _Component); + + function MaybeTagsPanel(props) { + var _this; + + Object(classCallCheck["a" /* default */])(this, MaybeTagsPanel); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(MaybeTagsPanel).call(this, props)); + _this.state = { + hadTagsWhenOpeningThePanel: props.hasTags + }; + return _this; + } + /* + * We only want to show the tag panel if the post didn't have + * any tags when the user hit the Publish button. + * + * We can't use the prop.hasTags because it'll change to true + * if the user adds a new tag within the pre-publish panel. + * This would force a re-render and a new prop.hasTags check, + * hiding this panel and keeping the user from adding + * more than one tag. + */ + + + Object(createClass["a" /* default */])(MaybeTagsPanel, [{ + key: "render", + value: function render() { + if (!this.state.hadTagsWhenOpeningThePanel) { + return Object(external_this_wp_element_["createElement"])(maybe_tags_panel_TagsPanel, null); + } + + return null; + } + }]); + + return MaybeTagsPanel; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var maybe_tags_panel = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select) { + var postType = select('core/editor').getCurrentPostType(); + var tagsTaxonomy = select('core').getTaxonomy('post_tag'); + var tags = tagsTaxonomy && select('core/editor').getEditedPostAttribute(tagsTaxonomy.rest_base); + return { + areTagsFetched: tagsTaxonomy !== undefined, + isPostTypeSupported: tagsTaxonomy && Object(external_lodash_["some"])(tagsTaxonomy.types, function (type) { + return type === postType; + }), + hasTags: tags && tags.length + }; +}), Object(external_this_wp_compose_["ifCondition"])(function (_ref) { + var areTagsFetched = _ref.areTagsFetched, + isPostTypeSupported = _ref.isPostTypeSupported; + return isPostTypeSupported && areTagsFetched; +}))(maybe_tags_panel_MaybeTagsPanel)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-publish-panel/maybe-post-format-panel.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + + +var maybe_post_format_panel_PostFormatSuggestion = function PostFormatSuggestion(_ref) { + var suggestedPostFormat = _ref.suggestedPostFormat, + suggestionText = _ref.suggestionText, + onUpdatePostFormat = _ref.onUpdatePostFormat; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isLink: true, + onClick: function onClick() { + return onUpdatePostFormat(suggestedPostFormat); + } + }, suggestionText); +}; + +var maybe_post_format_panel_PostFormatPanel = function PostFormatPanel(_ref2) { + var suggestion = _ref2.suggestion, + onUpdatePostFormat = _ref2.onUpdatePostFormat; + var panelBodyTitle = [Object(external_this_wp_i18n_["__"])('Suggestion:'), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-publish-panel__link", + key: "label" + }, Object(external_this_wp_i18n_["__"])('Use a post format'))]; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + initialOpen: false, + title: panelBodyTitle + }, Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_i18n_["__"])('Your theme uses post formats to highlight different kinds of content, like images or videos. Apply a post format to see this special styling.')), Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_element_["createElement"])(maybe_post_format_panel_PostFormatSuggestion, { + onUpdatePostFormat: onUpdatePostFormat, + suggestedPostFormat: suggestion.id, + suggestionText: Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["__"])('Apply the "%1$s" format.'), suggestion.caption) + }))); +}; + +var maybe_post_format_panel_getSuggestion = function getSuggestion(supportedFormats, suggestedPostFormat) { + var formats = POST_FORMATS.filter(function (format) { + return Object(external_lodash_["includes"])(supportedFormats, format.id); + }); + return Object(external_lodash_["find"])(formats, function (format) { + return format.id === suggestedPostFormat; + }); +}; + +/* harmony default export */ var maybe_post_format_panel = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getEditedPostAttribute = _select.getEditedPostAttribute, + getSuggestedPostFormat = _select.getSuggestedPostFormat; + + var supportedFormats = Object(external_lodash_["get"])(select('core').getThemeSupports(), ['formats'], []); + return { + currentPostFormat: getEditedPostAttribute('format'), + suggestion: maybe_post_format_panel_getSuggestion(supportedFormats, getSuggestedPostFormat()) + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdatePostFormat: function onUpdatePostFormat(postFormat) { + dispatch('core/editor').editPost({ + format: postFormat + }); + } + }; +}), Object(external_this_wp_compose_["ifCondition"])(function (_ref3) { + var suggestion = _ref3.suggestion, + currentPostFormat = _ref3.currentPostFormat; + return suggestion && suggestion.id !== currentPostFormat; +}))(maybe_post_format_panel_PostFormatPanel)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-publish-panel/prepublish.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + + + + + + + +function PostPublishPanelPrepublish(_ref) { + var hasPublishAction = _ref.hasPublishAction, + isBeingScheduled = _ref.isBeingScheduled, + children = _ref.children; + var prePublishTitle, prePublishBodyText; + + if (!hasPublishAction) { + prePublishTitle = Object(external_this_wp_i18n_["__"])('Are you ready to submit for review?'); + prePublishBodyText = Object(external_this_wp_i18n_["__"])('When you’re ready, submit your work for review, and an Editor will be able to approve it for you.'); + } else if (isBeingScheduled) { + prePublishTitle = Object(external_this_wp_i18n_["__"])('Are you ready to schedule?'); + prePublishBodyText = Object(external_this_wp_i18n_["__"])('Your work will be published at the specified date and time.'); + } else { + prePublishTitle = Object(external_this_wp_i18n_["__"])('Are you ready to publish?'); + prePublishBodyText = Object(external_this_wp_i18n_["__"])('Double-check your settings before publishing.'); + } + + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-publish-panel__prepublish" + }, Object(external_this_wp_element_["createElement"])("div", null, Object(external_this_wp_element_["createElement"])("strong", null, prePublishTitle)), Object(external_this_wp_element_["createElement"])("p", null, prePublishBodyText), hasPublishAction && Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + initialOpen: false, + title: [Object(external_this_wp_i18n_["__"])('Visibility:'), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-publish-panel__link", + key: "label" + }, Object(external_this_wp_element_["createElement"])(post_visibility_label, null))] + }, Object(external_this_wp_element_["createElement"])(post_visibility, null)), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + initialOpen: false, + title: [Object(external_this_wp_i18n_["__"])('Publish:'), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-publish-panel__link", + key: "label" + }, Object(external_this_wp_element_["createElement"])(post_schedule_label, null))] + }, Object(external_this_wp_element_["createElement"])(post_schedule, null)), Object(external_this_wp_element_["createElement"])(maybe_post_format_panel, null), Object(external_this_wp_element_["createElement"])(maybe_tags_panel, null), children)); +} + +/* harmony default export */ var prepublish = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getCurrentPost = _select.getCurrentPost, + isEditedPostBeingScheduled = _select.isEditedPostBeingScheduled; + + return { + hasPublishAction: Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-publish'], false), + isBeingScheduled: isEditedPostBeingScheduled() + }; +})(PostPublishPanelPrepublish)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-publish-panel/postpublish.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + +var postpublish_PostPublishPanelPostpublish = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostPublishPanelPostpublish, _Component); + + function PostPublishPanelPostpublish() { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostPublishPanelPostpublish); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostPublishPanelPostpublish).apply(this, arguments)); + _this.state = { + showCopyConfirmation: false + }; + _this.onCopy = _this.onCopy.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onSelectInput = _this.onSelectInput.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.postLink = Object(external_this_wp_element_["createRef"])(); + return _this; + } + + Object(createClass["a" /* default */])(PostPublishPanelPostpublish, [{ + key: "componentDidMount", + value: function componentDidMount() { + if (this.props.focusOnMount) { + this.postLink.current.focus(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + clearTimeout(this.dismissCopyConfirmation); + } + }, { + key: "onCopy", + value: function onCopy() { + var _this2 = this; + + this.setState({ + showCopyConfirmation: true + }); + clearTimeout(this.dismissCopyConfirmation); + this.dismissCopyConfirmation = setTimeout(function () { + _this2.setState({ + showCopyConfirmation: false + }); + }, 4000); + } + }, { + key: "onSelectInput", + value: function onSelectInput(event) { + event.target.select(); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + children = _this$props.children, + isScheduled = _this$props.isScheduled, + post = _this$props.post, + postType = _this$props.postType; + var postLabel = Object(external_lodash_["get"])(postType, ['labels', 'singular_name']); + var viewPostLabel = Object(external_lodash_["get"])(postType, ['labels', 'view_item']); + var postPublishNonLinkHeader = isScheduled ? Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_i18n_["__"])('is now scheduled. It will go live on'), " ", Object(external_this_wp_element_["createElement"])(post_schedule_label, null), ".") : Object(external_this_wp_i18n_["__"])('is now live.'); + return Object(external_this_wp_element_["createElement"])("div", { + className: "post-publish-panel__postpublish" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + className: "post-publish-panel__postpublish-header" + }, Object(external_this_wp_element_["createElement"])("a", { + ref: this.postLink, + href: post.link + }, post.title || Object(external_this_wp_i18n_["__"])('(no title)')), " ", postPublishNonLinkHeader), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], null, Object(external_this_wp_element_["createElement"])("p", { + className: "post-publish-panel__postpublish-subheader" + }, Object(external_this_wp_element_["createElement"])("strong", null, Object(external_this_wp_i18n_["__"])('What’s next?'))), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["TextControl"], { + className: "post-publish-panel__postpublish-post-address", + readOnly: true, + label: Object(external_this_wp_i18n_["sprintf"])( + /* translators: %s: post type singular name */ + Object(external_this_wp_i18n_["__"])('%s address'), postLabel), + value: Object(external_this_wp_url_["safeDecodeURIComponent"])(post.link), + onFocus: this.onSelectInput + }), Object(external_this_wp_element_["createElement"])("div", { + className: "post-publish-panel__postpublish-buttons" + }, !isScheduled && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isDefault: true, + href: post.link + }, viewPostLabel), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ClipboardButton"], { + isDefault: true, + text: post.link, + onCopy: this.onCopy + }, this.state.showCopyConfirmation ? Object(external_this_wp_i18n_["__"])('Copied!') : Object(external_this_wp_i18n_["__"])('Copy Link')))), children); + } + }]); + + return PostPublishPanelPostpublish; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var postpublish = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getEditedPostAttribute = _select.getEditedPostAttribute, + getCurrentPost = _select.getCurrentPost, + isCurrentPostScheduled = _select.isCurrentPostScheduled; + + var _select2 = select('core'), + getPostType = _select2.getPostType; + + return { + post: getCurrentPost(), + postType: getPostType(getEditedPostAttribute('type')), + isScheduled: isCurrentPostScheduled() + }; +})(postpublish_PostPublishPanelPostpublish)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-publish-panel/index.js + + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + + +var post_publish_panel_PostPublishPanel = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostPublishPanel, _Component); + + function PostPublishPanel() { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostPublishPanel); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostPublishPanel).apply(this, arguments)); + _this.onSubmit = _this.onSubmit.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + return _this; + } + + Object(createClass["a" /* default */])(PostPublishPanel, [{ + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + // Automatically collapse the publish sidebar when a post + // is published and the user makes an edit. + if (prevProps.isPublished && !this.props.isSaving && this.props.isDirty) { + this.props.onClose(); + } + } + }, { + key: "onSubmit", + value: function onSubmit() { + var _this$props = this.props, + onClose = _this$props.onClose, + hasPublishAction = _this$props.hasPublishAction, + isPostTypeViewable = _this$props.isPostTypeViewable; + + if (!hasPublishAction || !isPostTypeViewable) { + onClose(); + } + } + }, { + key: "render", + value: function render() { + var _this$props2 = this.props, + forceIsDirty = _this$props2.forceIsDirty, + forceIsSaving = _this$props2.forceIsSaving, + isBeingScheduled = _this$props2.isBeingScheduled, + isPublished = _this$props2.isPublished, + isPublishSidebarEnabled = _this$props2.isPublishSidebarEnabled, + isScheduled = _this$props2.isScheduled, + isSaving = _this$props2.isSaving, + onClose = _this$props2.onClose, + onTogglePublishSidebar = _this$props2.onTogglePublishSidebar, + PostPublishExtension = _this$props2.PostPublishExtension, + PrePublishExtension = _this$props2.PrePublishExtension, + additionalProps = Object(objectWithoutProperties["a" /* default */])(_this$props2, ["forceIsDirty", "forceIsSaving", "isBeingScheduled", "isPublished", "isPublishSidebarEnabled", "isScheduled", "isSaving", "onClose", "onTogglePublishSidebar", "PostPublishExtension", "PrePublishExtension"]); + + var propsForPanel = Object(external_lodash_["omit"])(additionalProps, ['hasPublishAction', 'isDirty', 'isPostTypeViewable']); + var isPublishedOrScheduled = isPublished || isScheduled && isBeingScheduled; + var isPrePublish = !isPublishedOrScheduled && !isSaving; + var isPostPublish = isPublishedOrScheduled && !isSaving; + return Object(external_this_wp_element_["createElement"])("div", Object(esm_extends["a" /* default */])({ + className: "editor-post-publish-panel" + }, propsForPanel), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-publish-panel__header" + }, isPostPublish ? Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-publish-panel__header-published" + }, isScheduled ? Object(external_this_wp_i18n_["__"])('Scheduled') : Object(external_this_wp_i18n_["__"])('Published')) : Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-publish-panel__header-publish-button" + }, Object(external_this_wp_element_["createElement"])(post_publish_button, { + focusOnMount: true, + onSubmit: this.onSubmit, + forceIsDirty: forceIsDirty, + forceIsSaving: forceIsSaving + }), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-publish-panel__spacer" + })), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + "aria-expanded": true, + onClick: onClose, + icon: "no-alt", + label: Object(external_this_wp_i18n_["__"])('Close panel') + })), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-publish-panel__content" + }, isPrePublish && Object(external_this_wp_element_["createElement"])(prepublish, null, PrePublishExtension && Object(external_this_wp_element_["createElement"])(PrePublishExtension, null)), isPostPublish && Object(external_this_wp_element_["createElement"])(postpublish, { + focusOnMount: true + }, PostPublishExtension && Object(external_this_wp_element_["createElement"])(PostPublishExtension, null)), isSaving && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Spinner"], null)), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-publish-panel__footer" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["CheckboxControl"], { + label: Object(external_this_wp_i18n_["__"])('Always show pre-publish checks.'), + checked: isPublishSidebarEnabled, + onChange: onTogglePublishSidebar + }))); + } + }]); + + return PostPublishPanel; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var post_publish_panel = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core'), + getPostType = _select.getPostType; + + var _select2 = select('core/editor'), + getCurrentPost = _select2.getCurrentPost, + getEditedPostAttribute = _select2.getEditedPostAttribute, + isCurrentPostPublished = _select2.isCurrentPostPublished, + isCurrentPostScheduled = _select2.isCurrentPostScheduled, + isEditedPostBeingScheduled = _select2.isEditedPostBeingScheduled, + isEditedPostDirty = _select2.isEditedPostDirty, + isSavingPost = _select2.isSavingPost; + + var _select3 = select('core/editor'), + isPublishSidebarEnabled = _select3.isPublishSidebarEnabled; + + var postType = getPostType(getEditedPostAttribute('type')); + return { + hasPublishAction: Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-publish'], false), + isPostTypeViewable: Object(external_lodash_["get"])(postType, ['viewable'], false), + isBeingScheduled: isEditedPostBeingScheduled(), + isDirty: isEditedPostDirty(), + isPublished: isCurrentPostPublished(), + isPublishSidebarEnabled: isPublishSidebarEnabled(), + isSaving: isSavingPost(), + isScheduled: isCurrentPostScheduled() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref) { + var isPublishSidebarEnabled = _ref.isPublishSidebarEnabled; + + var _dispatch = dispatch('core/editor'), + disablePublishSidebar = _dispatch.disablePublishSidebar, + enablePublishSidebar = _dispatch.enablePublishSidebar; + + return { + onTogglePublishSidebar: function onTogglePublishSidebar() { + if (isPublishSidebarEnabled) { + disablePublishSidebar(); + } else { + enablePublishSidebar(); + } + } + }; +}), external_this_wp_components_["withFocusReturn"], external_this_wp_components_["withConstrainedTabbing"]])(post_publish_panel_PostPublishPanel)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-switch-to-draft-button/index.js + + +/** + * WordPress dependencies + */ + + + + + +function PostSwitchToDraftButton(_ref) { + var isSaving = _ref.isSaving, + isPublished = _ref.isPublished, + isScheduled = _ref.isScheduled, + onClick = _ref.onClick; + + if (!isPublished && !isScheduled) { + return null; + } + + var onSwitch = function onSwitch() { + var alertMessage; + + if (isPublished) { + alertMessage = Object(external_this_wp_i18n_["__"])('Are you sure you want to unpublish this post?'); + } else if (isScheduled) { + alertMessage = Object(external_this_wp_i18n_["__"])('Are you sure you want to unschedule this post?'); + } // eslint-disable-next-line no-alert + + + if (window.confirm(alertMessage)) { + onClick(); + } + }; + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: "editor-post-switch-to-draft", + onClick: onSwitch, + disabled: isSaving, + isTertiary: true + }, Object(external_this_wp_i18n_["__"])('Switch to Draft')); +} + +/* harmony default export */ var post_switch_to_draft_button = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isSavingPost = _select.isSavingPost, + isCurrentPostPublished = _select.isCurrentPostPublished, + isCurrentPostScheduled = _select.isCurrentPostScheduled; + + return { + isSaving: isSavingPost(), + isPublished: isCurrentPostPublished(), + isScheduled: isCurrentPostScheduled() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + editPost = _dispatch.editPost, + savePost = _dispatch.savePost; + + return { + onClick: function onClick() { + editPost({ + status: 'draft' + }); + savePost(); + } + }; +})])(PostSwitchToDraftButton)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-saved-state/index.js + + + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + + + + +/** + * Internal dependencies + */ + + +/** + * Component showing whether the post is saved or not and displaying save links. + * + * @param {Object} Props Component Props. + */ + +var post_saved_state_PostSavedState = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostSavedState, _Component); + + function PostSavedState() { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostSavedState); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostSavedState).apply(this, arguments)); + _this.state = { + forceSavedMessage: false + }; + return _this; + } + + Object(createClass["a" /* default */])(PostSavedState, [{ + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var _this2 = this; + + if (prevProps.isSaving && !this.props.isSaving) { + this.setState({ + forceSavedMessage: true + }); + this.props.setTimeout(function () { + _this2.setState({ + forceSavedMessage: false + }); + }, 1000); + } + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + post = _this$props.post, + isNew = _this$props.isNew, + isScheduled = _this$props.isScheduled, + isPublished = _this$props.isPublished, + isDirty = _this$props.isDirty, + isSaving = _this$props.isSaving, + isSaveable = _this$props.isSaveable, + onSave = _this$props.onSave, + isAutosaving = _this$props.isAutosaving, + isPending = _this$props.isPending, + isLargeViewport = _this$props.isLargeViewport; + var forceSavedMessage = this.state.forceSavedMessage; + + if (isSaving) { + // TODO: Classes generation should be common across all return + // paths of this function, including proper naming convention for + // the "Save Draft" button. + var classes = classnames_default()('editor-post-saved-state', 'is-saving', { + 'is-autosaving': isAutosaving + }); + return Object(external_this_wp_element_["createElement"])("span", { + className: classes + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Dashicon"], { + icon: "cloud" + }), isAutosaving ? Object(external_this_wp_i18n_["__"])('Autosaving') : Object(external_this_wp_i18n_["__"])('Saving')); + } + + if (isPublished || isScheduled) { + return Object(external_this_wp_element_["createElement"])(post_switch_to_draft_button, null); + } + + if (!isSaveable) { + return null; + } + + if (forceSavedMessage || !isNew && !isDirty) { + return Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-saved-state is-saved" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Dashicon"], { + icon: "saved" + }), Object(external_this_wp_i18n_["__"])('Saved')); + } // Once the post has been submitted for review this button + // is not needed for the contributor role. + + + var hasPublishAction = Object(external_lodash_["get"])(post, ['_links', 'wp:action-publish'], false); + + if (!hasPublishAction && isPending) { + return null; + } + + var label = isPending ? Object(external_this_wp_i18n_["__"])('Save as Pending') : Object(external_this_wp_i18n_["__"])('Save Draft'); + + if (!isLargeViewport) { + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + className: "editor-post-save-draft", + label: label, + onClick: onSave, + shortcut: external_this_wp_keycodes_["displayShortcut"].primary('s'), + icon: "cloud-upload" + }); + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: "editor-post-save-draft", + onClick: onSave, + shortcut: external_this_wp_keycodes_["displayShortcut"].primary('s'), + isTertiary: true + }, label); + } + }]); + + return PostSavedState; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var post_saved_state = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, _ref) { + var forceIsDirty = _ref.forceIsDirty, + forceIsSaving = _ref.forceIsSaving; + + var _select = select('core/editor'), + isEditedPostNew = _select.isEditedPostNew, + isCurrentPostPublished = _select.isCurrentPostPublished, + isCurrentPostScheduled = _select.isCurrentPostScheduled, + isEditedPostDirty = _select.isEditedPostDirty, + isSavingPost = _select.isSavingPost, + isEditedPostSaveable = _select.isEditedPostSaveable, + getCurrentPost = _select.getCurrentPost, + isAutosavingPost = _select.isAutosavingPost, + getEditedPostAttribute = _select.getEditedPostAttribute; + + return { + post: getCurrentPost(), + isNew: isEditedPostNew(), + isPublished: isCurrentPostPublished(), + isScheduled: isCurrentPostScheduled(), + isDirty: forceIsDirty || isEditedPostDirty(), + isSaving: forceIsSaving || isSavingPost(), + isSaveable: isEditedPostSaveable(), + isAutosaving: isAutosavingPost(), + isPending: 'pending' === getEditedPostAttribute('status') + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onSave: dispatch('core/editor').savePost + }; +}), external_this_wp_compose_["withSafeTimeout"], Object(external_this_wp_viewport_["withViewportMatch"])({ + isLargeViewport: 'medium' +})])(post_saved_state_PostSavedState)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-schedule/check.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +function PostScheduleCheck(_ref) { + var hasPublishAction = _ref.hasPublishAction, + children = _ref.children; + + if (!hasPublishAction) { + return null; + } + + return children; +} +/* harmony default export */ var post_schedule_check = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getCurrentPost = _select.getCurrentPost, + getCurrentPostType = _select.getCurrentPostType; + + return { + hasPublishAction: Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-publish'], false), + postType: getCurrentPostType() + }; +})])(PostScheduleCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-sticky/check.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +function PostStickyCheck(_ref) { + var hasStickyAction = _ref.hasStickyAction, + postType = _ref.postType, + children = _ref.children; + + if (postType !== 'post' || !hasStickyAction) { + return null; + } + + return children; +} +/* harmony default export */ var post_sticky_check = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var post = select('core/editor').getCurrentPost(); + return { + hasStickyAction: Object(external_lodash_["get"])(post, ['_links', 'wp:action-sticky'], false), + postType: select('core/editor').getCurrentPostType() + }; +})])(PostStickyCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-sticky/index.js + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +function PostSticky(_ref) { + var onUpdateSticky = _ref.onUpdateSticky, + _ref$postSticky = _ref.postSticky, + postSticky = _ref$postSticky === void 0 ? false : _ref$postSticky; + return Object(external_this_wp_element_["createElement"])(post_sticky_check, null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["CheckboxControl"], { + label: Object(external_this_wp_i18n_["__"])('Stick to the top of the blog'), + checked: postSticky, + onChange: function onChange() { + return onUpdateSticky(!postSticky); + } + })); +} +/* harmony default export */ var post_sticky = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + postSticky: select('core/editor').getEditedPostAttribute('sticky') + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdateSticky: function onUpdateSticky(postSticky) { + dispatch('core/editor').editPost({ + sticky: postSticky + }); + } + }; +})])(PostSticky)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-taxonomies/hierarchical-term-selector.js + + + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + + + +/** + * Internal dependencies + */ + + +/** + * Module Constants + */ + +var hierarchical_term_selector_DEFAULT_QUERY = { + per_page: -1, + orderby: 'name', + order: 'asc', + _fields: 'id,name,parent' +}; +var MIN_TERMS_COUNT_FOR_FILTER = 8; + +var hierarchical_term_selector_HierarchicalTermSelector = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(HierarchicalTermSelector, _Component); + + function HierarchicalTermSelector() { + var _this; + + Object(classCallCheck["a" /* default */])(this, HierarchicalTermSelector); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(HierarchicalTermSelector).apply(this, arguments)); + _this.findTerm = _this.findTerm.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onChange = _this.onChange.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onChangeFormName = _this.onChangeFormName.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onChangeFormParent = _this.onChangeFormParent.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onAddTerm = _this.onAddTerm.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onToggleForm = _this.onToggleForm.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.setFilterValue = _this.setFilterValue.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.sortBySelected = _this.sortBySelected.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.state = { + loading: true, + availableTermsTree: [], + availableTerms: [], + adding: false, + formName: '', + formParent: '', + showForm: false, + filterValue: '', + filteredTermsTree: [] + }; + return _this; + } + + Object(createClass["a" /* default */])(HierarchicalTermSelector, [{ + key: "onChange", + value: function onChange(event) { + var _this$props = this.props, + onUpdateTerms = _this$props.onUpdateTerms, + _this$props$terms = _this$props.terms, + terms = _this$props$terms === void 0 ? [] : _this$props$terms, + taxonomy = _this$props.taxonomy; + var termId = parseInt(event.target.value, 10); + var hasTerm = terms.indexOf(termId) !== -1; + var newTerms = hasTerm ? Object(external_lodash_["without"])(terms, termId) : [].concat(Object(toConsumableArray["a" /* default */])(terms), [termId]); + onUpdateTerms(newTerms, taxonomy.rest_base); + } + }, { + key: "onChangeFormName", + value: function onChangeFormName(event) { + var newValue = event.target.value.trim() === '' ? '' : event.target.value; + this.setState({ + formName: newValue + }); + } + }, { + key: "onChangeFormParent", + value: function onChangeFormParent(newParent) { + this.setState({ + formParent: newParent + }); + } + }, { + key: "onToggleForm", + value: function onToggleForm() { + this.setState(function (state) { + return { + showForm: !state.showForm + }; + }); + } + }, { + key: "findTerm", + value: function findTerm(terms, parent, name) { + return Object(external_lodash_["find"])(terms, function (term) { + return (!term.parent && !parent || parseInt(term.parent) === parseInt(parent)) && term.name.toLowerCase() === name.toLowerCase(); + }); + } + }, { + key: "onAddTerm", + value: function onAddTerm(event) { + var _this2 = this; + + event.preventDefault(); + var _this$props2 = this.props, + onUpdateTerms = _this$props2.onUpdateTerms, + taxonomy = _this$props2.taxonomy, + terms = _this$props2.terms, + slug = _this$props2.slug; + var _this$state = this.state, + formName = _this$state.formName, + formParent = _this$state.formParent, + adding = _this$state.adding, + availableTerms = _this$state.availableTerms; + + if (formName === '' || adding) { + return; + } // check if the term we are adding already exists + + + var existingTerm = this.findTerm(availableTerms, formParent, formName); + + if (existingTerm) { + // if the term we are adding exists but is not selected select it + if (!Object(external_lodash_["some"])(terms, function (term) { + return term === existingTerm.id; + })) { + onUpdateTerms([].concat(Object(toConsumableArray["a" /* default */])(terms), [existingTerm.id]), taxonomy.rest_base); + } + + this.setState({ + formName: '', + formParent: '' + }); + return; + } + + this.setState({ + adding: true + }); + this.addRequest = external_this_wp_apiFetch_default()({ + path: "/wp/v2/".concat(taxonomy.rest_base), + method: 'POST', + data: { + name: formName, + parent: formParent ? formParent : undefined + } + }); // Tries to create a term or fetch it if it already exists + + var findOrCreatePromise = this.addRequest.catch(function (error) { + var errorCode = error.code; + + if (errorCode === 'term_exists') { + // search the new category created since last fetch + _this2.addRequest = external_this_wp_apiFetch_default()({ + path: Object(external_this_wp_url_["addQueryArgs"])("/wp/v2/".concat(taxonomy.rest_base), Object(objectSpread["a" /* default */])({}, hierarchical_term_selector_DEFAULT_QUERY, { + parent: formParent || 0, + search: formName + })) + }); + return _this2.addRequest.then(function (searchResult) { + return _this2.findTerm(searchResult, formParent, formName); + }); + } + + return Promise.reject(error); + }); + findOrCreatePromise.then(function (term) { + var hasTerm = !!Object(external_lodash_["find"])(_this2.state.availableTerms, function (availableTerm) { + return availableTerm.id === term.id; + }); + var newAvailableTerms = hasTerm ? _this2.state.availableTerms : [term].concat(Object(toConsumableArray["a" /* default */])(_this2.state.availableTerms)); + var termAddedMessage = Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_x"])('%s added', 'term'), Object(external_lodash_["get"])(_this2.props.taxonomy, ['labels', 'singular_name'], slug === 'category' ? Object(external_this_wp_i18n_["__"])('Category') : Object(external_this_wp_i18n_["__"])('Term'))); + + _this2.props.speak(termAddedMessage, 'assertive'); + + _this2.addRequest = null; + + _this2.setState({ + adding: false, + formName: '', + formParent: '', + availableTerms: newAvailableTerms, + availableTermsTree: _this2.sortBySelected(buildTermsTree(newAvailableTerms)) + }); + + onUpdateTerms([].concat(Object(toConsumableArray["a" /* default */])(terms), [term.id]), taxonomy.rest_base); + }, function (xhr) { + if (xhr.statusText === 'abort') { + return; + } + + _this2.addRequest = null; + + _this2.setState({ + adding: false + }); + }); + } + }, { + key: "componentDidMount", + value: function componentDidMount() { + this.fetchTerms(); + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + Object(external_lodash_["invoke"])(this.fetchRequest, ['abort']); + Object(external_lodash_["invoke"])(this.addRequest, ['abort']); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + if (this.props.taxonomy !== prevProps.taxonomy) { + this.fetchTerms(); + } + } + }, { + key: "fetchTerms", + value: function fetchTerms() { + var _this3 = this; + + var taxonomy = this.props.taxonomy; + + if (!taxonomy) { + return; + } + + this.fetchRequest = external_this_wp_apiFetch_default()({ + path: Object(external_this_wp_url_["addQueryArgs"])("/wp/v2/".concat(taxonomy.rest_base), hierarchical_term_selector_DEFAULT_QUERY) + }); + this.fetchRequest.then(function (terms) { + // resolve + var availableTermsTree = _this3.sortBySelected(buildTermsTree(terms)); + + _this3.fetchRequest = null; + + _this3.setState({ + loading: false, + availableTermsTree: availableTermsTree, + availableTerms: terms + }); + }, function (xhr) { + // reject + if (xhr.statusText === 'abort') { + return; + } + + _this3.fetchRequest = null; + + _this3.setState({ + loading: false + }); + }); + } + }, { + key: "sortBySelected", + value: function sortBySelected(termsTree) { + var terms = this.props.terms; + + var treeHasSelection = function treeHasSelection(termTree) { + if (terms.indexOf(termTree.id) !== -1) { + return true; + } + + if (undefined === termTree.children) { + return false; + } + + var anyChildIsSelected = termTree.children.map(treeHasSelection).filter(function (child) { + return child; + }).length > 0; + + if (anyChildIsSelected) { + return true; + } + + return false; + }; + + var termOrChildIsSelected = function termOrChildIsSelected(termA, termB) { + var termASelected = treeHasSelection(termA); + var termBSelected = treeHasSelection(termB); + + if (termASelected === termBSelected) { + return 0; + } + + if (termASelected && !termBSelected) { + return -1; + } + + if (!termASelected && termBSelected) { + return 1; + } + + return 0; + }; + + termsTree.sort(termOrChildIsSelected); + return termsTree; + } + }, { + key: "setFilterValue", + value: function setFilterValue(event) { + var availableTermsTree = this.state.availableTermsTree; + var filterValue = event.target.value; + var filteredTermsTree = availableTermsTree.map(this.getFilterMatcher(filterValue)).filter(function (term) { + return term; + }); + + var getResultCount = function getResultCount(terms) { + var count = 0; + + for (var i = 0; i < terms.length; i++) { + count++; + + if (undefined !== terms[i].children) { + count += getResultCount(terms[i].children); + } + } + + return count; + }; + + this.setState({ + filterValue: filterValue, + filteredTermsTree: filteredTermsTree + }); + var resultCount = getResultCount(filteredTermsTree); + var resultsFoundMessage = Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('%d result found.', '%d results found.', resultCount), resultCount); + this.props.debouncedSpeak(resultsFoundMessage, 'assertive'); + } + }, { + key: "getFilterMatcher", + value: function getFilterMatcher(filterValue) { + var matchTermsForFilter = function matchTermsForFilter(originalTerm) { + if ('' === filterValue) { + return originalTerm; + } // Shallow clone, because we'll be filtering the term's children and + // don't want to modify the original term. + + + var term = Object(objectSpread["a" /* default */])({}, originalTerm); // Map and filter the children, recursive so we deal with grandchildren + // and any deeper levels. + + + if (term.children.length > 0) { + term.children = term.children.map(matchTermsForFilter).filter(function (child) { + return child; + }); + } // If the term's name contains the filterValue, or it has children + // (i.e. some child matched at some point in the tree) then return it. + + + if (-1 !== term.name.toLowerCase().indexOf(filterValue) || term.children.length > 0) { + return term; + } // Otherwise, return false. After mapping, the list of terms will need + // to have false values filtered out. + + + return false; + }; + + return matchTermsForFilter; + } + }, { + key: "renderTerms", + value: function renderTerms(renderedTerms) { + var _this4 = this; + + var _this$props$terms2 = this.props.terms, + terms = _this$props$terms2 === void 0 ? [] : _this$props$terms2; + return renderedTerms.map(function (term) { + var id = "editor-post-taxonomies-hierarchical-term-".concat(term.id); + return Object(external_this_wp_element_["createElement"])("div", { + key: term.id, + className: "editor-post-taxonomies__hierarchical-terms-choice" + }, Object(external_this_wp_element_["createElement"])("input", { + id: id, + className: "editor-post-taxonomies__hierarchical-terms-input", + type: "checkbox", + checked: terms.indexOf(term.id) !== -1, + value: term.id, + onChange: _this4.onChange + }), Object(external_this_wp_element_["createElement"])("label", { + htmlFor: id + }, Object(external_lodash_["unescape"])(term.name)), !!term.children.length && Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-taxonomies__hierarchical-terms-subchoices" + }, _this4.renderTerms(term.children))); + }); + } + }, { + key: "render", + value: function render() { + var _this$props3 = this.props, + slug = _this$props3.slug, + taxonomy = _this$props3.taxonomy, + instanceId = _this$props3.instanceId, + hasCreateAction = _this$props3.hasCreateAction, + hasAssignAction = _this$props3.hasAssignAction; + + if (!hasAssignAction) { + return null; + } + + var _this$state2 = this.state, + availableTermsTree = _this$state2.availableTermsTree, + availableTerms = _this$state2.availableTerms, + filteredTermsTree = _this$state2.filteredTermsTree, + formName = _this$state2.formName, + formParent = _this$state2.formParent, + loading = _this$state2.loading, + showForm = _this$state2.showForm, + filterValue = _this$state2.filterValue; + + var labelWithFallback = function labelWithFallback(labelProperty, fallbackIsCategory, fallbackIsNotCategory) { + return Object(external_lodash_["get"])(taxonomy, ['labels', labelProperty], slug === 'category' ? fallbackIsCategory : fallbackIsNotCategory); + }; + + var newTermButtonLabel = labelWithFallback('add_new_item', Object(external_this_wp_i18n_["__"])('Add new category'), Object(external_this_wp_i18n_["__"])('Add new term')); + var newTermLabel = labelWithFallback('new_item_name', Object(external_this_wp_i18n_["__"])('Add new category'), Object(external_this_wp_i18n_["__"])('Add new term')); + var parentSelectLabel = labelWithFallback('parent_item', Object(external_this_wp_i18n_["__"])('Parent Category'), Object(external_this_wp_i18n_["__"])('Parent Term')); + var noParentOption = "\u2014 ".concat(parentSelectLabel, " \u2014"); + var newTermSubmitLabel = newTermButtonLabel; + var inputId = "editor-post-taxonomies__hierarchical-terms-input-".concat(instanceId); + var filterInputId = "editor-post-taxonomies__hierarchical-terms-filter-".concat(instanceId); + var filterLabel = Object(external_lodash_["get"])(this.props.taxonomy, ['labels', 'search_items'], Object(external_this_wp_i18n_["__"])('Search Terms')); + var groupLabel = Object(external_lodash_["get"])(this.props.taxonomy, ['name'], Object(external_this_wp_i18n_["__"])('Terms')); + var showFilter = availableTerms.length >= MIN_TERMS_COUNT_FOR_FILTER; + return [showFilter && Object(external_this_wp_element_["createElement"])("label", { + key: "filter-label", + htmlFor: filterInputId + }, filterLabel), showFilter && Object(external_this_wp_element_["createElement"])("input", { + type: "search", + id: filterInputId, + value: filterValue, + onChange: this.setFilterValue, + className: "editor-post-taxonomies__hierarchical-terms-filter", + key: "term-filter-input" + }), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-taxonomies__hierarchical-terms-list", + key: "term-list", + tabIndex: "0", + role: "group", + "aria-label": groupLabel + }, this.renderTerms('' !== filterValue ? filteredTermsTree : availableTermsTree)), !loading && hasCreateAction && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + key: "term-add-button", + onClick: this.onToggleForm, + className: "editor-post-taxonomies__hierarchical-terms-add", + "aria-expanded": showForm, + isLink: true + }, newTermButtonLabel), showForm && Object(external_this_wp_element_["createElement"])("form", { + onSubmit: this.onAddTerm, + key: "hierarchical-terms-form" + }, Object(external_this_wp_element_["createElement"])("label", { + htmlFor: inputId, + className: "editor-post-taxonomies__hierarchical-terms-label" + }, newTermLabel), Object(external_this_wp_element_["createElement"])("input", { + type: "text", + id: inputId, + className: "editor-post-taxonomies__hierarchical-terms-input", + value: formName, + onChange: this.onChangeFormName, + required: true + }), !!availableTerms.length && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["TreeSelect"], { + label: parentSelectLabel, + noOptionLabel: noParentOption, + onChange: this.onChangeFormParent, + selectedId: formParent, + tree: availableTermsTree + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isDefault: true, + type: "submit", + className: "editor-post-taxonomies__hierarchical-terms-submit" + }, newTermSubmitLabel))]; + /* eslint-enable jsx-a11y/no-onchange */ + } + }]); + + return HierarchicalTermSelector; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var hierarchical_term_selector = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, _ref) { + var slug = _ref.slug; + + var _select = select('core/editor'), + getCurrentPost = _select.getCurrentPost; + + var _select2 = select('core'), + getTaxonomy = _select2.getTaxonomy; + + var taxonomy = getTaxonomy(slug); + return { + hasCreateAction: taxonomy ? Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-create-' + taxonomy.rest_base], false) : false, + hasAssignAction: taxonomy ? Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-assign-' + taxonomy.rest_base], false) : false, + terms: taxonomy ? select('core/editor').getEditedPostAttribute(taxonomy.rest_base) : [], + taxonomy: taxonomy + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onUpdateTerms: function onUpdateTerms(terms, restBase) { + dispatch('core/editor').editPost(Object(defineProperty["a" /* default */])({}, restBase, terms)); + } + }; +}), external_this_wp_components_["withSpokenMessages"], external_this_wp_compose_["withInstanceId"], Object(external_this_wp_components_["withFilters"])('editor.PostTaxonomyType')])(hierarchical_term_selector_HierarchicalTermSelector)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-taxonomies/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + + +function PostTaxonomies(_ref) { + var postType = _ref.postType, + taxonomies = _ref.taxonomies, + _ref$taxonomyWrapper = _ref.taxonomyWrapper, + taxonomyWrapper = _ref$taxonomyWrapper === void 0 ? external_lodash_["identity"] : _ref$taxonomyWrapper; + var availableTaxonomies = Object(external_lodash_["filter"])(taxonomies, function (taxonomy) { + return Object(external_lodash_["includes"])(taxonomy.types, postType); + }); + var visibleTaxonomies = Object(external_lodash_["filter"])(availableTaxonomies, function (taxonomy) { + return taxonomy.visibility.show_ui; + }); + return visibleTaxonomies.map(function (taxonomy) { + var TaxonomyComponent = taxonomy.hierarchical ? hierarchical_term_selector : flat_term_selector; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], { + key: "taxonomy-".concat(taxonomy.slug) + }, taxonomyWrapper(Object(external_this_wp_element_["createElement"])(TaxonomyComponent, { + slug: taxonomy.slug + }), taxonomy)); + }); +} +/* harmony default export */ var post_taxonomies = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + postType: select('core/editor').getCurrentPostType(), + taxonomies: select('core').getTaxonomies({ + per_page: -1 + }) + }; +})])(PostTaxonomies)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-taxonomies/check.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +function PostTaxonomiesCheck(_ref) { + var postType = _ref.postType, + taxonomies = _ref.taxonomies, + children = _ref.children; + var hasTaxonomies = Object(external_lodash_["some"])(taxonomies, function (taxonomy) { + return Object(external_lodash_["includes"])(taxonomy.types, postType); + }); + + if (!hasTaxonomies) { + return null; + } + + return children; +} +/* harmony default export */ var post_taxonomies_check = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + return { + postType: select('core/editor').getCurrentPostType(), + taxonomies: select('core').getTaxonomies({ + per_page: -1 + }) + }; +})])(PostTaxonomiesCheck)); + +// EXTERNAL MODULE: ./node_modules/react-autosize-textarea/lib/index.js +var react_autosize_textarea_lib = __webpack_require__(61); +var react_autosize_textarea_lib_default = /*#__PURE__*/__webpack_require__.n(react_autosize_textarea_lib); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-text-editor/index.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +var post_text_editor_PostTextEditor = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostTextEditor, _Component); + + function PostTextEditor() { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostTextEditor); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostTextEditor).apply(this, arguments)); + _this.edit = _this.edit.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.stopEditing = _this.stopEditing.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.state = {}; + return _this; + } + + Object(createClass["a" /* default */])(PostTextEditor, [{ + key: "edit", + + /** + * Handles a textarea change event to notify the onChange prop callback and + * reflect the new value in the component's own state. This marks the start + * of the user's edits, if not already changed, preventing future props + * changes to value from replacing the rendered value. This is expected to + * be followed by a reset to dirty state via `stopEditing`. + * + * @see stopEditing + * + * @param {Event} event Change event. + */ + value: function edit(event) { + var value = event.target.value; + this.props.onChange(value); + this.setState({ + value: value, + isDirty: true + }); + } + /** + * Function called when the user has completed their edits, responsible for + * ensuring that changes, if made, are surfaced to the onPersist prop + * callback and resetting dirty state. + */ + + }, { + key: "stopEditing", + value: function stopEditing() { + if (this.state.isDirty) { + this.props.onPersist(this.state.value); + this.setState({ + isDirty: false + }); + } + } + }, { + key: "render", + value: function render() { + var value = this.state.value; + var instanceId = this.props.instanceId; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])("label", { + htmlFor: "post-content-".concat(instanceId), + className: "screen-reader-text" + }, Object(external_this_wp_i18n_["__"])('Type text or HTML')), Object(external_this_wp_element_["createElement"])(react_autosize_textarea_lib_default.a, { + autoComplete: "off", + dir: "auto", + value: value, + onChange: this.edit, + onBlur: this.stopEditing, + className: "editor-post-text-editor", + id: "post-content-".concat(instanceId), + placeholder: Object(external_this_wp_i18n_["__"])('Start writing with text or HTML') + })); + } + }], [{ + key: "getDerivedStateFromProps", + value: function getDerivedStateFromProps(props, state) { + if (state.isDirty) { + return null; + } + + return { + value: props.value, + isDirty: false + }; + } + }]); + + return PostTextEditor; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var post_text_editor = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getEditedPostContent = _select.getEditedPostContent; + + return { + value: getEditedPostContent() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + editPost = _dispatch.editPost, + resetEditorBlocks = _dispatch.resetEditorBlocks; + + return { + onChange: function onChange(content) { + editPost({ + content: content + }); + }, + onPersist: function onPersist(content) { + var blocks = Object(external_this_wp_blocks_["parse"])(content); + resetEditorBlocks(blocks); + } + }; +}), external_this_wp_compose_["withInstanceId"]])(post_text_editor_PostTextEditor)); + +// EXTERNAL MODULE: external {"this":["wp","htmlEntities"]} +var external_this_wp_htmlEntities_ = __webpack_require__(57); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-permalink/editor.js + + + + + + + + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + + +var editor_PostPermalinkEditor = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostPermalinkEditor, _Component); + + function PostPermalinkEditor(_ref) { + var _this; + + var permalinkParts = _ref.permalinkParts, + slug = _ref.slug; + + Object(classCallCheck["a" /* default */])(this, PostPermalinkEditor); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostPermalinkEditor).apply(this, arguments)); + _this.state = { + editedPostName: slug || permalinkParts.postName + }; + _this.onSavePermalink = _this.onSavePermalink.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + return _this; + } + + Object(createClass["a" /* default */])(PostPermalinkEditor, [{ + key: "onSavePermalink", + value: function onSavePermalink(event) { + var postName = cleanForSlug(this.state.editedPostName); + event.preventDefault(); + this.props.onSave(); + + if (postName === this.props.postName) { + return; + } + + this.props.editPost({ + slug: postName + }); + this.setState({ + editedPostName: postName + }); + } + }, { + key: "render", + value: function render() { + var _this2 = this; + + var _this$props$permalink = this.props.permalinkParts, + prefix = _this$props$permalink.prefix, + suffix = _this$props$permalink.suffix; + var editedPostName = this.state.editedPostName; + /* eslint-disable jsx-a11y/no-autofocus */ + // Autofocus is allowed here, as this mini-UI is only loaded when the user clicks to open it. + + return Object(external_this_wp_element_["createElement"])("form", { + className: "editor-post-permalink-editor", + onSubmit: this.onSavePermalink + }, Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-permalink__editor-container" + }, Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-permalink-editor__prefix" + }, prefix), Object(external_this_wp_element_["createElement"])("input", { + className: "editor-post-permalink-editor__edit", + "aria-label": Object(external_this_wp_i18n_["__"])('Edit post permalink'), + value: editedPostName, + onChange: function onChange(event) { + return _this2.setState({ + editedPostName: event.target.value + }); + }, + type: "text", + autoFocus: true + }), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-permalink-editor__suffix" + }, suffix), "\u200E"), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: "editor-post-permalink-editor__save", + isLarge: true, + onClick: this.onSavePermalink + }, Object(external_this_wp_i18n_["__"])('Save'))); + /* eslint-enable jsx-a11y/no-autofocus */ + } + }]); + + return PostPermalinkEditor; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var post_permalink_editor = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getPermalinkParts = _select.getPermalinkParts; + + return { + permalinkParts: getPermalinkParts() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + editPost = _dispatch.editPost; + + return { + editPost: editPost + }; +})])(editor_PostPermalinkEditor)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-permalink/index.js + + + + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + + + +/** + * Internal dependencies + */ + + + + +var post_permalink_PostPermalink = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostPermalink, _Component); + + function PostPermalink() { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostPermalink); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostPermalink).apply(this, arguments)); + _this.addVisibilityCheck = _this.addVisibilityCheck.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onVisibilityChange = _this.onVisibilityChange.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.state = { + isCopied: false, + isEditingPermalink: false + }; + return _this; + } + + Object(createClass["a" /* default */])(PostPermalink, [{ + key: "addVisibilityCheck", + value: function addVisibilityCheck() { + window.addEventListener('visibilitychange', this.onVisibilityChange); + } + }, { + key: "onVisibilityChange", + value: function onVisibilityChange() { + var _this$props = this.props, + isEditable = _this$props.isEditable, + refreshPost = _this$props.refreshPost; // If the user just returned after having clicked the "Change Permalinks" button, + // fetch a new copy of the post from the server, just in case they enabled permalinks. + + if (!isEditable && 'visible' === document.visibilityState) { + refreshPost(); + } + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps, prevState) { + // If we've just stopped editing the permalink, focus on the new permalink. + if (prevState.isEditingPermalink && !this.state.isEditingPermalink) { + this.linkElement.focus(); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + window.removeEventListener('visibilitychange', this.addVisibilityCheck); + } + }, { + key: "render", + value: function render() { + var _this2 = this; + + var _this$props2 = this.props, + isEditable = _this$props2.isEditable, + isNew = _this$props2.isNew, + isPublished = _this$props2.isPublished, + isViewable = _this$props2.isViewable, + permalinkParts = _this$props2.permalinkParts, + postLink = _this$props2.postLink, + postSlug = _this$props2.postSlug, + postID = _this$props2.postID, + postTitle = _this$props2.postTitle; + + if (isNew || !isViewable || !permalinkParts || !postLink) { + return null; + } + + var _this$state = this.state, + isCopied = _this$state.isCopied, + isEditingPermalink = _this$state.isEditingPermalink; + var ariaLabel = isCopied ? Object(external_this_wp_i18n_["__"])('Permalink copied') : Object(external_this_wp_i18n_["__"])('Copy the permalink'); + var prefix = permalinkParts.prefix, + suffix = permalinkParts.suffix; + var slug = Object(external_this_wp_url_["safeDecodeURIComponent"])(postSlug) || cleanForSlug(postTitle) || postID; + var samplePermalink = isEditable ? prefix + slug + suffix : prefix; + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-permalink" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ClipboardButton"], { + className: classnames_default()('editor-post-permalink__copy', { + 'is-copied': isCopied + }), + text: samplePermalink, + label: ariaLabel, + onCopy: function onCopy() { + return _this2.setState({ + isCopied: true + }); + }, + "aria-disabled": isCopied, + icon: "admin-links" + }), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-post-permalink__label" + }, Object(external_this_wp_i18n_["__"])('Permalink:')), !isEditingPermalink && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ExternalLink"], { + className: "editor-post-permalink__link", + href: !isPublished ? postLink : samplePermalink, + target: "_blank", + ref: function ref(linkElement) { + return _this2.linkElement = linkElement; + } + }, Object(external_this_wp_url_["safeDecodeURI"])(samplePermalink), "\u200E"), isEditingPermalink && Object(external_this_wp_element_["createElement"])(post_permalink_editor, { + slug: slug, + onSave: function onSave() { + return _this2.setState({ + isEditingPermalink: false + }); + } + }), isEditable && !isEditingPermalink && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: "editor-post-permalink__edit", + isLarge: true, + onClick: function onClick() { + return _this2.setState({ + isEditingPermalink: true + }); + } + }, Object(external_this_wp_i18n_["__"])('Edit')), !isEditable && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: "editor-post-permalink__change", + isLarge: true, + href: getWPAdminURL('options-permalink.php'), + onClick: this.addVisibilityCheck, + target: "_blank" + }, Object(external_this_wp_i18n_["__"])('Change Permalinks'))); + } + }]); + + return PostPermalink; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var post_permalink = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isEditedPostNew = _select.isEditedPostNew, + isPermalinkEditable = _select.isPermalinkEditable, + getCurrentPost = _select.getCurrentPost, + getPermalinkParts = _select.getPermalinkParts, + getEditedPostAttribute = _select.getEditedPostAttribute, + isCurrentPostPublished = _select.isCurrentPostPublished; + + var _select2 = select('core'), + getPostType = _select2.getPostType; + + var _getCurrentPost = getCurrentPost(), + id = _getCurrentPost.id, + link = _getCurrentPost.link; + + var postTypeName = getEditedPostAttribute('type'); + var postType = getPostType(postTypeName); + return { + isNew: isEditedPostNew(), + postLink: link, + permalinkParts: getPermalinkParts(), + postSlug: getEditedPostAttribute('slug'), + isEditable: isPermalinkEditable(), + isPublished: isCurrentPostPublished(), + postTitle: getEditedPostAttribute('title'), + postID: id, + isViewable: Object(external_lodash_["get"])(postType, ['viewable'], false) + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + refreshPost = _dispatch.refreshPost; + + return { + refreshPost: refreshPost + }; +})])(post_permalink_PostPermalink)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-title/index.js + + + + + + + + +/** + * External dependencies + */ + + + +/** + * WordPress dependencies + */ + + + + + + + + +/** + * Internal dependencies + */ + + + +/** + * Constants + */ + +var REGEXP_NEWLINES = /[\r\n]+/g; + +var post_title_PostTitle = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(PostTitle, _Component); + + function PostTitle() { + var _this; + + Object(classCallCheck["a" /* default */])(this, PostTitle); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(PostTitle).apply(this, arguments)); + _this.onChange = _this.onChange.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onSelect = _this.onSelect.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onUnselect = _this.onUnselect.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.onKeyDown = _this.onKeyDown.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.redirectHistory = _this.redirectHistory.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + _this.state = { + isSelected: false + }; + return _this; + } + + Object(createClass["a" /* default */])(PostTitle, [{ + key: "handleFocusOutside", + value: function handleFocusOutside() { + this.onUnselect(); + } + }, { + key: "onSelect", + value: function onSelect() { + this.setState({ + isSelected: true + }); + this.props.clearSelectedBlock(); + } + }, { + key: "onUnselect", + value: function onUnselect() { + this.setState({ + isSelected: false + }); + } + }, { + key: "onChange", + value: function onChange(event) { + var newTitle = event.target.value.replace(REGEXP_NEWLINES, ' '); + this.props.onUpdate(newTitle); + } + }, { + key: "onKeyDown", + value: function onKeyDown(event) { + if (event.keyCode === external_this_wp_keycodes_["ENTER"]) { + event.preventDefault(); + this.props.onEnterPress(); + } + } + /** + * Emulates behavior of an undo or redo on its corresponding key press + * combination. This is a workaround to React's treatment of undo in a + * controlled textarea where characters are updated one at a time. + * Instead, leverage the store's undo handling of title changes. + * + * @see https://github.com/facebook/react/issues/8514 + * + * @param {KeyboardEvent} event Key event. + */ + + }, { + key: "redirectHistory", + value: function redirectHistory(event) { + if (event.shiftKey) { + this.props.onRedo(); + } else { + this.props.onUndo(); + } + + event.preventDefault(); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + hasFixedToolbar = _this$props.hasFixedToolbar, + isCleanNewPost = _this$props.isCleanNewPost, + isFocusMode = _this$props.isFocusMode, + isPostTypeViewable = _this$props.isPostTypeViewable, + instanceId = _this$props.instanceId, + placeholder = _this$props.placeholder, + title = _this$props.title; + var isSelected = this.state.isSelected; // The wp-block className is important for editor styles. + + var className = classnames_default()('wp-block editor-post-title__block', { + 'is-selected': isSelected, + 'is-focus-mode': isFocusMode, + 'has-fixed-toolbar': hasFixedToolbar + }); + var decodedPlaceholder = Object(external_this_wp_htmlEntities_["decodeEntities"])(placeholder); + return Object(external_this_wp_element_["createElement"])(post_type_support_check, { + supportKeys: "title" + }, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-post-title" + }, Object(external_this_wp_element_["createElement"])("div", { + className: className + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["KeyboardShortcuts"], { + shortcuts: { + 'mod+z': this.redirectHistory, + 'mod+shift+z': this.redirectHistory + } + }, Object(external_this_wp_element_["createElement"])("label", { + htmlFor: "post-title-".concat(instanceId), + className: "screen-reader-text" + }, decodedPlaceholder || Object(external_this_wp_i18n_["__"])('Add title')), Object(external_this_wp_element_["createElement"])(react_autosize_textarea_lib_default.a, { + id: "post-title-".concat(instanceId), + className: "editor-post-title__input", + value: title, + onChange: this.onChange, + placeholder: decodedPlaceholder || Object(external_this_wp_i18n_["__"])('Add title'), + onFocus: this.onSelect, + onKeyDown: this.onKeyDown, + onKeyPress: this.onUnselect + /* + Only autofocus the title when the post is entirely empty. + This should only happen for a new post, which means we + focus the title on new post so the author can start typing + right away, without needing to click anything. + */ + + /* eslint-disable jsx-a11y/no-autofocus */ + , + autoFocus: isCleanNewPost + /* eslint-enable jsx-a11y/no-autofocus */ + + })), isSelected && isPostTypeViewable && Object(external_this_wp_element_["createElement"])(post_permalink, null)))); + } + }]); + + return PostTitle; +}(external_this_wp_element_["Component"]); + +var post_title_applyWithSelect = Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getEditedPostAttribute = _select.getEditedPostAttribute, + isCleanNewPost = _select.isCleanNewPost; + + var _select2 = select('core/block-editor'), + getSettings = _select2.getSettings; + + var _select3 = select('core'), + getPostType = _select3.getPostType; + + var postType = getPostType(getEditedPostAttribute('type')); + + var _getSettings = getSettings(), + titlePlaceholder = _getSettings.titlePlaceholder, + focusMode = _getSettings.focusMode, + hasFixedToolbar = _getSettings.hasFixedToolbar; + + return { + isCleanNewPost: isCleanNewPost(), + title: getEditedPostAttribute('title'), + isPostTypeViewable: Object(external_lodash_["get"])(postType, ['viewable'], false), + placeholder: titlePlaceholder, + isFocusMode: focusMode, + hasFixedToolbar: hasFixedToolbar + }; +}); +var post_title_applyWithDispatch = Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/block-editor'), + insertDefaultBlock = _dispatch.insertDefaultBlock, + clearSelectedBlock = _dispatch.clearSelectedBlock; + + var _dispatch2 = dispatch('core/editor'), + editPost = _dispatch2.editPost, + undo = _dispatch2.undo, + redo = _dispatch2.redo; + + return { + onEnterPress: function onEnterPress() { + insertDefaultBlock(undefined, undefined, 0); + }, + onUpdate: function onUpdate(title) { + editPost({ + title: title + }); + }, + onUndo: undo, + onRedo: redo, + clearSelectedBlock: clearSelectedBlock + }; +}); +/* harmony default export */ var post_title = (Object(external_this_wp_compose_["compose"])(post_title_applyWithSelect, post_title_applyWithDispatch, external_this_wp_compose_["withInstanceId"], external_this_wp_components_["withFocusOutside"])(post_title_PostTitle)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-trash/index.js + + + +/** + * WordPress dependencies + */ + + + + + +function PostTrash(_ref) { + var isNew = _ref.isNew, + postId = _ref.postId, + postType = _ref.postType, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["isNew", "postId", "postType"]); + + if (isNew || !postId) { + return null; + } + + var onClick = function onClick() { + return props.trashPost(postId, postType); + }; + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: "editor-post-trash button-link-delete", + onClick: onClick, + isDefault: true, + isLarge: true + }, Object(external_this_wp_i18n_["__"])('Move to trash')); +} + +/* harmony default export */ var post_trash = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isEditedPostNew = _select.isEditedPostNew, + getCurrentPostId = _select.getCurrentPostId, + getCurrentPostType = _select.getCurrentPostType; + + return { + isNew: isEditedPostNew(), + postId: getCurrentPostId(), + postType: getCurrentPostType() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + trashPost: dispatch('core/editor').trashPost + }; +})])(PostTrash)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-trash/check.js +/** + * WordPress dependencies + */ + + +function PostTrashCheck(_ref) { + var isNew = _ref.isNew, + postId = _ref.postId, + children = _ref.children; + + if (isNew || !postId) { + return null; + } + + return children; +} + +/* harmony default export */ var post_trash_check = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isEditedPostNew = _select.isEditedPostNew, + getCurrentPostId = _select.getCurrentPostId; + + return { + isNew: isEditedPostNew(), + postId: getCurrentPostId() + }; +})(PostTrashCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/post-visibility/check.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +function PostVisibilityCheck(_ref) { + var hasPublishAction = _ref.hasPublishAction, + render = _ref.render; + var canEdit = hasPublishAction; + return render({ + canEdit: canEdit + }); +} +/* harmony default export */ var post_visibility_check = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + getCurrentPost = _select.getCurrentPost, + getCurrentPostType = _select.getCurrentPostType; + + return { + hasPublishAction: Object(external_lodash_["get"])(getCurrentPost(), ['_links', 'wp:action-publish'], false), + postType: getCurrentPostType() + }; +})])(PostVisibilityCheck)); + +// EXTERNAL MODULE: external {"this":["wp","wordcount"]} +var external_this_wp_wordcount_ = __webpack_require__(98); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/word-count/index.js + + +/** + * WordPress dependencies + */ + + + + +function WordCount(_ref) { + var content = _ref.content; + + /* + * translators: If your word count is based on single characters (e.g. East Asian characters), + * enter 'characters_excluding_spaces' or 'characters_including_spaces'. Otherwise, enter 'words'. + * Do not translate into your own language. + */ + var wordCountType = Object(external_this_wp_i18n_["_x"])('words', 'Word count type. Do not translate!'); + + return Object(external_this_wp_element_["createElement"])("span", { + className: "word-count" + }, Object(external_this_wp_wordcount_["count"])(content, wordCountType)); +} + +/* harmony default export */ var word_count = (Object(external_this_wp_data_["withSelect"])(function (select) { + return { + content: select('core/editor').getEditedPostAttribute('content') + }; +})(WordCount)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/table-of-contents/panel.js + + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + +function TableOfContentsPanel(_ref) { + var headingCount = _ref.headingCount, + paragraphCount = _ref.paragraphCount, + numberOfBlocks = _ref.numberOfBlocks, + hasOutlineItemsDisabled = _ref.hasOutlineItemsDisabled, + onRequestClose = _ref.onRequestClose; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])("div", { + className: "table-of-contents__counts", + role: "note", + "aria-label": Object(external_this_wp_i18n_["__"])('Document Statistics'), + tabIndex: "0" + }, Object(external_this_wp_element_["createElement"])("div", { + className: "table-of-contents__count" + }, Object(external_this_wp_i18n_["__"])('Words'), Object(external_this_wp_element_["createElement"])(word_count, null)), Object(external_this_wp_element_["createElement"])("div", { + className: "table-of-contents__count" + }, Object(external_this_wp_i18n_["__"])('Headings'), Object(external_this_wp_element_["createElement"])("span", { + className: "table-of-contents__number" + }, headingCount)), Object(external_this_wp_element_["createElement"])("div", { + className: "table-of-contents__count" + }, Object(external_this_wp_i18n_["__"])('Paragraphs'), Object(external_this_wp_element_["createElement"])("span", { + className: "table-of-contents__number" + }, paragraphCount)), Object(external_this_wp_element_["createElement"])("div", { + className: "table-of-contents__count" + }, Object(external_this_wp_i18n_["__"])('Blocks'), Object(external_this_wp_element_["createElement"])("span", { + className: "table-of-contents__number" + }, numberOfBlocks))), headingCount > 0 && Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])("hr", null), Object(external_this_wp_element_["createElement"])("span", { + className: "table-of-contents__title" + }, Object(external_this_wp_i18n_["__"])('Document Outline')), Object(external_this_wp_element_["createElement"])(document_outline, { + onSelect: onRequestClose, + hasOutlineItemsDisabled: hasOutlineItemsDisabled + }))); +} + +/* harmony default export */ var panel = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getGlobalBlockCount = _select.getGlobalBlockCount; + + return { + headingCount: getGlobalBlockCount('core/heading'), + paragraphCount: getGlobalBlockCount('core/paragraph'), + numberOfBlocks: getGlobalBlockCount() + }; +})(TableOfContentsPanel)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/table-of-contents/index.js + + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + +function TableOfContents(_ref) { + var hasBlocks = _ref.hasBlocks, + hasOutlineItemsDisabled = _ref.hasOutlineItemsDisabled; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Dropdown"], { + position: "bottom", + className: "table-of-contents", + contentClassName: "table-of-contents__popover", + renderToggle: function renderToggle(_ref2) { + var isOpen = _ref2.isOpen, + onToggle = _ref2.onToggle; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + onClick: hasBlocks ? onToggle : undefined, + icon: "info-outline", + "aria-expanded": isOpen, + label: Object(external_this_wp_i18n_["__"])('Content structure'), + labelPosition: "bottom", + "aria-disabled": !hasBlocks + }); + }, + renderContent: function renderContent(_ref3) { + var onClose = _ref3.onClose; + return Object(external_this_wp_element_["createElement"])(panel, { + onRequestClose: onClose, + hasOutlineItemsDisabled: hasOutlineItemsDisabled + }); + } + }); +} + +/* harmony default export */ var table_of_contents = (Object(external_this_wp_data_["withSelect"])(function (select) { + return { + hasBlocks: !!select('core/block-editor').getBlockCount() + }; +})(TableOfContents)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/unsaved-changes-warning/index.js + + + + + + + +/** + * WordPress dependencies + */ + + + + +var unsaved_changes_warning_UnsavedChangesWarning = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(UnsavedChangesWarning, _Component); + + function UnsavedChangesWarning() { + var _this; + + Object(classCallCheck["a" /* default */])(this, UnsavedChangesWarning); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(UnsavedChangesWarning).apply(this, arguments)); + _this.warnIfUnsavedChanges = _this.warnIfUnsavedChanges.bind(Object(assertThisInitialized["a" /* default */])(Object(assertThisInitialized["a" /* default */])(_this))); + return _this; + } + + Object(createClass["a" /* default */])(UnsavedChangesWarning, [{ + key: "componentDidMount", + value: function componentDidMount() { + window.addEventListener('beforeunload', this.warnIfUnsavedChanges); + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + window.removeEventListener('beforeunload', this.warnIfUnsavedChanges); + } + /** + * Warns the user if there are unsaved changes before leaving the editor. + * + * @param {Event} event `beforeunload` event. + * + * @return {?string} Warning prompt message, if unsaved changes exist. + */ + + }, { + key: "warnIfUnsavedChanges", + value: function warnIfUnsavedChanges(event) { + var isDirty = this.props.isDirty; + + if (isDirty) { + event.returnValue = Object(external_this_wp_i18n_["__"])('You have unsaved changes. If you proceed, they will be lost.'); + return event.returnValue; + } + } + }, { + key: "render", + value: function render() { + return null; + } + }]); + + return UnsavedChangesWarning; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var unsaved_changes_warning = (Object(external_this_wp_data_["withSelect"])(function (select) { + return { + isDirty: select('core/editor').isEditedPostDirty() + }; +})(unsaved_changes_warning_UnsavedChangesWarning)); + +// EXTERNAL MODULE: ./node_modules/memize/index.js +var memize = __webpack_require__(41); +var memize_default = /*#__PURE__*/__webpack_require__.n(memize); + +// EXTERNAL MODULE: ./node_modules/traverse/index.js +var traverse = __webpack_require__(227); +var traverse_default = /*#__PURE__*/__webpack_require__.n(traverse); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/ast/parse.js + + +/* eslint-disable @wordpress/no-unused-vars-before-return */ +// Adapted from https://github.com/reworkcss/css +// because we needed to remove source map support. +// http://www.w3.org/TR/CSS21/grammar.htm +// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027 +var commentre = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g; +/* harmony default export */ var parse = (function (css, options) { + options = options || {}; + /** + * Positional. + */ + + var lineno = 1; + var column = 1; + /** + * Update lineno and column based on `str`. + */ + + function updatePosition(str) { + var lines = str.match(/\n/g); + + if (lines) { + lineno += lines.length; + } + + var i = str.lastIndexOf('\n'); // eslint-disable-next-line no-bitwise + + column = ~i ? str.length - i : column + str.length; + } + /** + * Mark position and patch `node.position`. + */ + + + function position() { + var start = { + line: lineno, + column: column + }; + return function (node) { + node.position = new Position(start); + whitespace(); + return node; + }; + } + /** + * Store position information for a node + */ + + + function Position(start) { + this.start = start; + this.end = { + line: lineno, + column: column + }; + this.source = options.source; + } + /** + * Non-enumerable source string + */ + + + Position.prototype.content = css; + /** + * Error `msg`. + */ + + var errorsList = []; + + function error(msg) { + var err = new Error(options.source + ':' + lineno + ':' + column + ': ' + msg); + err.reason = msg; + err.filename = options.source; + err.line = lineno; + err.column = column; + err.source = css; + + if (options.silent) { + errorsList.push(err); + } else { + throw err; + } + } + /** + * Parse stylesheet. + */ + + + function stylesheet() { + var rulesList = rules(); + return { + type: 'stylesheet', + stylesheet: { + source: options.source, + rules: rulesList, + parsingErrors: errorsList + } + }; + } + /** + * Opening brace. + */ + + + function open() { + return match(/^{\s*/); + } + /** + * Closing brace. + */ + + + function close() { + return match(/^}/); + } + /** + * Parse ruleset. + */ + + + function rules() { + var node; + var accumulator = []; + whitespace(); + comments(accumulator); + + while (css.length && css.charAt(0) !== '}' && (node = atrule() || rule())) { + if (node !== false) { + accumulator.push(node); + comments(accumulator); + } + } + + return accumulator; + } + /** + * Match `re` and return captures. + */ + + + function match(re) { + var m = re.exec(css); + + if (!m) { + return; + } + + var str = m[0]; + updatePosition(str); + css = css.slice(str.length); + return m; + } + /** + * Parse whitespace. + */ + + + function whitespace() { + match(/^\s*/); + } + /** + * Parse comments; + */ + + + function comments(accumulator) { + var c; + accumulator = accumulator || []; // eslint-disable-next-line no-cond-assign + + while (c = comment()) { + if (c !== false) { + accumulator.push(c); + } + } + + return accumulator; + } + /** + * Parse comment. + */ + + + function comment() { + var pos = position(); + + if ('/' !== css.charAt(0) || '*' !== css.charAt(1)) { + return; + } + + var i = 2; + + while ('' !== css.charAt(i) && ('*' !== css.charAt(i) || '/' !== css.charAt(i + 1))) { + ++i; + } + + i += 2; + + if ('' === css.charAt(i - 1)) { + return error('End of comment missing'); + } + + var str = css.slice(2, i - 2); + column += 2; + updatePosition(str); + css = css.slice(i); + column += 2; + return pos({ + type: 'comment', + comment: str + }); + } + /** + * Parse selector. + */ + + + function selector() { + var m = match(/^([^{]+)/); + + if (!m) { + return; + } + /* @fix Remove all comments from selectors + * http://ostermiller.org/findcomment.html */ + + + return trim(m[0]).replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/g, '').replace(/"(?:\\"|[^"])*"|'(?:\\'|[^'])*'/g, function (matched) { + return matched.replace(/,/g, "\u200C"); + }).split(/\s*(?![^(]*\)),\s*/).map(function (s) { + return s.replace(/\u200C/g, ','); + }); + } + /** + * Parse declaration. + */ + + + function declaration() { + var pos = position(); // prop + + var prop = match(/^(\*?[-#\/\*\\\w]+(\[[0-9a-z_-]+\])?)\s*/); + + if (!prop) { + return; + } + + prop = trim(prop[0]); // : + + if (!match(/^:\s*/)) { + return error("property missing ':'"); + } // val + + + var val = match(/^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^\)]*?\)|[^};])+)/); + var ret = pos({ + type: 'declaration', + property: prop.replace(commentre, ''), + value: val ? trim(val[0]).replace(commentre, '') : '' + }); // ; + + match(/^[;\s]*/); + return ret; + } + /** + * Parse declarations. + */ + + + function declarations() { + var decls = []; + + if (!open()) { + return error("missing '{'"); + } + + comments(decls); // declarations + + var decl; // eslint-disable-next-line no-cond-assign + + while (decl = declaration()) { + if (decl !== false) { + decls.push(decl); + comments(decls); + } + } + + if (!close()) { + return error("missing '}'"); + } + + return decls; + } + /** + * Parse keyframe. + */ + + + function keyframe() { + var m; + var vals = []; + var pos = position(); // eslint-disable-next-line no-cond-assign + + while (m = match(/^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/)) { + vals.push(m[1]); + match(/^,\s*/); + } + + if (!vals.length) { + return; + } + + return pos({ + type: 'keyframe', + values: vals, + declarations: declarations() + }); + } + /** + * Parse keyframes. + */ + + + function atkeyframes() { + var pos = position(); + var m = match(/^@([-\w]+)?keyframes\s*/); + + if (!m) { + return; + } + + var vendor = m[1]; // identifier + + m = match(/^([-\w]+)\s*/); + + if (!m) { + return error('@keyframes missing name'); + } + + var name = m[1]; + + if (!open()) { + return error("@keyframes missing '{'"); + } + + var frame; + var frames = comments(); // eslint-disable-next-line no-cond-assign + + while (frame = keyframe()) { + frames.push(frame); + frames = frames.concat(comments()); + } + + if (!close()) { + return error("@keyframes missing '}'"); + } + + return pos({ + type: 'keyframes', + name: name, + vendor: vendor, + keyframes: frames + }); + } + /** + * Parse supports. + */ + + + function atsupports() { + var pos = position(); + var m = match(/^@supports *([^{]+)/); + + if (!m) { + return; + } + + var supports = trim(m[1]); + + if (!open()) { + return error("@supports missing '{'"); + } + + var style = comments().concat(rules()); + + if (!close()) { + return error("@supports missing '}'"); + } + + return pos({ + type: 'supports', + supports: supports, + rules: style + }); + } + /** + * Parse host. + */ + + + function athost() { + var pos = position(); + var m = match(/^@host\s*/); + + if (!m) { + return; + } + + if (!open()) { + return error("@host missing '{'"); + } + + var style = comments().concat(rules()); + + if (!close()) { + return error("@host missing '}'"); + } + + return pos({ + type: 'host', + rules: style + }); + } + /** + * Parse media. + */ + + + function atmedia() { + var pos = position(); + var m = match(/^@media *([^{]+)/); + + if (!m) { + return; + } + + var media = trim(m[1]); + + if (!open()) { + return error("@media missing '{'"); + } + + var style = comments().concat(rules()); + + if (!close()) { + return error("@media missing '}'"); + } + + return pos({ + type: 'media', + media: media, + rules: style + }); + } + /** + * Parse custom-media. + */ + + + function atcustommedia() { + var pos = position(); + var m = match(/^@custom-media\s+(--[^\s]+)\s*([^{;]+);/); + + if (!m) { + return; + } + + return pos({ + type: 'custom-media', + name: trim(m[1]), + media: trim(m[2]) + }); + } + /** + * Parse paged media. + */ + + + function atpage() { + var pos = position(); + var m = match(/^@page */); + + if (!m) { + return; + } + + var sel = selector() || []; + + if (!open()) { + return error("@page missing '{'"); + } + + var decls = comments(); // declarations + + var decl; // eslint-disable-next-line no-cond-assign + + while (decl = declaration()) { + decls.push(decl); + decls = decls.concat(comments()); + } + + if (!close()) { + return error("@page missing '}'"); + } + + return pos({ + type: 'page', + selectors: sel, + declarations: decls + }); + } + /** + * Parse document. + */ + + + function atdocument() { + var pos = position(); + var m = match(/^@([-\w]+)?document *([^{]+)/); + + if (!m) { + return; + } + + var vendor = trim(m[1]); + var doc = trim(m[2]); + + if (!open()) { + return error("@document missing '{'"); + } + + var style = comments().concat(rules()); + + if (!close()) { + return error("@document missing '}'"); + } + + return pos({ + type: 'document', + document: doc, + vendor: vendor, + rules: style + }); + } + /** + * Parse font-face. + */ + + + function atfontface() { + var pos = position(); + var m = match(/^@font-face\s*/); + + if (!m) { + return; + } + + if (!open()) { + return error("@font-face missing '{'"); + } + + var decls = comments(); // declarations + + var decl; // eslint-disable-next-line no-cond-assign + + while (decl = declaration()) { + decls.push(decl); + decls = decls.concat(comments()); + } + + if (!close()) { + return error("@font-face missing '}'"); + } + + return pos({ + type: 'font-face', + declarations: decls + }); + } + /** + * Parse import + */ + + + var atimport = _compileAtrule('import'); + /** + * Parse charset + */ + + + var atcharset = _compileAtrule('charset'); + /** + * Parse namespace + */ + + + var atnamespace = _compileAtrule('namespace'); + /** + * Parse non-block at-rules + */ + + + function _compileAtrule(name) { + var re = new RegExp('^@' + name + '\\s*([^;]+);'); + return function () { + var pos = position(); + var m = match(re); + + if (!m) { + return; + } + + var ret = { + type: name + }; + ret[name] = m[1].trim(); + return pos(ret); + }; + } + /** + * Parse at rule. + */ + + + function atrule() { + if (css[0] !== '@') { + return; + } + + return atkeyframes() || atmedia() || atcustommedia() || atsupports() || atimport() || atcharset() || atnamespace() || atdocument() || atpage() || athost() || atfontface(); + } + /** + * Parse rule. + */ + + + function rule() { + var pos = position(); + var sel = selector(); + + if (!sel) { + return error('selector missing'); + } + + comments(); + return pos({ + type: 'rule', + selectors: sel, + declarations: declarations() + }); + } + + return addParent(stylesheet()); +}); +/** + * Trim `str`. + */ + +function trim(str) { + return str ? str.replace(/^\s+|\s+$/g, '') : ''; +} +/** + * Adds non-enumerable parent node reference to each node. + */ + + +function addParent(obj, parent) { + var isNode = obj && typeof obj.type === 'string'; + var childParent = isNode ? obj : parent; + + for (var k in obj) { + var value = obj[k]; + + if (Array.isArray(value)) { + value.forEach(function (v) { + addParent(v, childParent); + }); + } else if (value && Object(esm_typeof["a" /* default */])(value) === 'object') { + addParent(value, childParent); + } + } + + if (isNode) { + Object.defineProperty(obj, 'parent', { + configurable: true, + writable: true, + enumerable: false, + value: parent || null + }); + } + + return obj; +} + +// EXTERNAL MODULE: ./node_modules/inherits/inherits_browser.js +var inherits_browser = __webpack_require__(109); +var inherits_browser_default = /*#__PURE__*/__webpack_require__.n(inherits_browser); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/ast/stringify/compiler.js +// Adapted from https://github.com/reworkcss/css +// because we needed to remove source map support. + +/** + * Expose `Compiler`. + */ +/* harmony default export */ var stringify_compiler = (Compiler); +/** + * Initialize a compiler. + * + * @param {Type} name + * @return {Type} + * @api public + */ + +function Compiler(opts) { + this.options = opts || {}; +} +/** + * Emit `str` + */ + + +Compiler.prototype.emit = function (str) { + return str; +}; +/** + * Visit `node`. + */ + + +Compiler.prototype.visit = function (node) { + return this[node.type](node); +}; +/** + * Map visit over array of `nodes`, optionally using a `delim` + */ + + +Compiler.prototype.mapVisit = function (nodes, delim) { + var buf = ''; + delim = delim || ''; + + for (var i = 0, length = nodes.length; i < length; i++) { + buf += this.visit(nodes[i]); + + if (delim && i < length - 1) { + buf += this.emit(delim); + } + } + + return buf; +}; + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/ast/stringify/compress.js +// Adapted from https://github.com/reworkcss/css +// because we needed to remove source map support. + +/** + * External dependencies + */ + +/** + * Internal dependencies + */ + + +/** + * Expose compiler. + */ + +/* harmony default export */ var compress = (compress_Compiler); +/** + * Initialize a new `Compiler`. + */ + +function compress_Compiler(options) { + stringify_compiler.call(this, options); +} +/** + * Inherit from `Base.prototype`. + */ + + +inherits_browser_default()(compress_Compiler, stringify_compiler); +/** + * Compile `node`. + */ + +compress_Compiler.prototype.compile = function (node) { + return node.stylesheet.rules.map(this.visit, this).join(''); +}; +/** + * Visit comment node. + */ + + +compress_Compiler.prototype.comment = function (node) { + return this.emit('', node.position); +}; +/** + * Visit import node. + */ + + +compress_Compiler.prototype.import = function (node) { + return this.emit('@import ' + node.import + ';', node.position); +}; +/** + * Visit media node. + */ + + +compress_Compiler.prototype.media = function (node) { + return this.emit('@media ' + node.media, node.position) + this.emit('{') + this.mapVisit(node.rules) + this.emit('}'); +}; +/** + * Visit document node. + */ + + +compress_Compiler.prototype.document = function (node) { + var doc = '@' + (node.vendor || '') + 'document ' + node.document; + return this.emit(doc, node.position) + this.emit('{') + this.mapVisit(node.rules) + this.emit('}'); +}; +/** + * Visit charset node. + */ + + +compress_Compiler.prototype.charset = function (node) { + return this.emit('@charset ' + node.charset + ';', node.position); +}; +/** + * Visit namespace node. + */ + + +compress_Compiler.prototype.namespace = function (node) { + return this.emit('@namespace ' + node.namespace + ';', node.position); +}; +/** + * Visit supports node. + */ + + +compress_Compiler.prototype.supports = function (node) { + return this.emit('@supports ' + node.supports, node.position) + this.emit('{') + this.mapVisit(node.rules) + this.emit('}'); +}; +/** + * Visit keyframes node. + */ + + +compress_Compiler.prototype.keyframes = function (node) { + return this.emit('@' + (node.vendor || '') + 'keyframes ' + node.name, node.position) + this.emit('{') + this.mapVisit(node.keyframes) + this.emit('}'); +}; +/** + * Visit keyframe node. + */ + + +compress_Compiler.prototype.keyframe = function (node) { + var decls = node.declarations; + return this.emit(node.values.join(','), node.position) + this.emit('{') + this.mapVisit(decls) + this.emit('}'); +}; +/** + * Visit page node. + */ + + +compress_Compiler.prototype.page = function (node) { + var sel = node.selectors.length ? node.selectors.join(', ') : ''; + return this.emit('@page ' + sel, node.position) + this.emit('{') + this.mapVisit(node.declarations) + this.emit('}'); +}; +/** + * Visit font-face node. + */ + + +compress_Compiler.prototype['font-face'] = function (node) { + return this.emit('@font-face', node.position) + this.emit('{') + this.mapVisit(node.declarations) + this.emit('}'); +}; +/** + * Visit host node. + */ + + +compress_Compiler.prototype.host = function (node) { + return this.emit('@host', node.position) + this.emit('{') + this.mapVisit(node.rules) + this.emit('}'); +}; +/** + * Visit custom-media node. + */ + + +compress_Compiler.prototype['custom-media'] = function (node) { + return this.emit('@custom-media ' + node.name + ' ' + node.media + ';', node.position); +}; +/** + * Visit rule node. + */ + + +compress_Compiler.prototype.rule = function (node) { + var decls = node.declarations; + + if (!decls.length) { + return ''; + } + + return this.emit(node.selectors.join(','), node.position) + this.emit('{') + this.mapVisit(decls) + this.emit('}'); +}; +/** + * Visit declaration node. + */ + + +compress_Compiler.prototype.declaration = function (node) { + return this.emit(node.property + ':' + node.value, node.position) + this.emit(';'); +}; + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/ast/stringify/identity.js +/* eslint-disable @wordpress/no-unused-vars-before-return */ +// Adapted from https://github.com/reworkcss/css +// because we needed to remove source map support. + +/** + * External dependencies + */ + +/** + * Internal dependencies + */ + + +/** + * Expose compiler. + */ + +/* harmony default export */ var identity = (identity_Compiler); +/** + * Initialize a new `Compiler`. + */ + +function identity_Compiler(options) { + options = options || {}; + stringify_compiler.call(this, options); + this.indentation = options.indent; +} +/** + * Inherit from `Base.prototype`. + */ + + +inherits_browser_default()(identity_Compiler, stringify_compiler); +/** + * Compile `node`. + */ + +identity_Compiler.prototype.compile = function (node) { + return this.stylesheet(node); +}; +/** + * Visit stylesheet node. + */ + + +identity_Compiler.prototype.stylesheet = function (node) { + return this.mapVisit(node.stylesheet.rules, '\n\n'); +}; +/** + * Visit comment node. + */ + + +identity_Compiler.prototype.comment = function (node) { + return this.emit(this.indent() + '/*' + node.comment + '*/', node.position); +}; +/** + * Visit import node. + */ + + +identity_Compiler.prototype.import = function (node) { + return this.emit('@import ' + node.import + ';', node.position); +}; +/** + * Visit media node. + */ + + +identity_Compiler.prototype.media = function (node) { + return this.emit('@media ' + node.media, node.position) + this.emit(' {\n' + this.indent(1)) + this.mapVisit(node.rules, '\n\n') + this.emit(this.indent(-1) + '\n}'); +}; +/** + * Visit document node. + */ + + +identity_Compiler.prototype.document = function (node) { + var doc = '@' + (node.vendor || '') + 'document ' + node.document; + return this.emit(doc, node.position) + this.emit(' ' + ' {\n' + this.indent(1)) + this.mapVisit(node.rules, '\n\n') + this.emit(this.indent(-1) + '\n}'); +}; +/** + * Visit charset node. + */ + + +identity_Compiler.prototype.charset = function (node) { + return this.emit('@charset ' + node.charset + ';', node.position); +}; +/** + * Visit namespace node. + */ + + +identity_Compiler.prototype.namespace = function (node) { + return this.emit('@namespace ' + node.namespace + ';', node.position); +}; +/** + * Visit supports node. + */ + + +identity_Compiler.prototype.supports = function (node) { + return this.emit('@supports ' + node.supports, node.position) + this.emit(' {\n' + this.indent(1)) + this.mapVisit(node.rules, '\n\n') + this.emit(this.indent(-1) + '\n}'); +}; +/** + * Visit keyframes node. + */ + + +identity_Compiler.prototype.keyframes = function (node) { + return this.emit('@' + (node.vendor || '') + 'keyframes ' + node.name, node.position) + this.emit(' {\n' + this.indent(1)) + this.mapVisit(node.keyframes, '\n') + this.emit(this.indent(-1) + '}'); +}; +/** + * Visit keyframe node. + */ + + +identity_Compiler.prototype.keyframe = function (node) { + var decls = node.declarations; + return this.emit(this.indent()) + this.emit(node.values.join(', '), node.position) + this.emit(' {\n' + this.indent(1)) + this.mapVisit(decls, '\n') + this.emit(this.indent(-1) + '\n' + this.indent() + '}\n'); +}; +/** + * Visit page node. + */ + + +identity_Compiler.prototype.page = function (node) { + var sel = node.selectors.length ? node.selectors.join(', ') + ' ' : ''; + return this.emit('@page ' + sel, node.position) + this.emit('{\n') + this.emit(this.indent(1)) + this.mapVisit(node.declarations, '\n') + this.emit(this.indent(-1)) + this.emit('\n}'); +}; +/** + * Visit font-face node. + */ + + +identity_Compiler.prototype['font-face'] = function (node) { + return this.emit('@font-face ', node.position) + this.emit('{\n') + this.emit(this.indent(1)) + this.mapVisit(node.declarations, '\n') + this.emit(this.indent(-1)) + this.emit('\n}'); +}; +/** + * Visit host node. + */ + + +identity_Compiler.prototype.host = function (node) { + return this.emit('@host', node.position) + this.emit(' {\n' + this.indent(1)) + this.mapVisit(node.rules, '\n\n') + this.emit(this.indent(-1) + '\n}'); +}; +/** + * Visit custom-media node. + */ + + +identity_Compiler.prototype['custom-media'] = function (node) { + return this.emit('@custom-media ' + node.name + ' ' + node.media + ';', node.position); +}; +/** + * Visit rule node. + */ + + +identity_Compiler.prototype.rule = function (node) { + var indent = this.indent(); + var decls = node.declarations; + + if (!decls.length) { + return ''; + } + + return this.emit(node.selectors.map(function (s) { + return indent + s; + }).join(',\n'), node.position) + this.emit(' {\n') + this.emit(this.indent(1)) + this.mapVisit(decls, '\n') + this.emit(this.indent(-1)) + this.emit('\n' + this.indent() + '}'); +}; +/** + * Visit declaration node. + */ + + +identity_Compiler.prototype.declaration = function (node) { + return this.emit(this.indent()) + this.emit(node.property + ': ' + node.value, node.position) + this.emit(';'); +}; +/** + * Increase, decrease or return current indentation. + */ + + +identity_Compiler.prototype.indent = function (level) { + this.level = this.level || 1; + + if (null !== level) { + this.level += level; + return ''; + } + + return Array(this.level).join(this.indentation || ' '); +}; + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/ast/stringify/index.js +// Adapted from https://github.com/reworkcss/css +// because we needed to remove source map support. + +/** + * Internal dependencies + */ + + +/** + * Stringfy the given AST `node`. + * + * Options: + * + * - `compress` space-optimized output + * - `sourcemap` return an object with `.code` and `.map` + * + * @param {Object} node + * @param {Object} [options] + * @return {String} + * @api public + */ + +/* harmony default export */ var stringify = (function (node, options) { + options = options || {}; + var compiler = options.compress ? new compress(options) : new identity(options); + var code = compiler.compile(node); + return code; +}); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/ast/index.js +// Adapted from https://github.com/reworkcss/css +// because we needed to remove source map support. + + + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/traverse.js +/** + * External dependencies + */ + +/** + * Internal dependencies + */ + + + +function traverseCSS(css, callback) { + try { + var parsed = parse(css); + var updated = traverse_default.a.map(parsed, function (node) { + if (!node) { + return node; + } + + var updatedNode = callback(node); + return this.update(updatedNode); + }); + return stringify(updated); + } catch (err) { + // eslint-disable-next-line no-console + console.warn('Error while traversing the CSS: ' + err); + return null; + } +} + +/* harmony default export */ var editor_styles_traverse = (traverseCSS); + +// EXTERNAL MODULE: ./node_modules/url/url.js +var url = __webpack_require__(84); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/transforms/url-rewrite.js + + +/** + * External dependencies + */ + +/** + * Return `true` if the given path is http/https. + * + * @param {string} filePath path + * + * @return {boolean} is remote path. + */ + +function isRemotePath(filePath) { + return /^(?:https?:)?\/\//.test(filePath); +} +/** + * Return `true` if the given filePath is an absolute url. + * + * @param {string} filePath path + * + * @return {boolean} is absolute path. + */ + + +function isAbsolutePath(filePath) { + return /^\/(?!\/)/.test(filePath); +} +/** + * Whether or not the url should be inluded. + * + * @param {Object} meta url meta info + * + * @return {boolean} is valid. + */ + + +function isValidURL(meta) { + // ignore hashes or data uris + if (meta.value.indexOf('data:') === 0 || meta.value.indexOf('#') === 0) { + return false; + } + + if (isAbsolutePath(meta.value)) { + return false; + } // do not handle the http/https urls if `includeRemote` is false + + + if (isRemotePath(meta.value)) { + return false; + } + + return true; +} +/** + * Get the absolute path of the url, relative to the basePath + * + * @param {string} str the url + * @param {string} baseURL base URL + * @param {string} absolutePath the absolute path + * + * @return {string} the full path to the file + */ + + +function getResourcePath(str, baseURL) { + var pathname = Object(url["parse"])(str).pathname; + var filePath = Object(url["resolve"])(baseURL, pathname); + return filePath; +} +/** + * Process the single `url()` pattern + * + * @param {string} baseURL the base URL for relative URLs + * @return {Promise} the Promise + */ + + +function processURL(baseURL) { + return function (meta) { + var URL = getResourcePath(meta.value, baseURL); + return Object(objectSpread["a" /* default */])({}, meta, { + newUrl: 'url(' + meta.before + meta.quote + URL + meta.quote + meta.after + ')' + }); + }; +} +/** + * Get all `url()`s, and return the meta info + * + * @param {string} value decl.value + * + * @return {Array} the urls + */ + + +function getURLs(value) { + var reg = /url\((\s*)(['"]?)(.+?)\2(\s*)\)/g; + var match; + var URLs = []; + + while ((match = reg.exec(value)) !== null) { + var meta = { + source: match[0], + before: match[1], + quote: match[2], + value: match[3], + after: match[4] + }; + + if (isValidURL(meta)) { + URLs.push(meta); + } + } + + return URLs; +} +/** + * Replace the raw value's `url()` segment to the new value + * + * @param {string} raw the raw value + * @param {Array} URLs the URLs to replace + * + * @return {string} the new value + */ + + +function replaceURLs(raw, URLs) { + URLs.forEach(function (item) { + raw = raw.replace(item.source, item.newUrl); + }); + return raw; +} + +var url_rewrite_rewrite = function rewrite(rootURL) { + return function (node) { + if (node.type === 'declaration') { + var updatedURLs = getURLs(node.value).map(processURL(rootURL)); + return Object(objectSpread["a" /* default */])({}, node, { + value: replaceURLs(node.value, updatedURLs) + }); + } + + return node; + }; +}; + +/* harmony default export */ var url_rewrite = (url_rewrite_rewrite); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/transforms/wrap.js + + +/** + * External dependencies + */ + +/** + * @const string IS_ROOT_TAG Regex to check if the selector is a root tag selector. + */ + +var IS_ROOT_TAG = /^(body|html|:root).*$/; + +var wrap_wrap = function wrap(namespace) { + var ignore = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + return function (node) { + var updateSelector = function updateSelector(selector) { + if (Object(external_lodash_["includes"])(ignore, selector.trim())) { + return selector; + } // Anything other than a root tag is always prefixed. + + + { + if (!selector.match(IS_ROOT_TAG)) { + return namespace + ' ' + selector; + } + } // HTML and Body elements cannot be contained within our container so lets extract their styles. + + return selector.replace(/^(body|html|:root)/, namespace); + }; + + if (node.type === 'rule') { + return Object(objectSpread["a" /* default */])({}, node, { + selectors: node.selectors.map(updateSelector) + }); + } + + return node; + }; +}; + +/* harmony default export */ var transforms_wrap = (wrap_wrap); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/editor-styles/index.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + + + +/** + * Convert css rules. + * + * @param {Array} styles CSS rules. + * @param {string} wrapperClassName Wrapper Class Name. + * @return {Array} converted rules. + */ + +var editor_styles_transformStyles = function transformStyles(styles) { + var wrapperClassName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + return Object(external_lodash_["map"])(styles, function (_ref) { + var css = _ref.css, + baseURL = _ref.baseURL; + var transforms = []; + + if (wrapperClassName) { + transforms.push(transforms_wrap(wrapperClassName)); + } + + if (baseURL) { + transforms.push(url_rewrite(baseURL)); + } + + if (transforms.length) { + return editor_styles_traverse(css, Object(external_this_wp_compose_["compose"])(transforms)); + } + + return css; + }); +}; + +/* harmony default export */ var editor_styles = (editor_styles_transformStyles); + +// EXTERNAL MODULE: external {"this":["wp","blob"]} +var external_this_wp_blob_ = __webpack_require__(35); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/utils/media-upload/media-upload.js + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Browsers may use unexpected mime types, and they differ from browser to browser. + * This function computes a flexible array of mime types from the mime type structured provided by the server. + * Converts { jpg|jpeg|jpe: "image/jpeg" } into [ "image/jpeg", "image/jpg", "image/jpeg", "image/jpe" ] + * The computation of this array instead of directly using the object, + * solves the problem in chrome where mp3 files have audio/mp3 as mime type instead of audio/mpeg. + * https://bugs.chromium.org/p/chromium/issues/detail?id=227004 + * + * @param {?Object} wpMimeTypesObject Mime type object received from the server. + * Extensions are keys separated by '|' and values are mime types associated with an extension. + * + * @return {?Array} An array of mime types or the parameter passed if it was "falsy". + */ + +function getMimeTypesArray(wpMimeTypesObject) { + if (!wpMimeTypesObject) { + return wpMimeTypesObject; + } + + return Object(external_lodash_["flatMap"])(wpMimeTypesObject, function (mime, extensionsString) { + var _mime$split = mime.split('/'), + _mime$split2 = Object(slicedToArray["a" /* default */])(_mime$split, 1), + type = _mime$split2[0]; + + var extensions = extensionsString.split('|'); + return [mime].concat(Object(toConsumableArray["a" /* default */])(Object(external_lodash_["map"])(extensions, function (extension) { + return "".concat(type, "/").concat(extension); + }))); + }); +} +/** + * Media Upload is used by audio, image, gallery, video, and file blocks to + * handle uploading a media file when a file upload button is activated. + * + * TODO: future enhancement to add an upload indicator. + * + * @param {Object} $0 Parameters object passed to the function. + * @param {?Array} $0.allowedTypes Array with the types of media that can be uploaded, if unset all types are allowed. + * @param {?Object} $0.additionalData Additional data to include in the request. + * @param {Array} $0.filesList List of files. + * @param {?number} $0.maxUploadFileSize Maximum upload size in bytes allowed for the site. + * @param {Function} $0.onError Function called when an error happens. + * @param {Function} $0.onFileChange Function called each time a file or a temporary representation of the file is available. + * @param {?Object} $0.wpAllowedMimeTypes List of allowed mime types and file extensions. + */ + +function mediaUpload(_x) { + return _mediaUpload.apply(this, arguments); +} +/** + * @param {File} file Media File to Save. + * @param {?Object} additionalData Additional data to include in the request. + * + * @return {Promise} Media Object Promise. + */ + +function _mediaUpload() { + _mediaUpload = Object(asyncToGenerator["a" /* default */])( + /*#__PURE__*/ + regenerator_default.a.mark(function _callee(_ref) { + var allowedTypes, _ref$additionalData, additionalData, filesList, maxUploadFileSize, _ref$onError, onError, onFileChange, _ref$wpAllowedMimeTyp, wpAllowedMimeTypes, files, filesSet, setAndUpdateFiles, isAllowedType, allowedMimeTypesForUser, isAllowedMimeTypeForUser, triggerError, validFiles, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _mediaFile, idx, mediaFile, savedMedia, mediaObject, message; + + return regenerator_default.a.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + allowedTypes = _ref.allowedTypes, _ref$additionalData = _ref.additionalData, additionalData = _ref$additionalData === void 0 ? {} : _ref$additionalData, filesList = _ref.filesList, maxUploadFileSize = _ref.maxUploadFileSize, _ref$onError = _ref.onError, onError = _ref$onError === void 0 ? external_lodash_["noop"] : _ref$onError, onFileChange = _ref.onFileChange, _ref$wpAllowedMimeTyp = _ref.wpAllowedMimeTypes, wpAllowedMimeTypes = _ref$wpAllowedMimeTyp === void 0 ? null : _ref$wpAllowedMimeTyp; + // Cast filesList to array + files = Object(toConsumableArray["a" /* default */])(filesList); + filesSet = []; + + setAndUpdateFiles = function setAndUpdateFiles(idx, value) { + Object(external_this_wp_blob_["revokeBlobURL"])(Object(external_lodash_["get"])(filesSet, [idx, 'url'])); + filesSet[idx] = value; + onFileChange(Object(external_lodash_["compact"])(filesSet)); + }; // Allowed type specified by consumer + + + isAllowedType = function isAllowedType(fileType) { + if (!allowedTypes) { + return true; + } + + return Object(external_lodash_["some"])(allowedTypes, function (allowedType) { + // If a complete mimetype is specified verify if it matches exactly the mime type of the file. + if (Object(external_lodash_["includes"])(allowedType, '/')) { + return allowedType === fileType; + } // Otherwise a general mime type is used and we should verify if the file mimetype starts with it. + + + return Object(external_lodash_["startsWith"])(fileType, "".concat(allowedType, "/")); + }); + }; // Allowed types for the current WP_User + + + allowedMimeTypesForUser = getMimeTypesArray(wpAllowedMimeTypes); + + isAllowedMimeTypeForUser = function isAllowedMimeTypeForUser(fileType) { + return Object(external_lodash_["includes"])(allowedMimeTypesForUser, fileType); + }; // Build the error message including the filename + + + triggerError = function triggerError(error) { + error.message = [Object(external_this_wp_element_["createElement"])("strong", { + key: "filename" + }, error.file.name), ': ', error.message]; + onError(error); + }; + + validFiles = []; + _iteratorNormalCompletion = true; + _didIteratorError = false; + _iteratorError = undefined; + _context.prev = 12; + _iterator = files[Symbol.iterator](); + + case 14: + if (_iteratorNormalCompletion = (_step = _iterator.next()).done) { + _context.next = 34; + break; + } + + _mediaFile = _step.value; + + if (!(allowedMimeTypesForUser && !isAllowedMimeTypeForUser(_mediaFile.type))) { + _context.next = 19; + break; + } + + triggerError({ + code: 'MIME_TYPE_NOT_ALLOWED_FOR_USER', + message: Object(external_this_wp_i18n_["__"])('Sorry, this file type is not permitted for security reasons.'), + file: _mediaFile + }); + return _context.abrupt("continue", 31); + + case 19: + if (isAllowedType(_mediaFile.type)) { + _context.next = 22; + break; + } + + triggerError({ + code: 'MIME_TYPE_NOT_SUPPORTED', + message: Object(external_this_wp_i18n_["__"])('Sorry, this file type is not supported here.'), + file: _mediaFile + }); + return _context.abrupt("continue", 31); + + case 22: + if (!(maxUploadFileSize && _mediaFile.size > maxUploadFileSize)) { + _context.next = 25; + break; + } + + triggerError({ + code: 'SIZE_ABOVE_LIMIT', + message: Object(external_this_wp_i18n_["__"])('This file exceeds the maximum upload size for this site.'), + file: _mediaFile + }); + return _context.abrupt("continue", 31); + + case 25: + if (!(_mediaFile.size <= 0)) { + _context.next = 28; + break; + } + + triggerError({ + code: 'EMPTY_FILE', + message: Object(external_this_wp_i18n_["__"])('This file is empty.'), + file: _mediaFile + }); + return _context.abrupt("continue", 31); + + case 28: + validFiles.push(_mediaFile); // Set temporary URL to create placeholder media file, this is replaced + // with final file from media gallery when upload is `done` below + + filesSet.push({ + url: Object(external_this_wp_blob_["createBlobURL"])(_mediaFile) + }); + onFileChange(filesSet); + + case 31: + _iteratorNormalCompletion = true; + _context.next = 14; + break; + + case 34: + _context.next = 40; + break; + + case 36: + _context.prev = 36; + _context.t0 = _context["catch"](12); + _didIteratorError = true; + _iteratorError = _context.t0; + + case 40: + _context.prev = 40; + _context.prev = 41; + + if (!_iteratorNormalCompletion && _iterator.return != null) { + _iterator.return(); + } + + case 43: + _context.prev = 43; + + if (!_didIteratorError) { + _context.next = 46; + break; + } + + throw _iteratorError; + + case 46: + return _context.finish(43); + + case 47: + return _context.finish(40); + + case 48: + idx = 0; + + case 49: + if (!(idx < validFiles.length)) { + _context.next = 68; + break; + } + + mediaFile = validFiles[idx]; + _context.prev = 51; + _context.next = 54; + return createMediaFromFile(mediaFile, additionalData); + + case 54: + savedMedia = _context.sent; + mediaObject = Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(savedMedia, ['alt_text', 'source_url']), { + alt: savedMedia.alt_text, + caption: Object(external_lodash_["get"])(savedMedia, ['caption', 'raw'], ''), + title: savedMedia.title.raw, + url: savedMedia.source_url + }); + setAndUpdateFiles(idx, mediaObject); + _context.next = 65; + break; + + case 59: + _context.prev = 59; + _context.t1 = _context["catch"](51); + // Reset to empty on failure. + setAndUpdateFiles(idx, null); + message = void 0; + + if (Object(external_lodash_["has"])(_context.t1, ['message'])) { + message = Object(external_lodash_["get"])(_context.t1, ['message']); + } else { + message = Object(external_this_wp_i18n_["sprintf"])( // translators: %s: file name + Object(external_this_wp_i18n_["__"])('Error while uploading file %s to the media library.'), mediaFile.name); + } + + onError({ + code: 'GENERAL', + message: message, + file: mediaFile + }); + + case 65: + ++idx; + _context.next = 49; + break; + + case 68: + case "end": + return _context.stop(); + } + } + }, _callee, this, [[12, 36, 40, 48], [41,, 43, 47], [51, 59]]); + })); + return _mediaUpload.apply(this, arguments); +} + +function createMediaFromFile(file, additionalData) { + // Create upload payload + var data = new window.FormData(); + data.append('file', file, file.name || file.type.replace('/', '.')); + Object(external_lodash_["forEach"])(additionalData, function (value, key) { + return data.append(key, value); + }); + return external_this_wp_apiFetch_default()({ + path: '/wp/v2/media', + body: data, + method: 'POST' + }); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/utils/media-upload/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +/** + * Upload a media file when the file upload button is activated. + * Wrapper around mediaUpload() that injects the current post ID. + * + * @param {Object} $0 Parameters object passed to the function. + * @param {?Object} $0.additionalData Additional data to include in the request. + * @param {string} $0.allowedTypes Array with the types of media that can be uploaded, if unset all types are allowed. + * @param {Array} $0.filesList List of files. + * @param {?number} $0.maxUploadFileSize Maximum upload size in bytes allowed for the site. + * @param {Function} $0.onError Function called when an error happens. + * @param {Function} $0.onFileChange Function called each time a file or a temporary representation of the file is available. + */ + +/* harmony default export */ var media_upload = (function (_ref) { + var _ref$additionalData = _ref.additionalData, + additionalData = _ref$additionalData === void 0 ? {} : _ref$additionalData, + allowedTypes = _ref.allowedTypes, + filesList = _ref.filesList, + maxUploadFileSize = _ref.maxUploadFileSize, + _ref$onError = _ref.onError, + _onError = _ref$onError === void 0 ? external_lodash_["noop"] : _ref$onError, + onFileChange = _ref.onFileChange; + + var _select = Object(external_this_wp_data_["select"])('core/editor'), + getCurrentPostId = _select.getCurrentPostId, + getEditorSettings = _select.getEditorSettings; + + var wpAllowedMimeTypes = getEditorSettings().allowedMimeTypes; + maxUploadFileSize = maxUploadFileSize || getEditorSettings().maxUploadFileSize; + mediaUpload({ + allowedTypes: allowedTypes, + filesList: filesList, + onFileChange: onFileChange, + additionalData: Object(objectSpread["a" /* default */])({ + post: getCurrentPostId() + }, additionalData), + maxUploadFileSize: maxUploadFileSize, + onError: function onError(_ref2) { + var message = _ref2.message; + return _onError(message); + }, + wpAllowedMimeTypes: wpAllowedMimeTypes + }); +}); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/utils/index.js +/** + * Internal dependencies + */ + + + + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/provider/index.js + + + + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + + +var provider_EditorProvider = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(EditorProvider, _Component); + + function EditorProvider(props) { + var _this; + + Object(classCallCheck["a" /* default */])(this, EditorProvider); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(EditorProvider).apply(this, arguments)); + _this.getBlockEditorSettings = memize_default()(_this.getBlockEditorSettings, { + maxSize: 1 + }); // Assume that we don't need to initialize in the case of an error recovery. + + if (props.recovery) { + return Object(possibleConstructorReturn["a" /* default */])(_this); + } + + props.updatePostLock(props.settings.postLock); + props.setupEditor(props.post, props.initialEdits, props.settings.template); + + if (props.settings.autosave) { + props.createWarningNotice(Object(external_this_wp_i18n_["__"])('There is an autosave of this post that is more recent than the version below.'), { + id: 'autosave-exists', + actions: [{ + label: Object(external_this_wp_i18n_["__"])('View the autosave'), + url: props.settings.autosave.editLink + }] + }); + } + + return _this; + } + + Object(createClass["a" /* default */])(EditorProvider, [{ + key: "getBlockEditorSettings", + value: function getBlockEditorSettings(settings, meta, onMetaChange, reusableBlocks) { + return Object(objectSpread["a" /* default */])({}, Object(external_lodash_["pick"])(settings, ['alignWide', 'allowedBlockTypes', 'availableLegacyWidgets', 'bodyPlaceholder', 'colors', 'disableCustomColors', 'disableCustomFontSizes', 'focusMode', 'fontSizes', 'hasFixedToolbar', 'hasPermissionsToManageWidgets', 'imageSizes', 'isRTL', 'maxWidth', 'styles', 'template', 'templateLock', 'titlePlaceholder']), { + __experimentalMetaSource: { + value: meta, + onChange: onMetaChange + }, + __experimentalReusableBlocks: reusableBlocks, + __experimentalMediaUpload: media_upload + }); + } + }, { + key: "componentDidMount", + value: function componentDidMount() { + this.props.updateEditorSettings(this.props.settings); + + if (!this.props.settings.styles) { + return; + } + + var updatedStyles = editor_styles(this.props.settings.styles, '.editor-styles-wrapper'); + Object(external_lodash_["map"])(updatedStyles, function (updatedCSS) { + if (updatedCSS) { + var node = document.createElement('style'); + node.innerHTML = updatedCSS; + document.body.appendChild(node); + } + }); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + if (this.props.settings !== prevProps.settings) { + this.props.updateEditorSettings(this.props.settings); + } + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + children = _this$props.children, + blocks = _this$props.blocks, + resetEditorBlocks = _this$props.resetEditorBlocks, + isReady = _this$props.isReady, + settings = _this$props.settings, + meta = _this$props.meta, + onMetaChange = _this$props.onMetaChange, + reusableBlocks = _this$props.reusableBlocks, + resetEditorBlocksWithoutUndoLevel = _this$props.resetEditorBlocksWithoutUndoLevel; + + if (!isReady) { + return null; + } + + var editorSettings = this.getBlockEditorSettings(settings, meta, onMetaChange, reusableBlocks); + return Object(external_this_wp_element_["createElement"])(external_this_wp_blockEditor_["BlockEditorProvider"], { + value: blocks, + onInput: resetEditorBlocksWithoutUndoLevel, + onChange: resetEditorBlocks, + settings: editorSettings + }, children); + } + }]); + + return EditorProvider; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var provider = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/editor'), + isEditorReady = _select.__unstableIsEditorReady, + getEditorBlocks = _select.getEditorBlocks, + getEditedPostAttribute = _select.getEditedPostAttribute, + __experimentalGetReusableBlocks = _select.__experimentalGetReusableBlocks; + + return { + isReady: isEditorReady(), + blocks: getEditorBlocks(), + meta: getEditedPostAttribute('meta'), + reusableBlocks: __experimentalGetReusableBlocks() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/editor'), + setupEditor = _dispatch.setupEditor, + updatePostLock = _dispatch.updatePostLock, + resetEditorBlocks = _dispatch.resetEditorBlocks, + editPost = _dispatch.editPost, + updateEditorSettings = _dispatch.updateEditorSettings; + + var _dispatch2 = dispatch('core/notices'), + createWarningNotice = _dispatch2.createWarningNotice; + + return { + setupEditor: setupEditor, + updatePostLock: updatePostLock, + createWarningNotice: createWarningNotice, + resetEditorBlocks: resetEditorBlocks, + updateEditorSettings: updateEditorSettings, + resetEditorBlocksWithoutUndoLevel: function resetEditorBlocksWithoutUndoLevel(blocks) { + resetEditorBlocks(blocks, { + __unstableShouldCreateUndoLevel: false + }); + }, + onMetaChange: function onMetaChange(meta) { + editPost({ + meta: meta + }); + } + }; +})])(provider_EditorProvider)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/deprecated.js +// Block Creation Components + +/** + * WordPress dependencies + */ + + + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/components/index.js +// Block Creation Components + + // Post Related Components + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // State Related Components + + + + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/hooks/default-autocompleters.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +var defaultAutocompleters = [autocompleters_user]; +var default_autocompleters_fetchReusableBlocks = Object(external_lodash_["once"])(function () { + return Object(external_this_wp_data_["dispatch"])('core/editor').__experimentalFetchReusableBlocks(); +}); + +function setDefaultCompleters(completers, blockName) { + if (!completers) { + // Provide copies so filters may directly modify them. + completers = defaultAutocompleters.map(external_lodash_["clone"]); // Add blocks autocompleter for Paragraph block + + if (blockName === Object(external_this_wp_blocks_["getDefaultBlockName"])()) { + completers.push(Object(external_lodash_["clone"])(autocompleters_block)); + /* + * NOTE: This is a hack to help ensure reusable blocks are loaded + * so they may be included in the block completer. It can be removed + * once we have a way for completers to Promise options while + * store-based data dependencies are being resolved. + */ + + default_autocompleters_fetchReusableBlocks(); + } + } + + return completers; +} + +Object(external_this_wp_hooks_["addFilter"])('editor.Autocomplete.completers', 'editor/autocompleters/set-default-completers', setDefaultCompleters); + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/hooks/index.js +/** + * Internal dependencies + */ + + +// CONCATENATED MODULE: ./node_modules/@wordpress/editor/build-module/index.js +/* concated harmony reexport ServerSideRender */__webpack_require__.d(__webpack_exports__, "ServerSideRender", function() { return server_side_render; }); +/* concated harmony reexport AutosaveMonitor */__webpack_require__.d(__webpack_exports__, "AutosaveMonitor", function() { return autosave_monitor; }); +/* concated harmony reexport DocumentOutline */__webpack_require__.d(__webpack_exports__, "DocumentOutline", function() { return document_outline; }); +/* concated harmony reexport DocumentOutlineCheck */__webpack_require__.d(__webpack_exports__, "DocumentOutlineCheck", function() { return check; }); +/* concated harmony reexport VisualEditorGlobalKeyboardShortcuts */__webpack_require__.d(__webpack_exports__, "VisualEditorGlobalKeyboardShortcuts", function() { return visual_editor_shortcuts; }); +/* concated harmony reexport EditorGlobalKeyboardShortcuts */__webpack_require__.d(__webpack_exports__, "EditorGlobalKeyboardShortcuts", function() { return EditorGlobalKeyboardShortcuts; }); +/* concated harmony reexport TextEditorGlobalKeyboardShortcuts */__webpack_require__.d(__webpack_exports__, "TextEditorGlobalKeyboardShortcuts", function() { return TextEditorGlobalKeyboardShortcuts; }); +/* concated harmony reexport EditorHistoryRedo */__webpack_require__.d(__webpack_exports__, "EditorHistoryRedo", function() { return editor_history_redo; }); +/* concated harmony reexport EditorHistoryUndo */__webpack_require__.d(__webpack_exports__, "EditorHistoryUndo", function() { return editor_history_undo; }); +/* concated harmony reexport EditorNotices */__webpack_require__.d(__webpack_exports__, "EditorNotices", function() { return editor_notices; }); +/* concated harmony reexport ErrorBoundary */__webpack_require__.d(__webpack_exports__, "ErrorBoundary", function() { return error_boundary; }); +/* concated harmony reexport PageAttributesCheck */__webpack_require__.d(__webpack_exports__, "PageAttributesCheck", function() { return page_attributes_check; }); +/* concated harmony reexport PageAttributesOrder */__webpack_require__.d(__webpack_exports__, "PageAttributesOrder", function() { return page_attributes_order; }); +/* concated harmony reexport PageAttributesParent */__webpack_require__.d(__webpack_exports__, "PageAttributesParent", function() { return page_attributes_parent; }); +/* concated harmony reexport PageTemplate */__webpack_require__.d(__webpack_exports__, "PageTemplate", function() { return page_attributes_template; }); +/* concated harmony reexport PostAuthor */__webpack_require__.d(__webpack_exports__, "PostAuthor", function() { return post_author; }); +/* concated harmony reexport PostAuthorCheck */__webpack_require__.d(__webpack_exports__, "PostAuthorCheck", function() { return post_author_check; }); +/* concated harmony reexport PostComments */__webpack_require__.d(__webpack_exports__, "PostComments", function() { return post_comments; }); +/* concated harmony reexport PostExcerpt */__webpack_require__.d(__webpack_exports__, "PostExcerpt", function() { return post_excerpt; }); +/* concated harmony reexport PostExcerptCheck */__webpack_require__.d(__webpack_exports__, "PostExcerptCheck", function() { return post_excerpt_check; }); +/* concated harmony reexport PostFeaturedImage */__webpack_require__.d(__webpack_exports__, "PostFeaturedImage", function() { return post_featured_image; }); +/* concated harmony reexport PostFeaturedImageCheck */__webpack_require__.d(__webpack_exports__, "PostFeaturedImageCheck", function() { return post_featured_image_check; }); +/* concated harmony reexport PostFormat */__webpack_require__.d(__webpack_exports__, "PostFormat", function() { return post_format; }); +/* concated harmony reexport PostFormatCheck */__webpack_require__.d(__webpack_exports__, "PostFormatCheck", function() { return post_format_check; }); +/* concated harmony reexport PostLastRevision */__webpack_require__.d(__webpack_exports__, "PostLastRevision", function() { return post_last_revision; }); +/* concated harmony reexport PostLastRevisionCheck */__webpack_require__.d(__webpack_exports__, "PostLastRevisionCheck", function() { return post_last_revision_check; }); +/* concated harmony reexport PostLockedModal */__webpack_require__.d(__webpack_exports__, "PostLockedModal", function() { return post_locked_modal; }); +/* concated harmony reexport PostPendingStatus */__webpack_require__.d(__webpack_exports__, "PostPendingStatus", function() { return post_pending_status; }); +/* concated harmony reexport PostPendingStatusCheck */__webpack_require__.d(__webpack_exports__, "PostPendingStatusCheck", function() { return post_pending_status_check; }); +/* concated harmony reexport PostPingbacks */__webpack_require__.d(__webpack_exports__, "PostPingbacks", function() { return post_pingbacks; }); +/* concated harmony reexport PostPreviewButton */__webpack_require__.d(__webpack_exports__, "PostPreviewButton", function() { return post_preview_button; }); +/* concated harmony reexport PostPublishButton */__webpack_require__.d(__webpack_exports__, "PostPublishButton", function() { return post_publish_button; }); +/* concated harmony reexport PostPublishButtonLabel */__webpack_require__.d(__webpack_exports__, "PostPublishButtonLabel", function() { return post_publish_button_label; }); +/* concated harmony reexport PostPublishPanel */__webpack_require__.d(__webpack_exports__, "PostPublishPanel", function() { return post_publish_panel; }); +/* concated harmony reexport PostSavedState */__webpack_require__.d(__webpack_exports__, "PostSavedState", function() { return post_saved_state; }); +/* concated harmony reexport PostSchedule */__webpack_require__.d(__webpack_exports__, "PostSchedule", function() { return post_schedule; }); +/* concated harmony reexport PostScheduleCheck */__webpack_require__.d(__webpack_exports__, "PostScheduleCheck", function() { return post_schedule_check; }); +/* concated harmony reexport PostScheduleLabel */__webpack_require__.d(__webpack_exports__, "PostScheduleLabel", function() { return post_schedule_label; }); +/* concated harmony reexport PostSticky */__webpack_require__.d(__webpack_exports__, "PostSticky", function() { return post_sticky; }); +/* concated harmony reexport PostStickyCheck */__webpack_require__.d(__webpack_exports__, "PostStickyCheck", function() { return post_sticky_check; }); +/* concated harmony reexport PostSwitchToDraftButton */__webpack_require__.d(__webpack_exports__, "PostSwitchToDraftButton", function() { return post_switch_to_draft_button; }); +/* concated harmony reexport PostTaxonomies */__webpack_require__.d(__webpack_exports__, "PostTaxonomies", function() { return post_taxonomies; }); +/* concated harmony reexport PostTaxonomiesCheck */__webpack_require__.d(__webpack_exports__, "PostTaxonomiesCheck", function() { return post_taxonomies_check; }); +/* concated harmony reexport PostTextEditor */__webpack_require__.d(__webpack_exports__, "PostTextEditor", function() { return post_text_editor; }); +/* concated harmony reexport PostTitle */__webpack_require__.d(__webpack_exports__, "PostTitle", function() { return post_title; }); +/* concated harmony reexport PostTrash */__webpack_require__.d(__webpack_exports__, "PostTrash", function() { return post_trash; }); +/* concated harmony reexport PostTrashCheck */__webpack_require__.d(__webpack_exports__, "PostTrashCheck", function() { return post_trash_check; }); +/* concated harmony reexport PostTypeSupportCheck */__webpack_require__.d(__webpack_exports__, "PostTypeSupportCheck", function() { return post_type_support_check; }); +/* concated harmony reexport PostVisibility */__webpack_require__.d(__webpack_exports__, "PostVisibility", function() { return post_visibility; }); +/* concated harmony reexport PostVisibilityLabel */__webpack_require__.d(__webpack_exports__, "PostVisibilityLabel", function() { return post_visibility_label; }); +/* concated harmony reexport PostVisibilityCheck */__webpack_require__.d(__webpack_exports__, "PostVisibilityCheck", function() { return post_visibility_check; }); +/* concated harmony reexport TableOfContents */__webpack_require__.d(__webpack_exports__, "TableOfContents", function() { return table_of_contents; }); +/* concated harmony reexport UnsavedChangesWarning */__webpack_require__.d(__webpack_exports__, "UnsavedChangesWarning", function() { return unsaved_changes_warning; }); +/* concated harmony reexport WordCount */__webpack_require__.d(__webpack_exports__, "WordCount", function() { return word_count; }); +/* concated harmony reexport EditorProvider */__webpack_require__.d(__webpack_exports__, "EditorProvider", function() { return provider; }); +/* concated harmony reexport blockAutocompleter */__webpack_require__.d(__webpack_exports__, "blockAutocompleter", function() { return autocompleters_block; }); +/* concated harmony reexport userAutocompleter */__webpack_require__.d(__webpack_exports__, "userAutocompleter", function() { return autocompleters_user; }); +/* concated harmony reexport Autocomplete */__webpack_require__.d(__webpack_exports__, "Autocomplete", function() { return external_this_wp_blockEditor_["Autocomplete"]; }); +/* concated harmony reexport AlignmentToolbar */__webpack_require__.d(__webpack_exports__, "AlignmentToolbar", function() { return external_this_wp_blockEditor_["AlignmentToolbar"]; }); +/* concated harmony reexport BlockAlignmentToolbar */__webpack_require__.d(__webpack_exports__, "BlockAlignmentToolbar", function() { return external_this_wp_blockEditor_["BlockAlignmentToolbar"]; }); +/* concated harmony reexport BlockControls */__webpack_require__.d(__webpack_exports__, "BlockControls", function() { return external_this_wp_blockEditor_["BlockControls"]; }); +/* concated harmony reexport BlockEdit */__webpack_require__.d(__webpack_exports__, "BlockEdit", function() { return external_this_wp_blockEditor_["BlockEdit"]; }); +/* concated harmony reexport BlockEditorKeyboardShortcuts */__webpack_require__.d(__webpack_exports__, "BlockEditorKeyboardShortcuts", function() { return external_this_wp_blockEditor_["BlockEditorKeyboardShortcuts"]; }); +/* concated harmony reexport BlockFormatControls */__webpack_require__.d(__webpack_exports__, "BlockFormatControls", function() { return external_this_wp_blockEditor_["BlockFormatControls"]; }); +/* concated harmony reexport BlockIcon */__webpack_require__.d(__webpack_exports__, "BlockIcon", function() { return external_this_wp_blockEditor_["BlockIcon"]; }); +/* concated harmony reexport BlockInspector */__webpack_require__.d(__webpack_exports__, "BlockInspector", function() { return external_this_wp_blockEditor_["BlockInspector"]; }); +/* concated harmony reexport BlockList */__webpack_require__.d(__webpack_exports__, "BlockList", function() { return external_this_wp_blockEditor_["BlockList"]; }); +/* concated harmony reexport BlockMover */__webpack_require__.d(__webpack_exports__, "BlockMover", function() { return external_this_wp_blockEditor_["BlockMover"]; }); +/* concated harmony reexport BlockNavigationDropdown */__webpack_require__.d(__webpack_exports__, "BlockNavigationDropdown", function() { return external_this_wp_blockEditor_["BlockNavigationDropdown"]; }); +/* concated harmony reexport BlockSelectionClearer */__webpack_require__.d(__webpack_exports__, "BlockSelectionClearer", function() { return external_this_wp_blockEditor_["BlockSelectionClearer"]; }); +/* concated harmony reexport BlockSettingsMenu */__webpack_require__.d(__webpack_exports__, "BlockSettingsMenu", function() { return external_this_wp_blockEditor_["BlockSettingsMenu"]; }); +/* concated harmony reexport BlockTitle */__webpack_require__.d(__webpack_exports__, "BlockTitle", function() { return external_this_wp_blockEditor_["BlockTitle"]; }); +/* concated harmony reexport BlockToolbar */__webpack_require__.d(__webpack_exports__, "BlockToolbar", function() { return external_this_wp_blockEditor_["BlockToolbar"]; }); +/* concated harmony reexport ColorPalette */__webpack_require__.d(__webpack_exports__, "ColorPalette", function() { return external_this_wp_blockEditor_["ColorPalette"]; }); +/* concated harmony reexport ContrastChecker */__webpack_require__.d(__webpack_exports__, "ContrastChecker", function() { return external_this_wp_blockEditor_["ContrastChecker"]; }); +/* concated harmony reexport CopyHandler */__webpack_require__.d(__webpack_exports__, "CopyHandler", function() { return external_this_wp_blockEditor_["CopyHandler"]; }); +/* concated harmony reexport createCustomColorsHOC */__webpack_require__.d(__webpack_exports__, "createCustomColorsHOC", function() { return external_this_wp_blockEditor_["createCustomColorsHOC"]; }); +/* concated harmony reexport DefaultBlockAppender */__webpack_require__.d(__webpack_exports__, "DefaultBlockAppender", function() { return external_this_wp_blockEditor_["DefaultBlockAppender"]; }); +/* concated harmony reexport FontSizePicker */__webpack_require__.d(__webpack_exports__, "FontSizePicker", function() { return external_this_wp_blockEditor_["FontSizePicker"]; }); +/* concated harmony reexport getColorClassName */__webpack_require__.d(__webpack_exports__, "getColorClassName", function() { return external_this_wp_blockEditor_["getColorClassName"]; }); +/* concated harmony reexport getColorObjectByAttributeValues */__webpack_require__.d(__webpack_exports__, "getColorObjectByAttributeValues", function() { return external_this_wp_blockEditor_["getColorObjectByAttributeValues"]; }); +/* concated harmony reexport getColorObjectByColorValue */__webpack_require__.d(__webpack_exports__, "getColorObjectByColorValue", function() { return external_this_wp_blockEditor_["getColorObjectByColorValue"]; }); +/* concated harmony reexport getFontSize */__webpack_require__.d(__webpack_exports__, "getFontSize", function() { return external_this_wp_blockEditor_["getFontSize"]; }); +/* concated harmony reexport getFontSizeClass */__webpack_require__.d(__webpack_exports__, "getFontSizeClass", function() { return external_this_wp_blockEditor_["getFontSizeClass"]; }); +/* concated harmony reexport Inserter */__webpack_require__.d(__webpack_exports__, "Inserter", function() { return external_this_wp_blockEditor_["Inserter"]; }); +/* concated harmony reexport InnerBlocks */__webpack_require__.d(__webpack_exports__, "InnerBlocks", function() { return external_this_wp_blockEditor_["InnerBlocks"]; }); +/* concated harmony reexport InspectorAdvancedControls */__webpack_require__.d(__webpack_exports__, "InspectorAdvancedControls", function() { return external_this_wp_blockEditor_["InspectorAdvancedControls"]; }); +/* concated harmony reexport InspectorControls */__webpack_require__.d(__webpack_exports__, "InspectorControls", function() { return external_this_wp_blockEditor_["InspectorControls"]; }); +/* concated harmony reexport PanelColorSettings */__webpack_require__.d(__webpack_exports__, "PanelColorSettings", function() { return external_this_wp_blockEditor_["PanelColorSettings"]; }); +/* concated harmony reexport PlainText */__webpack_require__.d(__webpack_exports__, "PlainText", function() { return external_this_wp_blockEditor_["PlainText"]; }); +/* concated harmony reexport RichText */__webpack_require__.d(__webpack_exports__, "RichText", function() { return external_this_wp_blockEditor_["RichText"]; }); +/* concated harmony reexport RichTextShortcut */__webpack_require__.d(__webpack_exports__, "RichTextShortcut", function() { return external_this_wp_blockEditor_["RichTextShortcut"]; }); +/* concated harmony reexport RichTextToolbarButton */__webpack_require__.d(__webpack_exports__, "RichTextToolbarButton", function() { return external_this_wp_blockEditor_["RichTextToolbarButton"]; }); +/* concated harmony reexport RichTextInserterItem */__webpack_require__.d(__webpack_exports__, "RichTextInserterItem", function() { return external_this_wp_blockEditor_["RichTextInserterItem"]; }); +/* concated harmony reexport UnstableRichTextInputEvent */__webpack_require__.d(__webpack_exports__, "UnstableRichTextInputEvent", function() { return external_this_wp_blockEditor_["UnstableRichTextInputEvent"]; }); +/* concated harmony reexport MediaPlaceholder */__webpack_require__.d(__webpack_exports__, "MediaPlaceholder", function() { return external_this_wp_blockEditor_["MediaPlaceholder"]; }); +/* concated harmony reexport MediaUpload */__webpack_require__.d(__webpack_exports__, "MediaUpload", function() { return external_this_wp_blockEditor_["MediaUpload"]; }); +/* concated harmony reexport MediaUploadCheck */__webpack_require__.d(__webpack_exports__, "MediaUploadCheck", function() { return external_this_wp_blockEditor_["MediaUploadCheck"]; }); +/* concated harmony reexport MultiBlocksSwitcher */__webpack_require__.d(__webpack_exports__, "MultiBlocksSwitcher", function() { return external_this_wp_blockEditor_["MultiBlocksSwitcher"]; }); +/* concated harmony reexport MultiSelectScrollIntoView */__webpack_require__.d(__webpack_exports__, "MultiSelectScrollIntoView", function() { return external_this_wp_blockEditor_["MultiSelectScrollIntoView"]; }); +/* concated harmony reexport NavigableToolbar */__webpack_require__.d(__webpack_exports__, "NavigableToolbar", function() { return external_this_wp_blockEditor_["NavigableToolbar"]; }); +/* concated harmony reexport ObserveTyping */__webpack_require__.d(__webpack_exports__, "ObserveTyping", function() { return external_this_wp_blockEditor_["ObserveTyping"]; }); +/* concated harmony reexport PreserveScrollInReorder */__webpack_require__.d(__webpack_exports__, "PreserveScrollInReorder", function() { return external_this_wp_blockEditor_["PreserveScrollInReorder"]; }); +/* concated harmony reexport SkipToSelectedBlock */__webpack_require__.d(__webpack_exports__, "SkipToSelectedBlock", function() { return external_this_wp_blockEditor_["SkipToSelectedBlock"]; }); +/* concated harmony reexport URLInput */__webpack_require__.d(__webpack_exports__, "URLInput", function() { return external_this_wp_blockEditor_["URLInput"]; }); +/* concated harmony reexport URLInputButton */__webpack_require__.d(__webpack_exports__, "URLInputButton", function() { return external_this_wp_blockEditor_["URLInputButton"]; }); +/* concated harmony reexport URLPopover */__webpack_require__.d(__webpack_exports__, "URLPopover", function() { return external_this_wp_blockEditor_["URLPopover"]; }); +/* concated harmony reexport Warning */__webpack_require__.d(__webpack_exports__, "Warning", function() { return external_this_wp_blockEditor_["Warning"]; }); +/* concated harmony reexport WritingFlow */__webpack_require__.d(__webpack_exports__, "WritingFlow", function() { return external_this_wp_blockEditor_["WritingFlow"]; }); +/* concated harmony reexport withColorContext */__webpack_require__.d(__webpack_exports__, "withColorContext", function() { return external_this_wp_blockEditor_["withColorContext"]; }); +/* concated harmony reexport withColors */__webpack_require__.d(__webpack_exports__, "withColors", function() { return external_this_wp_blockEditor_["withColors"]; }); +/* concated harmony reexport withFontSizes */__webpack_require__.d(__webpack_exports__, "withFontSizes", function() { return external_this_wp_blockEditor_["withFontSizes"]; }); +/* concated harmony reexport mediaUpload */__webpack_require__.d(__webpack_exports__, "mediaUpload", function() { return media_upload; }); +/* concated harmony reexport cleanForSlug */__webpack_require__.d(__webpack_exports__, "cleanForSlug", function() { return cleanForSlug; }); +/* concated harmony reexport transformStyles */__webpack_require__.d(__webpack_exports__, "transformStyles", function() { return editor_styles; }); +/** + * WordPress dependencies + */ + + + + + + + +/** + * Internal dependencies + */ + + + + + + + + +/***/ }), + +/***/ 37: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _arrayWithHoles; }); +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +/***/ }), + +/***/ 38: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _nonIterableRest; }); +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); +} + +/***/ }), + +/***/ 4: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["components"]; }()); + +/***/ }), + +/***/ 40: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["viewport"]; }()); + +/***/ }), + +/***/ 41: +/***/ (function(module, exports, __webpack_require__) { + +module.exports = function memize( fn, options ) { + var size = 0, + maxSize, head, tail; + + if ( options && options.maxSize ) { + maxSize = options.maxSize; + } + + function memoized( /* ...args */ ) { + var node = head, + len = arguments.length, + args, i; + + searchCache: while ( node ) { + // Perform a shallow equality test to confirm that whether the node + // under test is a candidate for the arguments passed. Two arrays + // are shallowly equal if their length matches and each entry is + // strictly equal between the two sets. Avoid abstracting to a + // function which could incur an arguments leaking deoptimization. + + // Check whether node arguments match arguments length + if ( node.args.length !== arguments.length ) { + node = node.next; + continue; + } + + // Check whether node arguments match arguments values + for ( i = 0; i < len; i++ ) { + if ( node.args[ i ] !== arguments[ i ] ) { + node = node.next; + continue searchCache; + } + } + + // At this point we can assume we've found a match + + // Surface matched node to head if not already + if ( node !== head ) { + // As tail, shift to previous. Must only shift if not also + // head, since if both head and tail, there is no previous. + if ( node === tail ) { + tail = node.prev; + } + + // Adjust siblings to point to each other. If node was tail, + // this also handles new tail's empty `next` assignment. + node.prev.next = node.next; + if ( node.next ) { + node.next.prev = node.prev; + } + + node.next = head; + node.prev = null; + head.prev = node; + head = node; + } + + // Return immediately + return node.val; + } + + // No cached value found. Continue to insertion phase: + + // Create a copy of arguments (avoid leaking deoptimization) + args = new Array( len ); + for ( i = 0; i < len; i++ ) { + args[ i ] = arguments[ i ]; + } + + node = { + args: args, + + // Generate the result from original function + val: fn.apply( null, args ) + }; + + // Don't need to check whether node is already head, since it would + // have been returned above already if it was + + // Shift existing head down list + if ( head ) { + head.prev = node; + node.next = head; + } else { + // If no head, follows that there's no tail (at initial or reset) + tail = node; + } + + // Trim tail if we're reached max size and are pending cache insertion + if ( size === maxSize ) { + tail = tail.prev; + tail.next = null; + } else { + size++; + } + + head = node; + + return node.val; + } + + memoized.clear = function() { + head = null; + tail = null; + size = 0; + }; + + if ( false ) {} + + return memoized; +}; + + +/***/ }), + +/***/ 44: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _asyncToGenerator; }); +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} + +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; +} + +/***/ }), + +/***/ 49: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["deprecated"]; }()); + +/***/ }), + +/***/ 5: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["data"]; }()); + +/***/ }), + +/***/ 50: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["date"]; }()); + +/***/ }), + +/***/ 54: +/***/ (function(module, exports, __webpack_require__) { + +/** + * Copyright (c) 2014-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +// This method of obtaining a reference to the global object needs to be +// kept identical to the way it is obtained in runtime.js +var g = (function() { + return this || (typeof self === "object" && self); +})() || Function("return this")(); + +// Use `getOwnPropertyNames` because not all browsers support calling +// `hasOwnProperty` on the global `self` object in a worker. See #183. +var hadRuntime = g.regeneratorRuntime && + Object.getOwnPropertyNames(g).indexOf("regeneratorRuntime") >= 0; + +// Save the old regeneratorRuntime in case it needs to be restored later. +var oldRuntime = hadRuntime && g.regeneratorRuntime; + +// Force reevalutation of runtime.js. +g.regeneratorRuntime = undefined; + +module.exports = __webpack_require__(55); + +if (hadRuntime) { + // Restore the original runtime. + g.regeneratorRuntime = oldRuntime; +} else { + // Remove the global property added by runtime.js. + try { + delete g.regeneratorRuntime; + } catch(e) { + g.regeneratorRuntime = undefined; + } +} + + +/***/ }), + +/***/ 55: +/***/ (function(module, exports) { + +/** + * Copyright (c) 2014-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +!(function(global) { + "use strict"; + + var Op = Object.prototype; + var hasOwn = Op.hasOwnProperty; + var undefined; // More compressible than void 0. + var $Symbol = typeof Symbol === "function" ? Symbol : {}; + var iteratorSymbol = $Symbol.iterator || "@@iterator"; + var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator"; + var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; + + var inModule = typeof module === "object"; + var runtime = global.regeneratorRuntime; + if (runtime) { + if (inModule) { + // If regeneratorRuntime is defined globally and we're in a module, + // make the exports object identical to regeneratorRuntime. + module.exports = runtime; + } + // Don't bother evaluating the rest of this file if the runtime was + // already defined globally. + return; + } + + // Define the runtime globally (as expected by generated code) as either + // module.exports (if we're in a module) or a new, empty object. + runtime = global.regeneratorRuntime = inModule ? module.exports : {}; + + function wrap(innerFn, outerFn, self, tryLocsList) { + // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator. + var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator; + var generator = Object.create(protoGenerator.prototype); + var context = new Context(tryLocsList || []); + + // The ._invoke method unifies the implementations of the .next, + // .throw, and .return methods. + generator._invoke = makeInvokeMethod(innerFn, self, context); + + return generator; + } + runtime.wrap = wrap; + + // Try/catch helper to minimize deoptimizations. Returns a completion + // record like context.tryEntries[i].completion. This interface could + // have been (and was previously) designed to take a closure to be + // invoked without arguments, but in all the cases we care about we + // already have an existing method we want to call, so there's no need + // to create a new function object. We can even get away with assuming + // the method takes exactly one argument, since that happens to be true + // in every case, so we don't have to touch the arguments object. The + // only additional allocation required is the completion record, which + // has a stable shape and so hopefully should be cheap to allocate. + function tryCatch(fn, obj, arg) { + try { + return { type: "normal", arg: fn.call(obj, arg) }; + } catch (err) { + return { type: "throw", arg: err }; + } + } + + var GenStateSuspendedStart = "suspendedStart"; + var GenStateSuspendedYield = "suspendedYield"; + var GenStateExecuting = "executing"; + var GenStateCompleted = "completed"; + + // Returning this object from the innerFn has the same effect as + // breaking out of the dispatch switch statement. + var ContinueSentinel = {}; + + // Dummy constructor functions that we use as the .constructor and + // .constructor.prototype properties for functions that return Generator + // objects. For full spec compliance, you may wish to configure your + // minifier not to mangle the names of these two functions. + function Generator() {} + function GeneratorFunction() {} + function GeneratorFunctionPrototype() {} + + // This is a polyfill for %IteratorPrototype% for environments that + // don't natively support it. + var IteratorPrototype = {}; + IteratorPrototype[iteratorSymbol] = function () { + return this; + }; + + var getProto = Object.getPrototypeOf; + var NativeIteratorPrototype = getProto && getProto(getProto(values([]))); + if (NativeIteratorPrototype && + NativeIteratorPrototype !== Op && + hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) { + // This environment has a native %IteratorPrototype%; use it instead + // of the polyfill. + IteratorPrototype = NativeIteratorPrototype; + } + + var Gp = GeneratorFunctionPrototype.prototype = + Generator.prototype = Object.create(IteratorPrototype); + GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype; + GeneratorFunctionPrototype.constructor = GeneratorFunction; + GeneratorFunctionPrototype[toStringTagSymbol] = + GeneratorFunction.displayName = "GeneratorFunction"; + + // Helper for defining the .next, .throw, and .return methods of the + // Iterator interface in terms of a single ._invoke method. + function defineIteratorMethods(prototype) { + ["next", "throw", "return"].forEach(function(method) { + prototype[method] = function(arg) { + return this._invoke(method, arg); + }; + }); + } + + runtime.isGeneratorFunction = function(genFun) { + var ctor = typeof genFun === "function" && genFun.constructor; + return ctor + ? ctor === GeneratorFunction || + // For the native GeneratorFunction constructor, the best we can + // do is to check its .name property. + (ctor.displayName || ctor.name) === "GeneratorFunction" + : false; + }; + + runtime.mark = function(genFun) { + if (Object.setPrototypeOf) { + Object.setPrototypeOf(genFun, GeneratorFunctionPrototype); + } else { + genFun.__proto__ = GeneratorFunctionPrototype; + if (!(toStringTagSymbol in genFun)) { + genFun[toStringTagSymbol] = "GeneratorFunction"; + } + } + genFun.prototype = Object.create(Gp); + return genFun; + }; + + // Within the body of any async function, `await x` is transformed to + // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test + // `hasOwn.call(value, "__await")` to determine if the yielded value is + // meant to be awaited. + runtime.awrap = function(arg) { + return { __await: arg }; + }; + + function AsyncIterator(generator) { + function invoke(method, arg, resolve, reject) { + var record = tryCatch(generator[method], generator, arg); + if (record.type === "throw") { + reject(record.arg); + } else { + var result = record.arg; + var value = result.value; + if (value && + typeof value === "object" && + hasOwn.call(value, "__await")) { + return Promise.resolve(value.__await).then(function(value) { + invoke("next", value, resolve, reject); + }, function(err) { + invoke("throw", err, resolve, reject); + }); + } + + return Promise.resolve(value).then(function(unwrapped) { + // When a yielded Promise is resolved, its final value becomes + // the .value of the Promise<{value,done}> result for the + // current iteration. + result.value = unwrapped; + resolve(result); + }, function(error) { + // If a rejected Promise was yielded, throw the rejection back + // into the async generator function so it can be handled there. + return invoke("throw", error, resolve, reject); + }); + } + } + + var previousPromise; + + function enqueue(method, arg) { + function callInvokeWithMethodAndArg() { + return new Promise(function(resolve, reject) { + invoke(method, arg, resolve, reject); + }); + } + + return previousPromise = + // If enqueue has been called before, then we want to wait until + // all previous Promises have been resolved before calling invoke, + // so that results are always delivered in the correct order. If + // enqueue has not been called before, then it is important to + // call invoke immediately, without waiting on a callback to fire, + // so that the async generator function has the opportunity to do + // any necessary setup in a predictable way. This predictability + // is why the Promise constructor synchronously invokes its + // executor callback, and why async functions synchronously + // execute code before the first await. Since we implement simple + // async functions in terms of async generators, it is especially + // important to get this right, even though it requires care. + previousPromise ? previousPromise.then( + callInvokeWithMethodAndArg, + // Avoid propagating failures to Promises returned by later + // invocations of the iterator. + callInvokeWithMethodAndArg + ) : callInvokeWithMethodAndArg(); + } + + // Define the unified helper method that is used to implement .next, + // .throw, and .return (see defineIteratorMethods). + this._invoke = enqueue; + } + + defineIteratorMethods(AsyncIterator.prototype); + AsyncIterator.prototype[asyncIteratorSymbol] = function () { + return this; + }; + runtime.AsyncIterator = AsyncIterator; + + // Note that simple async functions are implemented on top of + // AsyncIterator objects; they just return a Promise for the value of + // the final result produced by the iterator. + runtime.async = function(innerFn, outerFn, self, tryLocsList) { + var iter = new AsyncIterator( + wrap(innerFn, outerFn, self, tryLocsList) + ); + + return runtime.isGeneratorFunction(outerFn) + ? iter // If outerFn is a generator, return the full iterator. + : iter.next().then(function(result) { + return result.done ? result.value : iter.next(); + }); + }; + + function makeInvokeMethod(innerFn, self, context) { + var state = GenStateSuspendedStart; + + return function invoke(method, arg) { + if (state === GenStateExecuting) { + throw new Error("Generator is already running"); + } + + if (state === GenStateCompleted) { + if (method === "throw") { + throw arg; + } + + // Be forgiving, per 25.3.3.3.3 of the spec: + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume + return doneResult(); + } + + context.method = method; + context.arg = arg; + + while (true) { + var delegate = context.delegate; + if (delegate) { + var delegateResult = maybeInvokeDelegate(delegate, context); + if (delegateResult) { + if (delegateResult === ContinueSentinel) continue; + return delegateResult; + } + } + + if (context.method === "next") { + // Setting context._sent for legacy support of Babel's + // function.sent implementation. + context.sent = context._sent = context.arg; + + } else if (context.method === "throw") { + if (state === GenStateSuspendedStart) { + state = GenStateCompleted; + throw context.arg; + } + + context.dispatchException(context.arg); + + } else if (context.method === "return") { + context.abrupt("return", context.arg); + } + + state = GenStateExecuting; + + var record = tryCatch(innerFn, self, context); + if (record.type === "normal") { + // If an exception is thrown from innerFn, we leave state === + // GenStateExecuting and loop back for another invocation. + state = context.done + ? GenStateCompleted + : GenStateSuspendedYield; + + if (record.arg === ContinueSentinel) { + continue; + } + + return { + value: record.arg, + done: context.done + }; + + } else if (record.type === "throw") { + state = GenStateCompleted; + // Dispatch the exception by looping back around to the + // context.dispatchException(context.arg) call above. + context.method = "throw"; + context.arg = record.arg; + } + } + }; + } + + // Call delegate.iterator[context.method](context.arg) and handle the + // result, either by returning a { value, done } result from the + // delegate iterator, or by modifying context.method and context.arg, + // setting context.delegate to null, and returning the ContinueSentinel. + function maybeInvokeDelegate(delegate, context) { + var method = delegate.iterator[context.method]; + if (method === undefined) { + // A .throw or .return when the delegate iterator has no .throw + // method always terminates the yield* loop. + context.delegate = null; + + if (context.method === "throw") { + if (delegate.iterator.return) { + // If the delegate iterator has a return method, give it a + // chance to clean up. + context.method = "return"; + context.arg = undefined; + maybeInvokeDelegate(delegate, context); + + if (context.method === "throw") { + // If maybeInvokeDelegate(context) changed context.method from + // "return" to "throw", let that override the TypeError below. + return ContinueSentinel; + } + } + + context.method = "throw"; + context.arg = new TypeError( + "The iterator does not provide a 'throw' method"); + } + + return ContinueSentinel; + } + + var record = tryCatch(method, delegate.iterator, context.arg); + + if (record.type === "throw") { + context.method = "throw"; + context.arg = record.arg; + context.delegate = null; + return ContinueSentinel; + } + + var info = record.arg; + + if (! info) { + context.method = "throw"; + context.arg = new TypeError("iterator result is not an object"); + context.delegate = null; + return ContinueSentinel; + } + + if (info.done) { + // Assign the result of the finished delegate to the temporary + // variable specified by delegate.resultName (see delegateYield). + context[delegate.resultName] = info.value; + + // Resume execution at the desired location (see delegateYield). + context.next = delegate.nextLoc; + + // If context.method was "throw" but the delegate handled the + // exception, let the outer generator proceed normally. If + // context.method was "next", forget context.arg since it has been + // "consumed" by the delegate iterator. If context.method was + // "return", allow the original .return call to continue in the + // outer generator. + if (context.method !== "return") { + context.method = "next"; + context.arg = undefined; + } + + } else { + // Re-yield the result returned by the delegate method. + return info; + } + + // The delegate iterator is finished, so forget it and continue with + // the outer generator. + context.delegate = null; + return ContinueSentinel; + } + + // Define Generator.prototype.{next,throw,return} in terms of the + // unified ._invoke helper method. + defineIteratorMethods(Gp); + + Gp[toStringTagSymbol] = "Generator"; + + // A Generator should always return itself as the iterator object when the + // @@iterator function is called on it. Some browsers' implementations of the + // iterator prototype chain incorrectly implement this, causing the Generator + // object to not be returned from this call. This ensures that doesn't happen. + // See https://github.com/facebook/regenerator/issues/274 for more details. + Gp[iteratorSymbol] = function() { + return this; + }; + + Gp.toString = function() { + return "[object Generator]"; + }; + + function pushTryEntry(locs) { + var entry = { tryLoc: locs[0] }; + + if (1 in locs) { + entry.catchLoc = locs[1]; + } + + if (2 in locs) { + entry.finallyLoc = locs[2]; + entry.afterLoc = locs[3]; + } + + this.tryEntries.push(entry); + } + + function resetTryEntry(entry) { + var record = entry.completion || {}; + record.type = "normal"; + delete record.arg; + entry.completion = record; + } + + function Context(tryLocsList) { + // The root entry object (effectively a try statement without a catch + // or a finally block) gives us a place to store values thrown from + // locations where there is no enclosing try statement. + this.tryEntries = [{ tryLoc: "root" }]; + tryLocsList.forEach(pushTryEntry, this); + this.reset(true); + } + + runtime.keys = function(object) { + var keys = []; + for (var key in object) { + keys.push(key); + } + keys.reverse(); + + // Rather than returning an object with a next method, we keep + // things simple and return the next function itself. + return function next() { + while (keys.length) { + var key = keys.pop(); + if (key in object) { + next.value = key; + next.done = false; + return next; + } + } + + // To avoid creating an additional object, we just hang the .value + // and .done properties off the next function object itself. This + // also ensures that the minifier will not anonymize the function. + next.done = true; + return next; + }; + }; + + function values(iterable) { + if (iterable) { + var iteratorMethod = iterable[iteratorSymbol]; + if (iteratorMethod) { + return iteratorMethod.call(iterable); + } + + if (typeof iterable.next === "function") { + return iterable; + } + + if (!isNaN(iterable.length)) { + var i = -1, next = function next() { + while (++i < iterable.length) { + if (hasOwn.call(iterable, i)) { + next.value = iterable[i]; + next.done = false; + return next; + } + } + + next.value = undefined; + next.done = true; + + return next; + }; + + return next.next = next; + } + } + + // Return an iterator with no values. + return { next: doneResult }; + } + runtime.values = values; + + function doneResult() { + return { value: undefined, done: true }; + } + + Context.prototype = { + constructor: Context, + + reset: function(skipTempReset) { + this.prev = 0; + this.next = 0; + // Resetting context._sent for legacy support of Babel's + // function.sent implementation. + this.sent = this._sent = undefined; + this.done = false; + this.delegate = null; + + this.method = "next"; + this.arg = undefined; + + this.tryEntries.forEach(resetTryEntry); + + if (!skipTempReset) { + for (var name in this) { + // Not sure about the optimal order of these conditions: + if (name.charAt(0) === "t" && + hasOwn.call(this, name) && + !isNaN(+name.slice(1))) { + this[name] = undefined; + } + } + } + }, + + stop: function() { + this.done = true; + + var rootEntry = this.tryEntries[0]; + var rootRecord = rootEntry.completion; + if (rootRecord.type === "throw") { + throw rootRecord.arg; + } + + return this.rval; + }, + + dispatchException: function(exception) { + if (this.done) { + throw exception; + } + + var context = this; + function handle(loc, caught) { + record.type = "throw"; + record.arg = exception; + context.next = loc; + + if (caught) { + // If the dispatched exception was caught by a catch block, + // then let that catch block handle the exception normally. + context.method = "next"; + context.arg = undefined; + } + + return !! caught; + } + + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + var record = entry.completion; + + if (entry.tryLoc === "root") { + // Exception thrown outside of any try block that could handle + // it, so set the completion value of the entire function to + // throw the exception. + return handle("end"); + } + + if (entry.tryLoc <= this.prev) { + var hasCatch = hasOwn.call(entry, "catchLoc"); + var hasFinally = hasOwn.call(entry, "finallyLoc"); + + if (hasCatch && hasFinally) { + if (this.prev < entry.catchLoc) { + return handle(entry.catchLoc, true); + } else if (this.prev < entry.finallyLoc) { + return handle(entry.finallyLoc); + } + + } else if (hasCatch) { + if (this.prev < entry.catchLoc) { + return handle(entry.catchLoc, true); + } + + } else if (hasFinally) { + if (this.prev < entry.finallyLoc) { + return handle(entry.finallyLoc); + } + + } else { + throw new Error("try statement without catch or finally"); + } + } + } + }, + + abrupt: function(type, arg) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc <= this.prev && + hasOwn.call(entry, "finallyLoc") && + this.prev < entry.finallyLoc) { + var finallyEntry = entry; + break; + } + } + + if (finallyEntry && + (type === "break" || + type === "continue") && + finallyEntry.tryLoc <= arg && + arg <= finallyEntry.finallyLoc) { + // Ignore the finally entry if control is not jumping to a + // location outside the try/catch block. + finallyEntry = null; + } + + var record = finallyEntry ? finallyEntry.completion : {}; + record.type = type; + record.arg = arg; + + if (finallyEntry) { + this.method = "next"; + this.next = finallyEntry.finallyLoc; + return ContinueSentinel; + } + + return this.complete(record); + }, + + complete: function(record, afterLoc) { + if (record.type === "throw") { + throw record.arg; + } + + if (record.type === "break" || + record.type === "continue") { + this.next = record.arg; + } else if (record.type === "return") { + this.rval = this.arg = record.arg; + this.method = "return"; + this.next = "end"; + } else if (record.type === "normal" && afterLoc) { + this.next = afterLoc; + } + + return ContinueSentinel; + }, + + finish: function(finallyLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.finallyLoc === finallyLoc) { + this.complete(entry.completion, entry.afterLoc); + resetTryEntry(entry); + return ContinueSentinel; + } + } + }, + + "catch": function(tryLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc === tryLoc) { + var record = entry.completion; + if (record.type === "throw") { + var thrown = record.arg; + resetTryEntry(entry); + } + return thrown; + } + } + + // The context.catch method must only be called with a location + // argument that corresponds to a known catch block. + throw new Error("illegal catch attempt"); + }, + + delegateYield: function(iterable, resultName, nextLoc) { + this.delegate = { + iterator: values(iterable), + resultName: resultName, + nextLoc: nextLoc + }; + + if (this.method === "next") { + // Deliberately forget the last sent value so that we don't + // accidentally pass it on to the delegate. + this.arg = undefined; + } + + return ContinueSentinel; + } + }; +})( + // In sloppy mode, unbound `this` refers to the global object, fallback to + // Function constructor if we're in global strict mode. That is sadly a form + // of indirect eval which violates Content Security Policy. + (function() { + return this || (typeof self === "object" && self); + })() || Function("return this")() +); + + +/***/ }), + +/***/ 57: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["htmlEntities"]; }()); + +/***/ }), + +/***/ 59: +/***/ (function(module, exports) { + +var g; + +// This works in non-strict mode +g = (function() { + return this; +})(); + +try { + // This works if eval is allowed (see CSP) + g = g || new Function("return this")(); +} catch (e) { + // This works if the window reference is available + if (typeof window === "object") g = window; +} + +// g can still be undefined, but nothing to do about it... +// We return undefined, instead of nothing here, so it's +// easier to handle this case. if(!global) { ...} + +module.exports = g; + + +/***/ }), + +/***/ 6: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["compose"]; }()); + +/***/ }), + +/***/ 60: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["nux"]; }()); + +/***/ }), + +/***/ 61: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +exports.__esModule = true; +var TextareaAutosize_1 = __webpack_require__(111); +exports["default"] = TextareaAutosize_1["default"]; + + +/***/ }), + +/***/ 62: +/***/ (function(module, exports, __webpack_require__) { + +module.exports = __webpack_require__(341); + + +/***/ }), + +/***/ 66: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["autop"]; }()); + +/***/ }), + +/***/ 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; +} + +/***/ }), + +/***/ 70: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +function flattenIntoMap( map, effects ) { + var i; + if ( Array.isArray( effects ) ) { + for ( i = 0; i < effects.length; i++ ) { + flattenIntoMap( map, effects[ i ] ); + } + } else { + for ( i in effects ) { + map[ i ] = ( map[ i ] || [] ).concat( effects[ i ] ); + } + } +} + +function refx( effects ) { + var map = {}, + middleware; + + flattenIntoMap( map, effects ); + + middleware = function( store ) { + return function( next ) { + return function( action ) { + var handlers = map[ action.type ], + result = next( action ), + i, handlerAction; + + if ( handlers ) { + for ( i = 0; i < handlers.length; i++ ) { + handlerAction = handlers[ i ]( action, store ); + if ( handlerAction ) { + store.dispatch( handlerAction ); + } + } + } + + return result; + }; + }; + }; + + middleware.effects = map; + + return middleware; +} + +module.exports = refx; + + +/***/ }), + +/***/ 72: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["coreData"]; }()); + +/***/ }), + +/***/ 8: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["blockEditor"]; }()); + +/***/ }), + +/***/ 84: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +var punycode = __webpack_require__(117); +var util = __webpack_require__(119); + +exports.parse = urlParse; +exports.resolve = urlResolve; +exports.resolveObject = urlResolveObject; +exports.format = urlFormat; + +exports.Url = Url; + +function Url() { + this.protocol = null; + this.slashes = null; + this.auth = null; + this.host = null; + this.port = null; + this.hostname = null; + this.hash = null; + this.search = null; + this.query = null; + this.pathname = null; + this.path = null; + this.href = null; +} + +// Reference: RFC 3986, RFC 1808, RFC 2396 + +// define these here so at least they only have to be +// compiled once on the first module load. +var protocolPattern = /^([a-z0-9.+-]+:)/i, + portPattern = /:[0-9]*$/, + + // Special case for a simple path URL + simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/, + + // RFC 2396: characters reserved for delimiting URLs. + // We actually just auto-escape these. + delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'], + + // RFC 2396: characters not allowed for various reasons. + unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims), + + // Allowed by RFCs, but cause of XSS attacks. Always escape these. + autoEscape = ['\''].concat(unwise), + // Characters that are never ever allowed in a hostname. + // Note that any invalid chars are also handled, but these + // are the ones that are *expected* to be seen, so we fast-path + // them. + nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape), + hostEndingChars = ['/', '?', '#'], + hostnameMaxLen = 255, + hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/, + hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/, + // protocols that can allow "unsafe" and "unwise" chars. + unsafeProtocol = { + 'javascript': true, + 'javascript:': true + }, + // protocols that never have a hostname. + hostlessProtocol = { + 'javascript': true, + 'javascript:': true + }, + // protocols that always contain a // bit. + slashedProtocol = { + 'http': true, + 'https': true, + 'ftp': true, + 'gopher': true, + 'file': true, + 'http:': true, + 'https:': true, + 'ftp:': true, + 'gopher:': true, + 'file:': true + }, + querystring = __webpack_require__(120); + +function urlParse(url, parseQueryString, slashesDenoteHost) { + if (url && util.isObject(url) && url instanceof Url) return url; + + var u = new Url; + u.parse(url, parseQueryString, slashesDenoteHost); + return u; +} + +Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) { + if (!util.isString(url)) { + throw new TypeError("Parameter 'url' must be a string, not " + typeof url); + } + + // Copy chrome, IE, opera backslash-handling behavior. + // Back slashes before the query string get converted to forward slashes + // See: https://code.google.com/p/chromium/issues/detail?id=25916 + var queryIndex = url.indexOf('?'), + splitter = + (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#', + uSplit = url.split(splitter), + slashRegex = /\\/g; + uSplit[0] = uSplit[0].replace(slashRegex, '/'); + url = uSplit.join(splitter); + + var rest = url; + + // trim before proceeding. + // This is to support parse stuff like " http://foo.com \n" + rest = rest.trim(); + + if (!slashesDenoteHost && url.split('#').length === 1) { + // Try fast path regexp + var simplePath = simplePathPattern.exec(rest); + if (simplePath) { + this.path = rest; + this.href = rest; + this.pathname = simplePath[1]; + if (simplePath[2]) { + this.search = simplePath[2]; + if (parseQueryString) { + this.query = querystring.parse(this.search.substr(1)); + } else { + this.query = this.search.substr(1); + } + } else if (parseQueryString) { + this.search = ''; + this.query = {}; + } + return this; + } + } + + var proto = protocolPattern.exec(rest); + if (proto) { + proto = proto[0]; + var lowerProto = proto.toLowerCase(); + this.protocol = lowerProto; + rest = rest.substr(proto.length); + } + + // figure out if it's got a host + // user@server is *always* interpreted as a hostname, and url + // resolution will treat //foo/bar as host=foo,path=bar because that's + // how the browser resolves relative URLs. + if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) { + var slashes = rest.substr(0, 2) === '//'; + if (slashes && !(proto && hostlessProtocol[proto])) { + rest = rest.substr(2); + this.slashes = true; + } + } + + if (!hostlessProtocol[proto] && + (slashes || (proto && !slashedProtocol[proto]))) { + + // there's a hostname. + // the first instance of /, ?, ;, or # ends the host. + // + // If there is an @ in the hostname, then non-host chars *are* allowed + // to the left of the last @ sign, unless some host-ending character + // comes *before* the @-sign. + // URLs are obnoxious. + // + // ex: + // http://a@b@c/ => user:a@b host:c + // http://a@b?@c => user:a host:c path:/?@c + + // v0.12 TODO(isaacs): This is not quite how Chrome does things. + // Review our test case against browsers more comprehensively. + + // find the first instance of any hostEndingChars + var hostEnd = -1; + for (var i = 0; i < hostEndingChars.length; i++) { + var hec = rest.indexOf(hostEndingChars[i]); + if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) + hostEnd = hec; + } + + // at this point, either we have an explicit point where the + // auth portion cannot go past, or the last @ char is the decider. + var auth, atSign; + if (hostEnd === -1) { + // atSign can be anywhere. + atSign = rest.lastIndexOf('@'); + } else { + // atSign must be in auth portion. + // http://a@b/c@d => host:b auth:a path:/c@d + atSign = rest.lastIndexOf('@', hostEnd); + } + + // Now we have a portion which is definitely the auth. + // Pull that off. + if (atSign !== -1) { + auth = rest.slice(0, atSign); + rest = rest.slice(atSign + 1); + this.auth = decodeURIComponent(auth); + } + + // the host is the remaining to the left of the first non-host char + hostEnd = -1; + for (var i = 0; i < nonHostChars.length; i++) { + var hec = rest.indexOf(nonHostChars[i]); + if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) + hostEnd = hec; + } + // if we still have not hit it, then the entire thing is a host. + if (hostEnd === -1) + hostEnd = rest.length; + + this.host = rest.slice(0, hostEnd); + rest = rest.slice(hostEnd); + + // pull out port. + this.parseHost(); + + // we've indicated that there is a hostname, + // so even if it's empty, it has to be present. + this.hostname = this.hostname || ''; + + // if hostname begins with [ and ends with ] + // assume that it's an IPv6 address. + var ipv6Hostname = this.hostname[0] === '[' && + this.hostname[this.hostname.length - 1] === ']'; + + // validate a little. + if (!ipv6Hostname) { + var hostparts = this.hostname.split(/\./); + for (var i = 0, l = hostparts.length; i < l; i++) { + var part = hostparts[i]; + if (!part) continue; + if (!part.match(hostnamePartPattern)) { + var newpart = ''; + for (var j = 0, k = part.length; j < k; j++) { + if (part.charCodeAt(j) > 127) { + // we replace non-ASCII char with a temporary placeholder + // we need this to make sure size of hostname is not + // broken by replacing non-ASCII by nothing + newpart += 'x'; + } else { + newpart += part[j]; + } + } + // we test again with ASCII char only + if (!newpart.match(hostnamePartPattern)) { + var validParts = hostparts.slice(0, i); + var notHost = hostparts.slice(i + 1); + var bit = part.match(hostnamePartStart); + if (bit) { + validParts.push(bit[1]); + notHost.unshift(bit[2]); + } + if (notHost.length) { + rest = '/' + notHost.join('.') + rest; + } + this.hostname = validParts.join('.'); + break; + } + } + } + } + + if (this.hostname.length > hostnameMaxLen) { + this.hostname = ''; + } else { + // hostnames are always lower case. + this.hostname = this.hostname.toLowerCase(); + } + + if (!ipv6Hostname) { + // IDNA Support: Returns a punycoded representation of "domain". + // It only converts parts of the domain name that + // have non-ASCII characters, i.e. it doesn't matter if + // you call it with a domain that already is ASCII-only. + this.hostname = punycode.toASCII(this.hostname); + } + + var p = this.port ? ':' + this.port : ''; + var h = this.hostname || ''; + this.host = h + p; + this.href += this.host; + + // strip [ and ] from the hostname + // the host field still retains them, though + if (ipv6Hostname) { + this.hostname = this.hostname.substr(1, this.hostname.length - 2); + if (rest[0] !== '/') { + rest = '/' + rest; + } + } + } + + // now rest is set to the post-host stuff. + // chop off any delim chars. + if (!unsafeProtocol[lowerProto]) { + + // First, make 100% sure that any "autoEscape" chars get + // escaped, even if encodeURIComponent doesn't think they + // need to be. + for (var i = 0, l = autoEscape.length; i < l; i++) { + var ae = autoEscape[i]; + if (rest.indexOf(ae) === -1) + continue; + var esc = encodeURIComponent(ae); + if (esc === ae) { + esc = escape(ae); + } + rest = rest.split(ae).join(esc); + } + } + + + // chop off from the tail first. + var hash = rest.indexOf('#'); + if (hash !== -1) { + // got a fragment string. + this.hash = rest.substr(hash); + rest = rest.slice(0, hash); + } + var qm = rest.indexOf('?'); + if (qm !== -1) { + this.search = rest.substr(qm); + this.query = rest.substr(qm + 1); + if (parseQueryString) { + this.query = querystring.parse(this.query); + } + rest = rest.slice(0, qm); + } else if (parseQueryString) { + // no query string, but parseQueryString still requested + this.search = ''; + this.query = {}; + } + if (rest) this.pathname = rest; + if (slashedProtocol[lowerProto] && + this.hostname && !this.pathname) { + this.pathname = '/'; + } + + //to support http.request + if (this.pathname || this.search) { + var p = this.pathname || ''; + var s = this.search || ''; + this.path = p + s; + } + + // finally, reconstruct the href based on what has been validated. + this.href = this.format(); + return this; +}; + +// format a parsed object into a url string +function urlFormat(obj) { + // ensure it's an object, and not a string url. + // If it's an obj, this is a no-op. + // this way, you can call url_format() on strings + // to clean up potentially wonky urls. + if (util.isString(obj)) obj = urlParse(obj); + if (!(obj instanceof Url)) return Url.prototype.format.call(obj); + return obj.format(); +} + +Url.prototype.format = function() { + var auth = this.auth || ''; + if (auth) { + auth = encodeURIComponent(auth); + auth = auth.replace(/%3A/i, ':'); + auth += '@'; + } + + var protocol = this.protocol || '', + pathname = this.pathname || '', + hash = this.hash || '', + host = false, + query = ''; + + if (this.host) { + host = auth + this.host; + } else if (this.hostname) { + host = auth + (this.hostname.indexOf(':') === -1 ? + this.hostname : + '[' + this.hostname + ']'); + if (this.port) { + host += ':' + this.port; + } + } + + if (this.query && + util.isObject(this.query) && + Object.keys(this.query).length) { + query = querystring.stringify(this.query); + } + + var search = this.search || (query && ('?' + query)) || ''; + + if (protocol && protocol.substr(-1) !== ':') protocol += ':'; + + // only the slashedProtocols get the //. Not mailto:, xmpp:, etc. + // unless they had them to begin with. + if (this.slashes || + (!protocol || slashedProtocol[protocol]) && host !== false) { + host = '//' + (host || ''); + if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname; + } else if (!host) { + host = ''; + } + + if (hash && hash.charAt(0) !== '#') hash = '#' + hash; + if (search && search.charAt(0) !== '?') search = '?' + search; + + pathname = pathname.replace(/[?#]/g, function(match) { + return encodeURIComponent(match); + }); + search = search.replace('#', '%23'); + + return protocol + host + pathname + search + hash; +}; + +function urlResolve(source, relative) { + return urlParse(source, false, true).resolve(relative); +} + +Url.prototype.resolve = function(relative) { + return this.resolveObject(urlParse(relative, false, true)).format(); +}; + +function urlResolveObject(source, relative) { + if (!source) return relative; + return urlParse(source, false, true).resolveObject(relative); +} + +Url.prototype.resolveObject = function(relative) { + if (util.isString(relative)) { + var rel = new Url(); + rel.parse(relative, false, true); + relative = rel; + } + + var result = new Url(); + var tkeys = Object.keys(this); + for (var tk = 0; tk < tkeys.length; tk++) { + var tkey = tkeys[tk]; + result[tkey] = this[tkey]; + } + + // hash is always overridden, no matter what. + // even href="" will remove it. + result.hash = relative.hash; + + // if the relative url is empty, then there's nothing left to do here. + if (relative.href === '') { + result.href = result.format(); + return result; + } + + // hrefs like //foo/bar always cut to the protocol. + if (relative.slashes && !relative.protocol) { + // take everything except the protocol from relative + var rkeys = Object.keys(relative); + for (var rk = 0; rk < rkeys.length; rk++) { + var rkey = rkeys[rk]; + if (rkey !== 'protocol') + result[rkey] = relative[rkey]; + } + + //urlParse appends trailing / to urls like http://www.example.com + if (slashedProtocol[result.protocol] && + result.hostname && !result.pathname) { + result.path = result.pathname = '/'; + } + + result.href = result.format(); + return result; + } + + if (relative.protocol && relative.protocol !== result.protocol) { + // if it's a known url protocol, then changing + // the protocol does weird things + // first, if it's not file:, then we MUST have a host, + // and if there was a path + // to begin with, then we MUST have a path. + // if it is file:, then the host is dropped, + // because that's known to be hostless. + // anything else is assumed to be absolute. + if (!slashedProtocol[relative.protocol]) { + var keys = Object.keys(relative); + for (var v = 0; v < keys.length; v++) { + var k = keys[v]; + result[k] = relative[k]; + } + result.href = result.format(); + return result; + } + + result.protocol = relative.protocol; + if (!relative.host && !hostlessProtocol[relative.protocol]) { + var relPath = (relative.pathname || '').split('/'); + while (relPath.length && !(relative.host = relPath.shift())); + if (!relative.host) relative.host = ''; + if (!relative.hostname) relative.hostname = ''; + if (relPath[0] !== '') relPath.unshift(''); + if (relPath.length < 2) relPath.unshift(''); + result.pathname = relPath.join('/'); + } else { + result.pathname = relative.pathname; + } + result.search = relative.search; + result.query = relative.query; + result.host = relative.host || ''; + result.auth = relative.auth; + result.hostname = relative.hostname || relative.host; + result.port = relative.port; + // to support http.request + if (result.pathname || result.search) { + var p = result.pathname || ''; + var s = result.search || ''; + result.path = p + s; + } + result.slashes = result.slashes || relative.slashes; + result.href = result.format(); + return result; + } + + var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'), + isRelAbs = ( + relative.host || + relative.pathname && relative.pathname.charAt(0) === '/' + ), + mustEndAbs = (isRelAbs || isSourceAbs || + (result.host && relative.pathname)), + removeAllDots = mustEndAbs, + srcPath = result.pathname && result.pathname.split('/') || [], + relPath = relative.pathname && relative.pathname.split('/') || [], + psychotic = result.protocol && !slashedProtocol[result.protocol]; + + // if the url is a non-slashed url, then relative + // links like ../.. should be able + // to crawl up to the hostname, as well. This is strange. + // result.protocol has already been set by now. + // Later on, put the first path part into the host field. + if (psychotic) { + result.hostname = ''; + result.port = null; + if (result.host) { + if (srcPath[0] === '') srcPath[0] = result.host; + else srcPath.unshift(result.host); + } + result.host = ''; + if (relative.protocol) { + relative.hostname = null; + relative.port = null; + if (relative.host) { + if (relPath[0] === '') relPath[0] = relative.host; + else relPath.unshift(relative.host); + } + relative.host = null; + } + mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === ''); + } + + if (isRelAbs) { + // it's absolute. + result.host = (relative.host || relative.host === '') ? + relative.host : result.host; + result.hostname = (relative.hostname || relative.hostname === '') ? + relative.hostname : result.hostname; + result.search = relative.search; + result.query = relative.query; + srcPath = relPath; + // fall through to the dot-handling below. + } else if (relPath.length) { + // it's relative + // throw away the existing file, and take the new path instead. + if (!srcPath) srcPath = []; + srcPath.pop(); + srcPath = srcPath.concat(relPath); + result.search = relative.search; + result.query = relative.query; + } else if (!util.isNullOrUndefined(relative.search)) { + // just pull out the search. + // like href='?foo'. + // Put this after the other two cases because it simplifies the booleans + if (psychotic) { + result.hostname = result.host = srcPath.shift(); + //occationaly the auth can get stuck only in host + //this especially happens in cases like + //url.resolveObject('mailto:local1@domain1', 'local2@domain2') + var authInHost = result.host && result.host.indexOf('@') > 0 ? + result.host.split('@') : false; + if (authInHost) { + result.auth = authInHost.shift(); + result.host = result.hostname = authInHost.shift(); + } + } + result.search = relative.search; + result.query = relative.query; + //to support http.request + if (!util.isNull(result.pathname) || !util.isNull(result.search)) { + result.path = (result.pathname ? result.pathname : '') + + (result.search ? result.search : ''); + } + result.href = result.format(); + return result; + } + + if (!srcPath.length) { + // no path at all. easy. + // we've already handled the other stuff above. + result.pathname = null; + //to support http.request + if (result.search) { + result.path = '/' + result.search; + } else { + result.path = null; + } + result.href = result.format(); + return result; + } + + // if a url ENDs in . or .., then it must get a trailing slash. + // however, if it ends in anything else non-slashy, + // then it must NOT get a trailing slash. + var last = srcPath.slice(-1)[0]; + var hasTrailingSlash = ( + (result.host || relative.host || srcPath.length > 1) && + (last === '.' || last === '..') || last === ''); + + // strip single dots, resolve double dots to parent dir + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = srcPath.length; i >= 0; i--) { + last = srcPath[i]; + if (last === '.') { + srcPath.splice(i, 1); + } else if (last === '..') { + srcPath.splice(i, 1); + up++; + } else if (up) { + srcPath.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (!mustEndAbs && !removeAllDots) { + for (; up--; up) { + srcPath.unshift('..'); + } + } + + if (mustEndAbs && srcPath[0] !== '' && + (!srcPath[0] || srcPath[0].charAt(0) !== '/')) { + srcPath.unshift(''); + } + + if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) { + srcPath.push(''); + } + + var isAbsolute = srcPath[0] === '' || + (srcPath[0] && srcPath[0].charAt(0) === '/'); + + // put the host back + if (psychotic) { + result.hostname = result.host = isAbsolute ? '' : + srcPath.length ? srcPath.shift() : ''; + //occationaly the auth can get stuck only in host + //this especially happens in cases like + //url.resolveObject('mailto:local1@domain1', 'local2@domain2') + var authInHost = result.host && result.host.indexOf('@') > 0 ? + result.host.split('@') : false; + if (authInHost) { + result.auth = authInHost.shift(); + result.host = result.hostname = authInHost.shift(); + } + } + + mustEndAbs = mustEndAbs || (result.host && srcPath.length); + + if (mustEndAbs && !isAbsolute) { + srcPath.unshift(''); + } + + if (!srcPath.length) { + result.pathname = null; + result.path = null; + } else { + result.pathname = srcPath.join('/'); + } + + //to support request.http + if (!util.isNull(result.pathname) || !util.isNull(result.search)) { + result.path = (result.pathname ? result.pathname : '') + + (result.search ? result.search : ''); + } + result.auth = relative.auth || result.auth; + result.slashes = result.slashes || relative.slashes; + result.href = result.format(); + return result; +}; + +Url.prototype.parseHost = function() { + var host = this.host; + var port = portPattern.exec(host); + if (port) { + port = port[0]; + if (port !== ':') { + this.port = port.substr(1); + } + host = host.substr(0, host.length - port.length); + } + if (host) this.hostname = host; +}; + + +/***/ }), + +/***/ 89: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + + +var ReactPropTypesSecret = __webpack_require__(90); + +function emptyFunction() {} + +module.exports = function() { + function shim(props, propName, componentName, location, propFullName, secret) { + if (secret === ReactPropTypesSecret) { + // It is still safe when called from React. + return; + } + var err = new Error( + 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + + 'Use PropTypes.checkPropTypes() to call them. ' + + 'Read more at http://fb.me/use-check-prop-types' + ); + err.name = 'Invariant Violation'; + throw err; + }; + shim.isRequired = shim; + function getShim() { + return shim; + }; + // Important! + // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. + var ReactPropTypes = { + array: shim, + bool: shim, + func: shim, + number: shim, + object: shim, + string: shim, + symbol: shim, + + any: shim, + arrayOf: getShim, + element: shim, + instanceOf: getShim, + node: shim, + objectOf: getShim, + oneOf: getShim, + oneOfType: getShim, + shape: getShim, + exact: getShim + }; + + ReactPropTypes.checkPropTypes = emptyFunction; + ReactPropTypes.PropTypes = ReactPropTypes; + + return ReactPropTypes; +}; + + +/***/ }), + +/***/ 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; +} + +/***/ }), + +/***/ 90: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + + +var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; + +module.exports = ReactPropTypesSecret; + + +/***/ }), + +/***/ 97: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); +/** + * Redux dispatch multiple actions + */ + +function multi(_ref) { + var dispatch = _ref.dispatch; + + return function (next) { + return function (action) { + return Array.isArray(action) ? action.filter(Boolean).map(dispatch) : next(action); + }; + }; +} + +/** + * Exports + */ + +exports.default = multi; + +/***/ }), + +/***/ 98: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["wordcount"]; }()); + +/***/ }) + +/******/ }); \ No newline at end of file