diff options
Diffstat (limited to 'srcs/wordpress/wp-includes/js/dist/block-editor.js')
| -rw-r--r-- | srcs/wordpress/wp-includes/js/dist/block-editor.js | 28170 |
1 files changed, 28170 insertions, 0 deletions
diff --git a/srcs/wordpress/wp-includes/js/dist/block-editor.js b/srcs/wordpress/wp-includes/js/dist/block-editor.js new file mode 100644 index 0000000..9c456c8 --- /dev/null +++ b/srcs/wordpress/wp-includes/js/dist/block-editor.js @@ -0,0 +1,28170 @@ +this["wp"] = this["wp"] || {}; this["wp"]["blockEditor"] = +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 342); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 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 _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; +} + +/***/ }), + +/***/ 11: +/***/ (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; +} + +/***/ }), + +/***/ 112: +/***/ (function(module, exports) { + +if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + if (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) { + if (superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } + } +} + + +/***/ }), + +/***/ 113: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var util = __webpack_require__(114); + +function scrollIntoView(elem, container, config) { + config = config || {}; + // document 归一化到 window + if (container.nodeType === 9) { + container = util.getWindow(container); + } + + var allowHorizontalScroll = config.allowHorizontalScroll; + var onlyScrollIfNeeded = config.onlyScrollIfNeeded; + var alignWithTop = config.alignWithTop; + var alignWithLeft = config.alignWithLeft; + var offsetTop = config.offsetTop || 0; + var offsetLeft = config.offsetLeft || 0; + var offsetBottom = config.offsetBottom || 0; + var offsetRight = config.offsetRight || 0; + + allowHorizontalScroll = allowHorizontalScroll === undefined ? true : allowHorizontalScroll; + + var isWin = util.isWindow(container); + var elemOffset = util.offset(elem); + var eh = util.outerHeight(elem); + var ew = util.outerWidth(elem); + var containerOffset = undefined; + var ch = undefined; + var cw = undefined; + var containerScroll = undefined; + var diffTop = undefined; + var diffBottom = undefined; + var win = undefined; + var winScroll = undefined; + var ww = undefined; + var wh = undefined; + + if (isWin) { + win = container; + wh = util.height(win); + ww = util.width(win); + winScroll = { + left: util.scrollLeft(win), + top: util.scrollTop(win) + }; + // elem 相对 container 可视视窗的距离 + diffTop = { + left: elemOffset.left - winScroll.left - offsetLeft, + top: elemOffset.top - winScroll.top - offsetTop + }; + diffBottom = { + left: elemOffset.left + ew - (winScroll.left + ww) + offsetRight, + top: elemOffset.top + eh - (winScroll.top + wh) + offsetBottom + }; + containerScroll = winScroll; + } else { + containerOffset = util.offset(container); + ch = container.clientHeight; + cw = container.clientWidth; + containerScroll = { + left: container.scrollLeft, + top: container.scrollTop + }; + // elem 相对 container 可视视窗的距离 + // 注意边框, offset 是边框到根节点 + diffTop = { + left: elemOffset.left - (containerOffset.left + (parseFloat(util.css(container, 'borderLeftWidth')) || 0)) - offsetLeft, + top: elemOffset.top - (containerOffset.top + (parseFloat(util.css(container, 'borderTopWidth')) || 0)) - offsetTop + }; + diffBottom = { + left: elemOffset.left + ew - (containerOffset.left + cw + (parseFloat(util.css(container, 'borderRightWidth')) || 0)) + offsetRight, + top: elemOffset.top + eh - (containerOffset.top + ch + (parseFloat(util.css(container, 'borderBottomWidth')) || 0)) + offsetBottom + }; + } + + if (diffTop.top < 0 || diffBottom.top > 0) { + // 强制向上 + if (alignWithTop === true) { + util.scrollTop(container, containerScroll.top + diffTop.top); + } else if (alignWithTop === false) { + util.scrollTop(container, containerScroll.top + diffBottom.top); + } else { + // 自动调整 + if (diffTop.top < 0) { + util.scrollTop(container, containerScroll.top + diffTop.top); + } else { + util.scrollTop(container, containerScroll.top + diffBottom.top); + } + } + } else { + if (!onlyScrollIfNeeded) { + alignWithTop = alignWithTop === undefined ? true : !!alignWithTop; + if (alignWithTop) { + util.scrollTop(container, containerScroll.top + diffTop.top); + } else { + util.scrollTop(container, containerScroll.top + diffBottom.top); + } + } + } + + if (allowHorizontalScroll) { + if (diffTop.left < 0 || diffBottom.left > 0) { + // 强制向上 + if (alignWithLeft === true) { + util.scrollLeft(container, containerScroll.left + diffTop.left); + } else if (alignWithLeft === false) { + util.scrollLeft(container, containerScroll.left + diffBottom.left); + } else { + // 自动调整 + if (diffTop.left < 0) { + util.scrollLeft(container, containerScroll.left + diffTop.left); + } else { + util.scrollLeft(container, containerScroll.left + diffBottom.left); + } + } + } else { + if (!onlyScrollIfNeeded) { + alignWithLeft = alignWithLeft === undefined ? true : !!alignWithLeft; + if (alignWithLeft) { + util.scrollLeft(container, containerScroll.left + diffTop.left); + } else { + util.scrollLeft(container, containerScroll.left + diffBottom.left); + } + } + } + } +} + +module.exports = scrollIntoView; + +/***/ }), + +/***/ 114: +/***/ (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; }; + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; }; + +var RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source; + +function getClientPosition(elem) { + var box = undefined; + var x = undefined; + var y = undefined; + var doc = elem.ownerDocument; + var body = doc.body; + var docElem = doc && doc.documentElement; + // 根据 GBS 最新数据，A-Grade Browsers 都已支持 getBoundingClientRect 方法，不用再考虑传统的实现方式 + box = elem.getBoundingClientRect(); + + // 注：jQuery 还考虑减去 docElem.clientLeft/clientTop + // 但测试发现，这样反而会导致当 html 和 body 有边距/边框样式时，获取的值不正确 + // 此外，ie6 会忽略 html 的 margin 值，幸运地是没有谁会去设置 html 的 margin + + x = box.left; + y = box.top; + + // In IE, most of the time, 2 extra pixels are added to the top and left + // due to the implicit 2-pixel inset border. In IE6/7 quirks mode and + // IE6 standards mode, this border can be overridden by setting the + // document element's border to zero -- thus, we cannot rely on the + // offset always being 2 pixels. + + // In quirks mode, the offset can be determined by querying the body's + // clientLeft/clientTop, but in standards mode, it is found by querying + // the document element's clientLeft/clientTop. Since we already called + // getClientBoundingRect we have already forced a reflow, so it is not + // too expensive just to query them all. + + // ie 下应该减去窗口的边框吧，毕竟默认 absolute 都是相对窗口定位的 + // 窗口边框标准是设 documentElement ,quirks 时设置 body + // 最好禁止在 body 和 html 上边框 ，但 ie < 9 html 默认有 2px ，减去 + // 但是非 ie 不可能设置窗口边框，body html 也不是窗口 ,ie 可以通过 html,body 设置 + // 标准 ie 下 docElem.clientTop 就是 border-top + // ie7 html 即窗口边框改变不了。永远为 2 + // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框，即使设了 border-top 也为 0 + + x -= docElem.clientLeft || body.clientLeft || 0; + y -= docElem.clientTop || body.clientTop || 0; + + return { + left: x, + top: y + }; +} + +function getScroll(w, top) { + var ret = w['page' + (top ? 'Y' : 'X') + 'Offset']; + var method = 'scroll' + (top ? 'Top' : 'Left'); + if (typeof ret !== 'number') { + var d = w.document; + // ie6,7,8 standard mode + ret = d.documentElement[method]; + if (typeof ret !== 'number') { + // quirks mode + ret = d.body[method]; + } + } + return ret; +} + +function getScrollLeft(w) { + return getScroll(w); +} + +function getScrollTop(w) { + return getScroll(w, true); +} + +function getOffset(el) { + var pos = getClientPosition(el); + var doc = el.ownerDocument; + var w = doc.defaultView || doc.parentWindow; + pos.left += getScrollLeft(w); + pos.top += getScrollTop(w); + return pos; +} +function _getComputedStyle(elem, name, computedStyle_) { + var val = ''; + var d = elem.ownerDocument; + var computedStyle = computedStyle_ || d.defaultView.getComputedStyle(elem, null); + + // https://github.com/kissyteam/kissy/issues/61 + if (computedStyle) { + val = computedStyle.getPropertyValue(name) || computedStyle[name]; + } + + return val; +} + +var _RE_NUM_NO_PX = new RegExp('^(' + RE_NUM + ')(?!px)[a-z%]+$', 'i'); +var RE_POS = /^(top|right|bottom|left)$/; +var CURRENT_STYLE = 'currentStyle'; +var RUNTIME_STYLE = 'runtimeStyle'; +var LEFT = 'left'; +var PX = 'px'; + +function _getComputedStyleIE(elem, name) { + // currentStyle maybe null + // http://msdn.microsoft.com/en-us/library/ms535231.aspx + var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name]; + + // 当 width/height 设置为百分比时，通过 pixelLeft 方式转换的 width/height 值 + // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19 + // 在 ie 下不对，需要直接用 offset 方式 + // borderWidth 等值也有问题，但考虑到 borderWidth 设为百分比的概率很小，这里就不考虑了 + + // From the awesome hack by Dean Edwards + // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 + // If we're not dealing with a regular pixel number + // but a number that has a weird ending, we need to convert it to pixels + // exclude left right for relativity + if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) { + // Remember the original values + var style = elem.style; + var left = style[LEFT]; + var rsLeft = elem[RUNTIME_STYLE][LEFT]; + + // prevent flashing of content + elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT]; + + // Put in the new values to get a computed value out + style[LEFT] = name === 'fontSize' ? '1em' : ret || 0; + ret = style.pixelLeft + PX; + + // Revert the changed values + style[LEFT] = left; + + elem[RUNTIME_STYLE][LEFT] = rsLeft; + } + return ret === '' ? 'auto' : ret; +} + +var getComputedStyleX = undefined; +if (typeof window !== 'undefined') { + getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE; +} + +function each(arr, fn) { + for (var i = 0; i < arr.length; i++) { + fn(arr[i]); + } +} + +function isBorderBoxFn(elem) { + return getComputedStyleX(elem, 'boxSizing') === 'border-box'; +} + +var BOX_MODELS = ['margin', 'border', 'padding']; +var CONTENT_INDEX = -1; +var PADDING_INDEX = 2; +var BORDER_INDEX = 1; +var MARGIN_INDEX = 0; + +function swap(elem, options, callback) { + var old = {}; + var style = elem.style; + var name = undefined; + + // Remember the old values, and insert the new ones + for (name in options) { + if (options.hasOwnProperty(name)) { + old[name] = style[name]; + style[name] = options[name]; + } + } + + callback.call(elem); + + // Revert the old values + for (name in options) { + if (options.hasOwnProperty(name)) { + style[name] = old[name]; + } + } +} + +function getPBMWidth(elem, props, which) { + var value = 0; + var prop = undefined; + var j = undefined; + var i = undefined; + for (j = 0; j < props.length; j++) { + prop = props[j]; + if (prop) { + for (i = 0; i < which.length; i++) { + var cssProp = undefined; + if (prop === 'border') { + cssProp = prop + which[i] + 'Width'; + } else { + cssProp = prop + which[i]; + } + value += parseFloat(getComputedStyleX(elem, cssProp)) || 0; + } + } + } + return value; +} + +/** + * A crude way of determining if an object is a window + * @member util + */ +function isWindow(obj) { + // must use == for ie8 + /* eslint eqeqeq:0 */ + return obj != null && obj == obj.window; +} + +var domUtils = {}; + +each(['Width', 'Height'], function (name) { + domUtils['doc' + name] = function (refWin) { + var d = refWin.document; + return Math.max( + // firefox chrome documentElement.scrollHeight< body.scrollHeight + // ie standard mode : documentElement.scrollHeight> body.scrollHeight + d.documentElement['scroll' + name], + // quirks : documentElement.scrollHeight 最大等于可视窗口多一点？ + d.body['scroll' + name], domUtils['viewport' + name](d)); + }; + + domUtils['viewport' + name] = function (win) { + // pc browser includes scrollbar in window.innerWidth + var prop = 'client' + name; + var doc = win.document; + var body = doc.body; + var documentElement = doc.documentElement; + var documentElementProp = documentElement[prop]; + // 标准模式取 documentElement + // backcompat 取 body + return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp; + }; +}); + +/* + 得到元素的大小信息 + @param elem + @param name + @param {String} [extra] 'padding' : (css width) + padding + 'border' : (css width) + padding + border + 'margin' : (css width) + padding + border + margin + */ +function getWH(elem, name, extra) { + if (isWindow(elem)) { + return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem); + } else if (elem.nodeType === 9) { + return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem); + } + var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom']; + var borderBoxValue = name === 'width' ? elem.offsetWidth : elem.offsetHeight; + var computedStyle = getComputedStyleX(elem); + var isBorderBox = isBorderBoxFn(elem, computedStyle); + var cssBoxValue = 0; + if (borderBoxValue == null || borderBoxValue <= 0) { + borderBoxValue = undefined; + // Fall back to computed then un computed css if necessary + cssBoxValue = getComputedStyleX(elem, name); + if (cssBoxValue == null || Number(cssBoxValue) < 0) { + cssBoxValue = elem.style[name] || 0; + } + // Normalize '', auto, and prepare for extra + cssBoxValue = parseFloat(cssBoxValue) || 0; + } + if (extra === undefined) { + extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX; + } + var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox; + var val = borderBoxValue || cssBoxValue; + if (extra === CONTENT_INDEX) { + if (borderBoxValueOrIsBorderBox) { + return val - getPBMWidth(elem, ['border', 'padding'], which, computedStyle); + } + return cssBoxValue; + } + if (borderBoxValueOrIsBorderBox) { + var padding = extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which, computedStyle) : getPBMWidth(elem, ['margin'], which, computedStyle); + return val + (extra === BORDER_INDEX ? 0 : padding); + } + return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which, computedStyle); +} + +var cssShow = { + position: 'absolute', + visibility: 'hidden', + display: 'block' +}; + +// fix #119 : https://github.com/kissyteam/kissy/issues/119 +function getWHIgnoreDisplay(elem) { + var val = undefined; + var args = arguments; + // in case elem is window + // elem.offsetWidth === undefined + if (elem.offsetWidth !== 0) { + val = getWH.apply(undefined, args); + } else { + swap(elem, cssShow, function () { + val = getWH.apply(undefined, args); + }); + } + return val; +} + +function css(el, name, v) { + var value = v; + if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') { + for (var i in name) { + if (name.hasOwnProperty(i)) { + css(el, i, name[i]); + } + } + return undefined; + } + if (typeof value !== 'undefined') { + if (typeof value === 'number') { + value += 'px'; + } + el.style[name] = value; + return undefined; + } + return getComputedStyleX(el, name); +} + +each(['width', 'height'], function (name) { + var first = name.charAt(0).toUpperCase() + name.slice(1); + domUtils['outer' + first] = function (el, includeMargin) { + return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX); + }; + var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom']; + + domUtils[name] = function (elem, val) { + if (val !== undefined) { + if (elem) { + var computedStyle = getComputedStyleX(elem); + var isBorderBox = isBorderBoxFn(elem); + if (isBorderBox) { + val += getPBMWidth(elem, ['padding', 'border'], which, computedStyle); + } + return css(elem, name, val); + } + return undefined; + } + return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX); + }; +}); + +// 设置 elem 相对 elem.ownerDocument 的坐标 +function setOffset(elem, offset) { + // set position first, in-case top/left are set even on static elem + if (css(elem, 'position') === 'static') { + elem.style.position = 'relative'; + } + + var old = getOffset(elem); + var ret = {}; + var current = undefined; + var key = undefined; + + for (key in offset) { + if (offset.hasOwnProperty(key)) { + current = parseFloat(css(elem, key)) || 0; + ret[key] = current + offset[key] - old[key]; + } + } + css(elem, ret); +} + +module.exports = _extends({ + getWindow: function getWindow(node) { + var doc = node.ownerDocument || node; + return doc.defaultView || doc.parentWindow; + }, + offset: function offset(el, value) { + if (typeof value !== 'undefined') { + setOffset(el, value); + } else { + return getOffset(el); + } + }, + + isWindow: isWindow, + each: each, + css: css, + clone: function clone(obj) { + var ret = {}; + for (var i in obj) { + if (obj.hasOwnProperty(i)) { + ret[i] = obj[i]; + } + } + var overflow = obj.overflow; + if (overflow) { + for (var i in obj) { + if (obj.hasOwnProperty(i)) { + ret.overflow[i] = obj.overflow[i]; + } + } + } + return ret; + }, + scrollLeft: function scrollLeft(w, v) { + if (isWindow(w)) { + if (v === undefined) { + return getScrollLeft(w); + } + window.scrollTo(v, getScrollTop(w)); + } else { + if (v === undefined) { + return w.scrollLeft; + } + w.scrollLeft = v; + } + }, + scrollTop: function scrollTop(w, v) { + if (isWindow(w)) { + if (v === undefined) { + return getScrollTop(w); + } + window.scrollTo(getScrollLeft(w), v); + } else { + if (v === undefined) { + return w.scrollTop; + } + w.scrollTop = v; + } + }, + + viewportWidth: 0, + viewportHeight: 0 +}, domUtils); + +/***/ }), + +/***/ 115: +/***/ (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__(28); +var PropTypes = __webpack_require__(33); +var autosize = __webpack_require__(116); +var _getLineHeight = __webpack_require__(117); +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; + + +/***/ }), + +/***/ 116: +/***/ (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']; +}); + +/***/ }), + +/***/ 117: +/***/ (function(module, exports, __webpack_require__) { + +// Load in dependencies +var computedStyle = __webpack_require__(118); + +/** + * 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; + + +/***/ }), + +/***/ 118: +/***/ (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; + + +/***/ }), + +/***/ 119: +/***/ (function(module, exports) { + +function _extends() { + module.exports = _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); +} + +module.exports = _extends; + +/***/ }), + +/***/ 12: +/***/ (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"); + } +} + +/***/ }), + +/***/ 120: +/***/ (function(module, exports) { + +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; +} + +module.exports = _objectWithoutPropertiesLoose; + +/***/ }), + +/***/ 121: +/***/ (function(module, exports) { + +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; +} + +module.exports = _inheritsLoose; + +/***/ }), + +/***/ 122: +/***/ (function(module, exports) { + +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +module.exports = _assertThisInitialized; + +/***/ }), + +/***/ 123: +/***/ (function(module, exports, __webpack_require__) { + +/* WEBPACK VAR INJECTION */(function(module, global) {var __WEBPACK_AMD_DEFINE_RESULT__;/*! https://mths.be/punycode v1.3.2 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 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 <https://mathiasbynens.be/notes/javascript-encoding> + * @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. + * http://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 <n,i> state to <m,0>, + // 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.3.2', + /** + * An object of methods to convert from JavaScript's internal character + * representation (UCS-2) to Unicode code points, and back. + * @see <https://mathiasbynens.be/notes/javascript-encoding> + * @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__(124)(module), __webpack_require__(65))) + +/***/ }), + +/***/ 124: +/***/ (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; +}; + + +/***/ }), + +/***/ 125: +/***/ (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; + } +}; + + +/***/ }), + +/***/ 126: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +exports.decode = exports.parse = __webpack_require__(127); +exports.encode = exports.stringify = __webpack_require__(128); + + +/***/ }), + +/***/ 127: +/***/ (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]'; +}; + + +/***/ }), + +/***/ 128: +/***/ (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"; +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _possibleConstructorReturn; }); +/* harmony import */ var _helpers_esm_typeof__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(31); +/* harmony import */ var _assertThisInitialized__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5); + + +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); +} + +/***/ }), + +/***/ 14: +/***/ (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); +} + +/***/ }), + +/***/ 143: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["tokenList"]; }()); + +/***/ }), + +/***/ 15: +/***/ (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); +} + +/***/ }), + +/***/ 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__(30); + +// 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, __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); +} + +/***/ }), + +/***/ 19: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["keycodes"]; }()); + +/***/ }), + +/***/ 2: +/***/ (function(module, exports) { + +(function() { module.exports = this["lodash"]; }()); + +/***/ }), + +/***/ 20: +/***/ (function(module, exports, __webpack_require__) { + +module.exports = __webpack_require__(47); + + +/***/ }), + +/***/ 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; +} + +/***/ }), + +/***/ 218: +/***/ (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; + +/***/ }), + +/***/ 219: +/***/ (function(module, exports, __webpack_require__) { + +/*! + + diff v3.5.0 + +Software License Agreement (BSD License) + +Copyright (c) 2009-2015, Kevin Decker <kpdecker@gmail.com> + +All rights reserved. + +Redistribution and use of this software in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of Kevin Decker nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER +IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +@license +*/ +(function webpackUniversalModuleDefinition(root, factory) { + if(true) + module.exports = factory(); + else {} +})(this, function() { +return /******/ (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] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = 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; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.canonicalize = exports.convertChangesToXML = exports.convertChangesToDMP = exports.merge = exports.parsePatch = exports.applyPatches = exports.applyPatch = exports.createPatch = exports.createTwoFilesPatch = exports.structuredPatch = exports.diffArrays = exports.diffJson = exports.diffCss = exports.diffSentences = exports.diffTrimmedLines = exports.diffLines = exports.diffWordsWithSpace = exports.diffWords = exports.diffChars = exports.Diff = undefined; + + /*istanbul ignore end*/var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_character = __webpack_require__(2) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_word = __webpack_require__(3) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_line = __webpack_require__(5) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_sentence = __webpack_require__(6) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_css = __webpack_require__(7) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_json = __webpack_require__(8) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_array = __webpack_require__(9) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_apply = __webpack_require__(10) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_parse = __webpack_require__(11) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_merge = __webpack_require__(13) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_create = __webpack_require__(14) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_dmp = __webpack_require__(16) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_xml = __webpack_require__(17) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /* See LICENSE file for terms of use */ + + /* + * Text diff implementation. + * + * This library supports the following APIS: + * JsDiff.diffChars: Character by character diff + * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace + * JsDiff.diffLines: Line based diff + * + * JsDiff.diffCss: Diff targeted at CSS content + * + * These methods are based on the implementation proposed in + * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986). + * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927 + */ + exports. /*istanbul ignore end*/Diff = _base2['default']; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffChars = _character.diffChars; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffWords = _word.diffWords; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = _word.diffWordsWithSpace; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffLines = _line.diffLines; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = _line.diffTrimmedLines; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffSentences = _sentence.diffSentences; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffCss = _css.diffCss; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffJson = _json.diffJson; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffArrays = _array.diffArrays; + /*istanbul ignore start*/exports. /*istanbul ignore end*/structuredPatch = _create.structuredPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = _create.createTwoFilesPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = _create.createPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatch = _apply.applyPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = _apply.applyPatches; + /*istanbul ignore start*/exports. /*istanbul ignore end*/parsePatch = _parse.parsePatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/merge = _merge.merge; + /*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToDMP = _dmp.convertChangesToDMP; + /*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToXML = _xml.convertChangesToXML; + /*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = _json.canonicalize; + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 1 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports['default'] = /*istanbul ignore end*/Diff; + function Diff() {} + + Diff.prototype = { + /*istanbul ignore start*/ /*istanbul ignore end*/diff: function diff(oldString, newString) { + /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + var callback = options.callback; + if (typeof options === 'function') { + callback = options; + options = {}; + } + this.options = options; + + var self = this; + + function done(value) { + if (callback) { + setTimeout(function () { + callback(undefined, value); + }, 0); + return true; + } else { + return value; + } + } + + // Allow subclasses to massage the input prior to running + oldString = this.castInput(oldString); + newString = this.castInput(newString); + + oldString = this.removeEmpty(this.tokenize(oldString)); + newString = this.removeEmpty(this.tokenize(newString)); + + var newLen = newString.length, + oldLen = oldString.length; + var editLength = 1; + var maxEditLength = newLen + oldLen; + var bestPath = [{ newPos: -1, components: [] }]; + + // Seed editLength = 0, i.e. the content starts with the same values + var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { + // Identity per the equality and tokenizer + return done([{ value: this.join(newString), count: newString.length }]); + } + + // Main worker method. checks all permutations of a given edit length for acceptance. + function execEditLength() { + for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { + var basePath = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + var addPath = bestPath[diagonalPath - 1], + removePath = bestPath[diagonalPath + 1], + _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; + if (addPath) { + // No one else is going to attempt to use this value, clear it + bestPath[diagonalPath - 1] = undefined; + } + + var canAdd = addPath && addPath.newPos + 1 < newLen, + canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; + if (!canAdd && !canRemove) { + // If this path is a terminal then prune + bestPath[diagonalPath] = undefined; + continue; + } + + // Select the diagonal that we want to branch from. We select the prior + // path whose position in the new string is the farthest from the origin + // and does not pass the bounds of the diff graph + if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { + basePath = clonePath(removePath); + self.pushComponent(basePath.components, undefined, true); + } else { + basePath = addPath; // No need to clone, we've pulled it from the list + basePath.newPos++; + self.pushComponent(basePath.components, true, undefined); + } + + _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); + + // If we have hit the end of both strings, then we are done + if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { + return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken)); + } else { + // Otherwise track this path as a potential candidate and continue. + bestPath[diagonalPath] = basePath; + } + } + + editLength++; + } + + // Performs the length of edit iteration. Is a bit fugly as this has to support the + // sync and async mode which is never fun. Loops over execEditLength until a value + // is produced. + if (callback) { + (function exec() { + setTimeout(function () { + // This should not happen, but we want to be safe. + /* istanbul ignore next */ + if (editLength > maxEditLength) { + return callback(); + } + + if (!execEditLength()) { + exec(); + } + }, 0); + })(); + } else { + while (editLength <= maxEditLength) { + var ret = execEditLength(); + if (ret) { + return ret; + } + } + } + }, + /*istanbul ignore start*/ /*istanbul ignore end*/pushComponent: function pushComponent(components, added, removed) { + var last = components[components.length - 1]; + if (last && last.added === added && last.removed === removed) { + // We need to clone here as the component clone operation is just + // as shallow array clone + components[components.length - 1] = { count: last.count + 1, added: added, removed: removed }; + } else { + components.push({ count: 1, added: added, removed: removed }); + } + }, + /*istanbul ignore start*/ /*istanbul ignore end*/extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { + var newLen = newString.length, + oldLen = oldString.length, + newPos = basePath.newPos, + oldPos = newPos - diagonalPath, + commonCount = 0; + while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { + newPos++; + oldPos++; + commonCount++; + } + + if (commonCount) { + basePath.components.push({ count: commonCount }); + } + + basePath.newPos = newPos; + return oldPos; + }, + /*istanbul ignore start*/ /*istanbul ignore end*/equals: function equals(left, right) { + if (this.options.comparator) { + return this.options.comparator(left, right); + } else { + return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase(); + } + }, + /*istanbul ignore start*/ /*istanbul ignore end*/removeEmpty: function removeEmpty(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + if (array[i]) { + ret.push(array[i]); + } + } + return ret; + }, + /*istanbul ignore start*/ /*istanbul ignore end*/castInput: function castInput(value) { + return value; + }, + /*istanbul ignore start*/ /*istanbul ignore end*/tokenize: function tokenize(value) { + return value.split(''); + }, + /*istanbul ignore start*/ /*istanbul ignore end*/join: function join(chars) { + return chars.join(''); + } + }; + + function buildValues(diff, components, newString, oldString, useLongestToken) { + var componentPos = 0, + componentLen = components.length, + newPos = 0, + oldPos = 0; + + for (; componentPos < componentLen; componentPos++) { + var component = components[componentPos]; + if (!component.removed) { + if (!component.added && useLongestToken) { + var value = newString.slice(newPos, newPos + component.count); + value = value.map(function (value, i) { + var oldValue = oldString[oldPos + i]; + return oldValue.length > value.length ? oldValue : value; + }); + + component.value = diff.join(value); + } else { + component.value = diff.join(newString.slice(newPos, newPos + component.count)); + } + newPos += component.count; + + // Common case + if (!component.added) { + oldPos += component.count; + } + } else { + component.value = diff.join(oldString.slice(oldPos, oldPos + component.count)); + oldPos += component.count; + + // Reverse add and remove so removes are output first to match common convention + // The diffing algorithm is tied to add then remove output and this is the simplest + // route to get the desired output with minimal overhead. + if (componentPos && components[componentPos - 1].added) { + var tmp = components[componentPos - 1]; + components[componentPos - 1] = components[componentPos]; + components[componentPos] = tmp; + } + } + } + + // Special case handle for when one terminal is ignored (i.e. whitespace). + // For this case we merge the terminal into the prior string and drop the change. + // This is only available for string mode. + var lastComponent = components[componentLen - 1]; + if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) { + components[componentLen - 2].value += lastComponent.value; + components.pop(); + } + + return components; + } + + function clonePath(path) { + return { newPos: path.newPos, components: path.components.slice(0) }; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/diff/base.js"],"names":["Diff","prototype","diff","oldString","newString","options","callback","self","done","value","setTimeout","undefined","castInput","removeEmpty","tokenize","newLen","length","oldLen","editLength","maxEditLength","bestPath","newPos","components","oldPos","extractCommon","join","count","execEditLength","diagonalPath","basePath","addPath","removePath","canAdd","canRemove","clonePath","pushComponent","buildValues","useLongestToken","exec","ret","added","removed","last","push","commonCount","equals","left","right","comparator","ignoreCase","toLowerCase","array","i","split","chars","componentPos","componentLen","component","slice","map","oldValue","tmp","lastComponent","pop","path"],"mappings":";;;4CAAwBA,I;AAAT,SAASA,IAAT,GAAgB,CAAE;;AAEjCA,KAAKC,SAAL,GAAiB;AAAA,mDACfC,IADe,gBACVC,SADU,EACCC,SADD,EAC0B;AAAA,wDAAdC,OAAc,uEAAJ,EAAI;;AACvC,QAAIC,WAAWD,QAAQC,QAAvB;AACA,QAAI,OAAOD,OAAP,KAAmB,UAAvB,EAAmC;AACjCC,iBAAWD,OAAX;AACAA,gBAAU,EAAV;AACD;AACD,SAAKA,OAAL,GAAeA,OAAf;;AAEA,QAAIE,OAAO,IAAX;;AAEA,aAASC,IAAT,CAAcC,KAAd,EAAqB;AACnB,UAAIH,QAAJ,EAAc;AACZI,mBAAW,YAAW;AAAEJ,mBAASK,SAAT,EAAoBF,KAApB;AAA6B,SAArD,EAAuD,CAAvD;AACA,eAAO,IAAP;AACD,OAHD,MAGO;AACL,eAAOA,KAAP;AACD;AACF;;AAED;AACAN,gBAAY,KAAKS,SAAL,CAAeT,SAAf,CAAZ;AACAC,gBAAY,KAAKQ,SAAL,CAAeR,SAAf,CAAZ;;AAEAD,gBAAY,KAAKU,WAAL,CAAiB,KAAKC,QAAL,CAAcX,SAAd,CAAjB,CAAZ;AACAC,gBAAY,KAAKS,WAAL,CAAiB,KAAKC,QAAL,CAAcV,SAAd,CAAjB,CAAZ;;AAEA,QAAIW,SAASX,UAAUY,MAAvB;AAAA,QAA+BC,SAASd,UAAUa,MAAlD;AACA,QAAIE,aAAa,CAAjB;AACA,QAAIC,gBAAgBJ,SAASE,MAA7B;AACA,QAAIG,WAAW,CAAC,EAAEC,QAAQ,CAAC,CAAX,EAAcC,YAAY,EAA1B,EAAD,CAAf;;AAEA;AACA,QAAIC,SAAS,KAAKC,aAAL,CAAmBJ,SAAS,CAAT,CAAnB,EAAgChB,SAAhC,EAA2CD,SAA3C,EAAsD,CAAtD,CAAb;AACA,QAAIiB,SAAS,CAAT,EAAYC,MAAZ,GAAqB,CAArB,IAA0BN,MAA1B,IAAoCQ,SAAS,CAAT,IAAcN,MAAtD,EAA8D;AAC5D;AACA,aAAOT,KAAK,CAAC,EAACC,OAAO,KAAKgB,IAAL,CAAUrB,SAAV,CAAR,EAA8BsB,OAAOtB,UAAUY,MAA/C,EAAD,CAAL,CAAP;AACD;;AAED;AACA,aAASW,cAAT,GAA0B;AACxB,WAAK,IAAIC,eAAe,CAAC,CAAD,GAAKV,UAA7B,EAAyCU,gBAAgBV,UAAzD,EAAqEU,gBAAgB,CAArF,EAAwF;AACtF,YAAIC,0CAAJ;AACA,YAAIC,UAAUV,SAASQ,eAAe,CAAxB,CAAd;AAAA,YACIG,aAAaX,SAASQ,eAAe,CAAxB,CADjB;AAAA,YAEIL,UAAS,CAACQ,aAAaA,WAAWV,MAAxB,GAAiC,CAAlC,IAAuCO,YAFpD;AAGA,YAAIE,OAAJ,EAAa;AACX;AACAV,mBAASQ,eAAe,CAAxB,IAA6BjB,SAA7B;AACD;;AAED,YAAIqB,SAASF,WAAWA,QAAQT,MAAR,GAAiB,CAAjB,GAAqBN,MAA7C;AAAA,YACIkB,YAAYF,cAAc,KAAKR,OAAnB,IAA6BA,UAASN,MADtD;AAEA,YAAI,CAACe,MAAD,IAAW,CAACC,SAAhB,EAA2B;AACzB;AACAb,mBAASQ,YAAT,IAAyBjB,SAAzB;AACA;AACD;;AAED;AACA;AACA;AACA,YAAI,CAACqB,MAAD,IAAYC,aAAaH,QAAQT,MAAR,GAAiBU,WAAWV,MAAzD,EAAkE;AAChEQ,qBAAWK,UAAUH,UAAV,CAAX;AACAxB,eAAK4B,aAAL,CAAmBN,SAASP,UAA5B,EAAwCX,SAAxC,EAAmD,IAAnD;AACD,SAHD,MAGO;AACLkB,qBAAWC,OAAX,CADK,CACiB;AACtBD,mBAASR,MAAT;AACAd,eAAK4B,aAAL,CAAmBN,SAASP,UAA5B,EAAwC,IAAxC,EAA8CX,SAA9C;AACD;;AAEDY,kBAAShB,KAAKiB,aAAL,CAAmBK,QAAnB,EAA6BzB,SAA7B,EAAwCD,SAAxC,EAAmDyB,YAAnD,CAAT;;AAEA;AACA,YAAIC,SAASR,MAAT,GAAkB,CAAlB,IAAuBN,MAAvB,IAAiCQ,UAAS,CAAT,IAAcN,MAAnD,EAA2D;AACzD,iBAAOT,KAAK4B,YAAY7B,IAAZ,EAAkBsB,SAASP,UAA3B,EAAuClB,SAAvC,EAAkDD,SAAlD,EAA6DI,KAAK8B,eAAlE,CAAL,CAAP;AACD,SAFD,MAEO;AACL;AACAjB,mBAASQ,YAAT,IAAyBC,QAAzB;AACD;AACF;;AAEDX;AACD;;AAED;AACA;AACA;AACA,QAAIZ,QAAJ,EAAc;AACX,gBAASgC,IAAT,GAAgB;AACf5B,mBAAW,YAAW;AACpB;AACA;AACA,cAAIQ,aAAaC,aAAjB,EAAgC;AAC9B,mBAAOb,UAAP;AACD;;AAED,cAAI,CAACqB,gBAAL,EAAuB;AACrBW;AACD;AACF,SAVD,EAUG,CAVH;AAWD,OAZA,GAAD;AAaD,KAdD,MAcO;AACL,aAAOpB,cAAcC,aAArB,EAAoC;AAClC,YAAIoB,MAAMZ,gBAAV;AACA,YAAIY,GAAJ,EAAS;AACP,iBAAOA,GAAP;AACD;AACF;AACF;AACF,GA9Gc;AAAA,mDAgHfJ,aAhHe,yBAgHDb,UAhHC,EAgHWkB,KAhHX,EAgHkBC,OAhHlB,EAgH2B;AACxC,QAAIC,OAAOpB,WAAWA,WAAWN,MAAX,GAAoB,CAA/B,CAAX;AACA,QAAI0B,QAAQA,KAAKF,KAAL,KAAeA,KAAvB,IAAgCE,KAAKD,OAAL,KAAiBA,OAArD,EAA8D;AAC5D;AACA;AACAnB,iBAAWA,WAAWN,MAAX,GAAoB,CAA/B,IAAoC,EAACU,OAAOgB,KAAKhB,KAAL,GAAa,CAArB,EAAwBc,OAAOA,KAA/B,EAAsCC,SAASA,OAA/C,EAApC;AACD,KAJD,MAIO;AACLnB,iBAAWqB,IAAX,CAAgB,EAACjB,OAAO,CAAR,EAAWc,OAAOA,KAAlB,EAAyBC,SAASA,OAAlC,EAAhB;AACD;AACF,GAzHc;AAAA,mDA0HfjB,aA1He,yBA0HDK,QA1HC,EA0HSzB,SA1HT,EA0HoBD,SA1HpB,EA0H+ByB,YA1H/B,EA0H6C;AAC1D,QAAIb,SAASX,UAAUY,MAAvB;AAAA,QACIC,SAASd,UAAUa,MADvB;AAAA,QAEIK,SAASQ,SAASR,MAFtB;AAAA,QAGIE,SAASF,SAASO,YAHtB;AAAA,QAKIgB,cAAc,CALlB;AAMA,WAAOvB,SAAS,CAAT,GAAaN,MAAb,IAAuBQ,SAAS,CAAT,GAAaN,MAApC,IAA8C,KAAK4B,MAAL,CAAYzC,UAAUiB,SAAS,CAAnB,CAAZ,EAAmClB,UAAUoB,SAAS,CAAnB,CAAnC,CAArD,EAAgH;AAC9GF;AACAE;AACAqB;AACD;;AAED,QAAIA,WAAJ,EAAiB;AACff,eAASP,UAAT,CAAoBqB,IAApB,CAAyB,EAACjB,OAAOkB,WAAR,EAAzB;AACD;;AAEDf,aAASR,MAAT,GAAkBA,MAAlB;AACA,WAAOE,MAAP;AACD,GA7Ic;AAAA,mDA+IfsB,MA/Ie,kBA+IRC,IA/IQ,EA+IFC,KA/IE,EA+IK;AAClB,QAAI,KAAK1C,OAAL,CAAa2C,UAAjB,EAA6B;AAC3B,aAAO,KAAK3C,OAAL,CAAa2C,UAAb,CAAwBF,IAAxB,EAA8BC,KAA9B,CAAP;AACD,KAFD,MAEO;AACL,aAAOD,SAASC,KAAT,IACD,KAAK1C,OAAL,CAAa4C,UAAb,IAA2BH,KAAKI,WAAL,OAAuBH,MAAMG,WAAN,EADxD;AAED;AACF,GAtJc;AAAA,mDAuJfrC,WAvJe,uBAuJHsC,KAvJG,EAuJI;AACjB,QAAIZ,MAAM,EAAV;AACA,SAAK,IAAIa,IAAI,CAAb,EAAgBA,IAAID,MAAMnC,MAA1B,EAAkCoC,GAAlC,EAAuC;AACrC,UAAID,MAAMC,CAAN,CAAJ,EAAc;AACZb,YAAII,IAAJ,CAASQ,MAAMC,CAAN,CAAT;AACD;AACF;AACD,WAAOb,GAAP;AACD,GA/Jc;AAAA,mDAgKf3B,SAhKe,qBAgKLH,KAhKK,EAgKE;AACf,WAAOA,KAAP;AACD,GAlKc;AAAA,mDAmKfK,QAnKe,oBAmKNL,KAnKM,EAmKC;AACd,WAAOA,MAAM4C,KAAN,CAAY,EAAZ,CAAP;AACD,GArKc;AAAA,mDAsKf5B,IAtKe,gBAsKV6B,KAtKU,EAsKH;AACV,WAAOA,MAAM7B,IAAN,CAAW,EAAX,CAAP;AACD;AAxKc,CAAjB;;AA2KA,SAASW,WAAT,CAAqBlC,IAArB,EAA2BoB,UAA3B,EAAuClB,SAAvC,EAAkDD,SAAlD,EAA6DkC,eAA7D,EAA8E;AAC5E,MAAIkB,eAAe,CAAnB;AAAA,MACIC,eAAelC,WAAWN,MAD9B;AAAA,MAEIK,SAAS,CAFb;AAAA,MAGIE,SAAS,CAHb;;AAKA,SAAOgC,eAAeC,YAAtB,EAAoCD,cAApC,EAAoD;AAClD,QAAIE,YAAYnC,WAAWiC,YAAX,CAAhB;AACA,QAAI,CAACE,UAAUhB,OAAf,EAAwB;AACtB,UAAI,CAACgB,UAAUjB,KAAX,IAAoBH,eAAxB,EAAyC;AACvC,YAAI5B,QAAQL,UAAUsD,KAAV,CAAgBrC,MAAhB,EAAwBA,SAASoC,UAAU/B,KAA3C,CAAZ;AACAjB,gBAAQA,MAAMkD,GAAN,CAAU,UAASlD,KAAT,EAAgB2C,CAAhB,EAAmB;AACnC,cAAIQ,WAAWzD,UAAUoB,SAAS6B,CAAnB,CAAf;AACA,iBAAOQ,SAAS5C,MAAT,GAAkBP,MAAMO,MAAxB,GAAiC4C,QAAjC,GAA4CnD,KAAnD;AACD,SAHO,CAAR;;AAKAgD,kBAAUhD,KAAV,GAAkBP,KAAKuB,IAAL,CAAUhB,KAAV,CAAlB;AACD,OARD,MAQO;AACLgD,kBAAUhD,KAAV,GAAkBP,KAAKuB,IAAL,CAAUrB,UAAUsD,KAAV,CAAgBrC,MAAhB,EAAwBA,SAASoC,UAAU/B,KAA3C,CAAV,CAAlB;AACD;AACDL,gBAAUoC,UAAU/B,KAApB;;AAEA;AACA,UAAI,CAAC+B,UAAUjB,KAAf,EAAsB;AACpBjB,kBAAUkC,UAAU/B,KAApB;AACD;AACF,KAlBD,MAkBO;AACL+B,gBAAUhD,KAAV,GAAkBP,KAAKuB,IAAL,CAAUtB,UAAUuD,KAAV,CAAgBnC,MAAhB,EAAwBA,SAASkC,UAAU/B,KAA3C,CAAV,CAAlB;AACAH,gBAAUkC,UAAU/B,KAApB;;AAEA;AACA;AACA;AACA,UAAI6B,gBAAgBjC,WAAWiC,eAAe,CAA1B,EAA6Bf,KAAjD,EAAwD;AACtD,YAAIqB,MAAMvC,WAAWiC,eAAe,CAA1B,CAAV;AACAjC,mBAAWiC,eAAe,CAA1B,IAA+BjC,WAAWiC,YAAX,CAA/B;AACAjC,mBAAWiC,YAAX,IAA2BM,GAA3B;AACD;AACF;AACF;;AAED;AACA;AACA;AACA,MAAIC,gBAAgBxC,WAAWkC,eAAe,CAA1B,CAApB;AACA,MAAIA,eAAe,CAAf,IACG,OAAOM,cAAcrD,KAArB,KAA+B,QADlC,KAEIqD,cAActB,KAAd,IAAuBsB,cAAcrB,OAFzC,KAGGvC,KAAK2C,MAAL,CAAY,EAAZ,EAAgBiB,cAAcrD,KAA9B,CAHP,EAG6C;AAC3Ca,eAAWkC,eAAe,CAA1B,EAA6B/C,KAA7B,IAAsCqD,cAAcrD,KAApD;AACAa,eAAWyC,GAAX;AACD;;AAED,SAAOzC,UAAP;AACD;;AAED,SAASY,SAAT,CAAmB8B,IAAnB,EAAyB;AACvB,SAAO,EAAE3C,QAAQ2C,KAAK3C,MAAf,EAAuBC,YAAY0C,KAAK1C,UAAL,CAAgBoC,KAAhB,CAAsB,CAAtB,CAAnC,EAAP;AACD","file":"base.js","sourcesContent":["export default function Diff() {}\n\nDiff.prototype = {\n  diff(oldString, newString, options = {}) {\n    let callback = options.callback;\n    if (typeof options === 'function') {\n      callback = options;\n      options = {};\n    }\n    this.options = options;\n\n    let self = this;\n\n    function done(value) {\n      if (callback) {\n        setTimeout(function() { callback(undefined, value); }, 0);\n        return true;\n      } else {\n        return value;\n      }\n    }\n\n    // Allow subclasses to massage the input prior to running\n    oldString = this.castInput(oldString);\n    newString = this.castInput(newString);\n\n    oldString = this.removeEmpty(this.tokenize(oldString));\n    newString = this.removeEmpty(this.tokenize(newString));\n\n    let newLen = newString.length, oldLen = oldString.length;\n    let editLength = 1;\n    let maxEditLength = newLen + oldLen;\n    let bestPath = [{ newPos: -1, components: [] }];\n\n    // Seed editLength = 0, i.e. the content starts with the same values\n    let oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);\n    if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n      // Identity per the equality and tokenizer\n      return done([{value: this.join(newString), count: newString.length}]);\n    }\n\n    // Main worker method. checks all permutations of a given edit length for acceptance.\n    function execEditLength() {\n      for (let diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {\n        let basePath;\n        let addPath = bestPath[diagonalPath - 1],\n            removePath = bestPath[diagonalPath + 1],\n            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;\n        if (addPath) {\n          // No one else is going to attempt to use this value, clear it\n          bestPath[diagonalPath - 1] = undefined;\n        }\n\n        let canAdd = addPath && addPath.newPos + 1 < newLen,\n            canRemove = removePath && 0 <= oldPos && oldPos < oldLen;\n        if (!canAdd && !canRemove) {\n          // If this path is a terminal then prune\n          bestPath[diagonalPath] = undefined;\n          continue;\n        }\n\n        // Select the diagonal that we want to branch from. We select the prior\n        // path whose position in the new string is the farthest from the origin\n        // and does not pass the bounds of the diff graph\n        if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {\n          basePath = clonePath(removePath);\n          self.pushComponent(basePath.components, undefined, true);\n        } else {\n          basePath = addPath;   // No need to clone, we've pulled it from the list\n          basePath.newPos++;\n          self.pushComponent(basePath.components, true, undefined);\n        }\n\n        oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath);\n\n        // If we have hit the end of both strings, then we are done\n        if (basePath.newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n          return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));\n        } else {\n          // Otherwise track this path as a potential candidate and continue.\n          bestPath[diagonalPath] = basePath;\n        }\n      }\n\n      editLength++;\n    }\n\n    // Performs the length of edit iteration. Is a bit fugly as this has to support the\n    // sync and async mode which is never fun. Loops over execEditLength until a value\n    // is produced.\n    if (callback) {\n      (function exec() {\n        setTimeout(function() {\n          // This should not happen, but we want to be safe.\n          /* istanbul ignore next */\n          if (editLength > maxEditLength) {\n            return callback();\n          }\n\n          if (!execEditLength()) {\n            exec();\n          }\n        }, 0);\n      }());\n    } else {\n      while (editLength <= maxEditLength) {\n        let ret = execEditLength();\n        if (ret) {\n          return ret;\n        }\n      }\n    }\n  },\n\n  pushComponent(components, added, removed) {\n    let last = components[components.length - 1];\n    if (last && last.added === added && last.removed === removed) {\n      // We need to clone here as the component clone operation is just\n      // as shallow array clone\n      components[components.length - 1] = {count: last.count + 1, added: added, removed: removed };\n    } else {\n      components.push({count: 1, added: added, removed: removed });\n    }\n  },\n  extractCommon(basePath, newString, oldString, diagonalPath) {\n    let newLen = newString.length,\n        oldLen = oldString.length,\n        newPos = basePath.newPos,\n        oldPos = newPos - diagonalPath,\n\n        commonCount = 0;\n    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {\n      newPos++;\n      oldPos++;\n      commonCount++;\n    }\n\n    if (commonCount) {\n      basePath.components.push({count: commonCount});\n    }\n\n    basePath.newPos = newPos;\n    return oldPos;\n  },\n\n  equals(left, right) {\n    if (this.options.comparator) {\n      return this.options.comparator(left, right);\n    } else {\n      return left === right\n        || (this.options.ignoreCase && left.toLowerCase() === right.toLowerCase());\n    }\n  },\n  removeEmpty(array) {\n    let ret = [];\n    for (let i = 0; i < array.length; i++) {\n      if (array[i]) {\n        ret.push(array[i]);\n      }\n    }\n    return ret;\n  },\n  castInput(value) {\n    return value;\n  },\n  tokenize(value) {\n    return value.split('');\n  },\n  join(chars) {\n    return chars.join('');\n  }\n};\n\nfunction buildValues(diff, components, newString, oldString, useLongestToken) {\n  let componentPos = 0,\n      componentLen = components.length,\n      newPos = 0,\n      oldPos = 0;\n\n  for (; componentPos < componentLen; componentPos++) {\n    let component = components[componentPos];\n    if (!component.removed) {\n      if (!component.added && useLongestToken) {\n        let value = newString.slice(newPos, newPos + component.count);\n        value = value.map(function(value, i) {\n          let oldValue = oldString[oldPos + i];\n          return oldValue.length > value.length ? oldValue : value;\n        });\n\n        component.value = diff.join(value);\n      } else {\n        component.value = diff.join(newString.slice(newPos, newPos + component.count));\n      }\n      newPos += component.count;\n\n      // Common case\n      if (!component.added) {\n        oldPos += component.count;\n      }\n    } else {\n      component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));\n      oldPos += component.count;\n\n      // Reverse add and remove so removes are output first to match common convention\n      // The diffing algorithm is tied to add then remove output and this is the simplest\n      // route to get the desired output with minimal overhead.\n      if (componentPos && components[componentPos - 1].added) {\n        let tmp = components[componentPos - 1];\n        components[componentPos - 1] = components[componentPos];\n        components[componentPos] = tmp;\n      }\n    }\n  }\n\n  // Special case handle for when one terminal is ignored (i.e. whitespace).\n  // For this case we merge the terminal into the prior string and drop the change.\n  // This is only available for string mode.\n  let lastComponent = components[componentLen - 1];\n  if (componentLen > 1\n      && typeof lastComponent.value === 'string'\n      && (lastComponent.added || lastComponent.removed)\n      && diff.equals('', lastComponent.value)) {\n    components[componentLen - 2].value += lastComponent.value;\n    components.pop();\n  }\n\n  return components;\n}\n\nfunction clonePath(path) {\n  return { newPos: path.newPos, components: path.components.slice(0) };\n}\n"]} + + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.characterDiff = undefined; + exports. /*istanbul ignore end*/diffChars = diffChars; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var characterDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/characterDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + function diffChars(oldStr, newStr, options) { + return characterDiff.diff(oldStr, newStr, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2NoYXJhY3Rlci5qcyJdLCJuYW1lcyI6WyJkaWZmQ2hhcnMiLCJjaGFyYWN0ZXJEaWZmIiwib2xkU3RyIiwibmV3U3RyIiwib3B0aW9ucyIsImRpZmYiXSwibWFwcGluZ3MiOiI7Ozs7Z0NBR2dCQSxTLEdBQUFBLFM7O0FBSGhCOzs7Ozs7dUJBRU8sSUFBTUMseUZBQWdCLHdFQUF0QjtBQUNBLFNBQVNELFNBQVQsQ0FBbUJFLE1BQW5CLEVBQTJCQyxNQUEzQixFQUFtQ0MsT0FBbkMsRUFBNEM7QUFBRSxTQUFPSCxjQUFjSSxJQUFkLENBQW1CSCxNQUFuQixFQUEyQkMsTUFBM0IsRUFBbUNDLE9BQW5DLENBQVA7QUFBcUQiLCJmaWxlIjoiY2hhcmFjdGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IERpZmYgZnJvbSAnLi9iYXNlJztcblxuZXhwb3J0IGNvbnN0IGNoYXJhY3RlckRpZmYgPSBuZXcgRGlmZigpO1xuZXhwb3J0IGZ1bmN0aW9uIGRpZmZDaGFycyhvbGRTdHIsIG5ld1N0ciwgb3B0aW9ucykgeyByZXR1cm4gY2hhcmFjdGVyRGlmZi5kaWZmKG9sZFN0ciwgbmV3U3RyLCBvcHRpb25zKTsgfVxuIl19 + + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.wordDiff = undefined; + exports. /*istanbul ignore end*/diffWords = diffWords; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = diffWordsWithSpace; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_params = __webpack_require__(4) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/ // Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode + // + // Ranges and exceptions: + // Latin-1 Supplement, 0080–00FF + // - U+00D7 × Multiplication sign + // - U+00F7 ÷ Division sign + // Latin Extended-A, 0100–017F + // Latin Extended-B, 0180–024F + // IPA Extensions, 0250–02AF + // Spacing Modifier Letters, 02B0–02FF + // - U+02C7 ˇ ˇ Caron + // - U+02D8 ˘ ˘ Breve + // - U+02D9 ˙ ˙ Dot Above + // - U+02DA ˚ ˚ Ring Above + // - U+02DB ˛ ˛ Ogonek + // - U+02DC ˜ ˜ Small Tilde + // - U+02DD ˝ ˝ Double Acute Accent + // Latin Extended Additional, 1E00–1EFF + var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/; + + var reWhitespace = /\S/; + + var wordDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/wordDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + wordDiff.equals = function (left, right) { + if (this.options.ignoreCase) { + left = left.toLowerCase(); + right = right.toLowerCase(); + } + return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right); + }; + wordDiff.tokenize = function (value) { + var tokens = value.split(/(\s+|\b)/); + + // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set. + for (var i = 0; i < tokens.length - 1; i++) { + // If we have an empty string in the next field and we have only word chars before and after, merge + if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) { + tokens[i] += tokens[i + 2]; + tokens.splice(i + 1, 2); + i--; + } + } + + return tokens; + }; + + function diffWords(oldStr, newStr, options) { + options = /*istanbul ignore start*/(0, _params.generateOptions) /*istanbul ignore end*/(options, { ignoreWhitespace: true }); + return wordDiff.diff(oldStr, newStr, options); + } + + function diffWordsWithSpace(oldStr, newStr, options) { + return wordDiff.diff(oldStr, newStr, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 4 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/generateOptions = generateOptions; + function generateOptions(options, defaults) { + if (typeof options === 'function') { + defaults.callback = options; + } else if (options) { + for (var name in options) { + /* istanbul ignore else */ + if (options.hasOwnProperty(name)) { + defaults[name] = options[name]; + } + } + } + return defaults; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL3BhcmFtcy5qcyJdLCJuYW1lcyI6WyJnZW5lcmF0ZU9wdGlvbnMiLCJvcHRpb25zIiwiZGVmYXVsdHMiLCJjYWxsYmFjayIsIm5hbWUiLCJoYXNPd25Qcm9wZXJ0eSJdLCJtYXBwaW5ncyI6Ijs7O2dDQUFnQkEsZSxHQUFBQSxlO0FBQVQsU0FBU0EsZUFBVCxDQUF5QkMsT0FBekIsRUFBa0NDLFFBQWxDLEVBQTRDO0FBQ2pELE1BQUksT0FBT0QsT0FBUCxLQUFtQixVQUF2QixFQUFtQztBQUNqQ0MsYUFBU0MsUUFBVCxHQUFvQkYsT0FBcEI7QUFDRCxHQUZELE1BRU8sSUFBSUEsT0FBSixFQUFhO0FBQ2xCLFNBQUssSUFBSUcsSUFBVCxJQUFpQkgsT0FBakIsRUFBMEI7QUFDeEI7QUFDQSxVQUFJQSxRQUFRSSxjQUFSLENBQXVCRCxJQUF2QixDQUFKLEVBQWtDO0FBQ2hDRixpQkFBU0UsSUFBVCxJQUFpQkgsUUFBUUcsSUFBUixDQUFqQjtBQUNEO0FBQ0Y7QUFDRjtBQUNELFNBQU9GLFFBQVA7QUFDRCIsImZpbGUiOiJwYXJhbXMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gZ2VuZXJhdGVPcHRpb25zKG9wdGlvbnMsIGRlZmF1bHRzKSB7XG4gIGlmICh0eXBlb2Ygb3B0aW9ucyA9PT0gJ2Z1bmN0aW9uJykge1xuICAgIGRlZmF1bHRzLmNhbGxiYWNrID0gb3B0aW9ucztcbiAgfSBlbHNlIGlmIChvcHRpb25zKSB7XG4gICAgZm9yIChsZXQgbmFtZSBpbiBvcHRpb25zKSB7XG4gICAgICAvKiBpc3RhbmJ1bCBpZ25vcmUgZWxzZSAqL1xuICAgICAgaWYgKG9wdGlvbnMuaGFzT3duUHJvcGVydHkobmFtZSkpIHtcbiAgICAgICAgZGVmYXVsdHNbbmFtZV0gPSBvcHRpb25zW25hbWVdO1xuICAgICAgfVxuICAgIH1cbiAgfVxuICByZXR1cm4gZGVmYXVsdHM7XG59XG4iXX0= + + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.lineDiff = undefined; + exports. /*istanbul ignore end*/diffLines = diffLines; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = diffTrimmedLines; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_params = __webpack_require__(4) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var lineDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/lineDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + lineDiff.tokenize = function (value) { + var retLines = [], + linesAndNewlines = value.split(/(\n|\r\n)/); + + // Ignore the final empty token that occurs if the string ends with a new line + if (!linesAndNewlines[linesAndNewlines.length - 1]) { + linesAndNewlines.pop(); + } + + // Merge the content and line separators into single tokens + for (var i = 0; i < linesAndNewlines.length; i++) { + var line = linesAndNewlines[i]; + + if (i % 2 && !this.options.newlineIsToken) { + retLines[retLines.length - 1] += line; + } else { + if (this.options.ignoreWhitespace) { + line = line.trim(); + } + retLines.push(line); + } + } + + return retLines; + }; + + function diffLines(oldStr, newStr, callback) { + return lineDiff.diff(oldStr, newStr, callback); + } + function diffTrimmedLines(oldStr, newStr, callback) { + var options = /*istanbul ignore start*/(0, _params.generateOptions) /*istanbul ignore end*/(callback, { ignoreWhitespace: true }); + return lineDiff.diff(oldStr, newStr, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.sentenceDiff = undefined; + exports. /*istanbul ignore end*/diffSentences = diffSentences; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var sentenceDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/sentenceDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + sentenceDiff.tokenize = function (value) { + return value.split(/(\S.+?[.!?])(?=\s+|$)/); + }; + + function diffSentences(oldStr, newStr, callback) { + return sentenceDiff.diff(oldStr, newStr, callback); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL3NlbnRlbmNlLmpzIl0sIm5hbWVzIjpbImRpZmZTZW50ZW5jZXMiLCJzZW50ZW5jZURpZmYiLCJ0b2tlbml6ZSIsInZhbHVlIiwic3BsaXQiLCJvbGRTdHIiLCJuZXdTdHIiLCJjYWxsYmFjayIsImRpZmYiXSwibWFwcGluZ3MiOiI7Ozs7Z0NBUWdCQSxhLEdBQUFBLGE7O0FBUmhCOzs7Ozs7dUJBR08sSUFBTUMsdUZBQWUsd0VBQXJCO0FBQ1BBLGFBQWFDLFFBQWIsR0FBd0IsVUFBU0MsS0FBVCxFQUFnQjtBQUN0QyxTQUFPQSxNQUFNQyxLQUFOLENBQVksdUJBQVosQ0FBUDtBQUNELENBRkQ7O0FBSU8sU0FBU0osYUFBVCxDQUF1QkssTUFBdkIsRUFBK0JDLE1BQS9CLEVBQXVDQyxRQUF2QyxFQUFpRDtBQUFFLFNBQU9OLGFBQWFPLElBQWIsQ0FBa0JILE1BQWxCLEVBQTBCQyxNQUExQixFQUFrQ0MsUUFBbEMsQ0FBUDtBQUFxRCIsImZpbGUiOiJzZW50ZW5jZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cblxuZXhwb3J0IGNvbnN0IHNlbnRlbmNlRGlmZiA9IG5ldyBEaWZmKCk7XG5zZW50ZW5jZURpZmYudG9rZW5pemUgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWUuc3BsaXQoLyhcXFMuKz9bLiE/XSkoPz1cXHMrfCQpLyk7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZlNlbnRlbmNlcyhvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spIHsgcmV0dXJuIHNlbnRlbmNlRGlmZi5kaWZmKG9sZFN0ciwgbmV3U3RyLCBjYWxsYmFjayk7IH1cbiJdfQ== + + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.cssDiff = undefined; + exports. /*istanbul ignore end*/diffCss = diffCss; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var cssDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/cssDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + cssDiff.tokenize = function (value) { + return value.split(/([{}:;,]|\s+)/); + }; + + function diffCss(oldStr, newStr, callback) { + return cssDiff.diff(oldStr, newStr, callback); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2Nzcy5qcyJdLCJuYW1lcyI6WyJkaWZmQ3NzIiwiY3NzRGlmZiIsInRva2VuaXplIiwidmFsdWUiLCJzcGxpdCIsIm9sZFN0ciIsIm5ld1N0ciIsImNhbGxiYWNrIiwiZGlmZiJdLCJtYXBwaW5ncyI6Ijs7OztnQ0FPZ0JBLE8sR0FBQUEsTzs7QUFQaEI7Ozs7Ozt1QkFFTyxJQUFNQyw2RUFBVSx3RUFBaEI7QUFDUEEsUUFBUUMsUUFBUixHQUFtQixVQUFTQyxLQUFULEVBQWdCO0FBQ2pDLFNBQU9BLE1BQU1DLEtBQU4sQ0FBWSxlQUFaLENBQVA7QUFDRCxDQUZEOztBQUlPLFNBQVNKLE9BQVQsQ0FBaUJLLE1BQWpCLEVBQXlCQyxNQUF6QixFQUFpQ0MsUUFBakMsRUFBMkM7QUFBRSxTQUFPTixRQUFRTyxJQUFSLENBQWFILE1BQWIsRUFBcUJDLE1BQXJCLEVBQTZCQyxRQUE3QixDQUFQO0FBQWdEIiwiZmlsZSI6ImNzcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cbmV4cG9ydCBjb25zdCBjc3NEaWZmID0gbmV3IERpZmYoKTtcbmNzc0RpZmYudG9rZW5pemUgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWUuc3BsaXQoLyhbe306OyxdfFxccyspLyk7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZkNzcyhvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spIHsgcmV0dXJuIGNzc0RpZmYuZGlmZihvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spOyB9XG4iXX0= + + +/***/ }), +/* 8 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.jsonDiff = undefined; + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + + exports. /*istanbul ignore end*/diffJson = diffJson; + /*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = canonicalize; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_line = __webpack_require__(5) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var objectPrototypeToString = Object.prototype.toString; + + var jsonDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/jsonDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a + // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output: + jsonDiff.useLongestToken = true; + + jsonDiff.tokenize = /*istanbul ignore start*/_line.lineDiff /*istanbul ignore end*/.tokenize; + jsonDiff.castInput = function (value) { + /*istanbul ignore start*/var _options = /*istanbul ignore end*/this.options, + undefinedReplacement = _options.undefinedReplacement, + _options$stringifyRep = _options.stringifyReplacer, + stringifyReplacer = _options$stringifyRep === undefined ? function (k, v) /*istanbul ignore start*/{ + return (/*istanbul ignore end*/typeof v === 'undefined' ? undefinedReplacement : v + ); + } : _options$stringifyRep; + + + return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, ' '); + }; + jsonDiff.equals = function (left, right) { + return (/*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1')) + ); + }; + + function diffJson(oldObj, newObj, options) { + return jsonDiff.diff(oldObj, newObj, options); + } + + // This function handles the presence of circular references by bailing out when encountering an + // object that is already on the "stack" of items being processed. Accepts an optional replacer + function canonicalize(obj, stack, replacementStack, replacer, key) { + stack = stack || []; + replacementStack = replacementStack || []; + + if (replacer) { + obj = replacer(key, obj); + } + + var i = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + + for (i = 0; i < stack.length; i += 1) { + if (stack[i] === obj) { + return replacementStack[i]; + } + } + + var canonicalizedObj = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + + if ('[object Array]' === objectPrototypeToString.call(obj)) { + stack.push(obj); + canonicalizedObj = new Array(obj.length); + replacementStack.push(canonicalizedObj); + for (i = 0; i < obj.length; i += 1) { + canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key); + } + stack.pop(); + replacementStack.pop(); + return canonicalizedObj; + } + + if (obj && obj.toJSON) { + obj = obj.toJSON(); + } + + if ( /*istanbul ignore start*/(typeof /*istanbul ignore end*/obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && obj !== null) { + stack.push(obj); + canonicalizedObj = {}; + replacementStack.push(canonicalizedObj); + var sortedKeys = [], + _key = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + for (_key in obj) { + /* istanbul ignore else */ + if (obj.hasOwnProperty(_key)) { + sortedKeys.push(_key); + } + } + sortedKeys.sort(); + for (i = 0; i < sortedKeys.length; i += 1) { + _key = sortedKeys[i]; + canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key); + } + stack.pop(); + replacementStack.pop(); + } else { + canonicalizedObj = obj; + } + return canonicalizedObj; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 9 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.arrayDiff = undefined; + exports. /*istanbul ignore end*/diffArrays = diffArrays; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var arrayDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/arrayDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + arrayDiff.tokenize = function (value) { + return value.slice(); + }; + arrayDiff.join = arrayDiff.removeEmpty = function (value) { + return value; + }; + + function diffArrays(oldArr, newArr, callback) { + return arrayDiff.diff(oldArr, newArr, callback); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2FycmF5LmpzIl0sIm5hbWVzIjpbImRpZmZBcnJheXMiLCJhcnJheURpZmYiLCJ0b2tlbml6ZSIsInZhbHVlIiwic2xpY2UiLCJqb2luIiwicmVtb3ZlRW1wdHkiLCJvbGRBcnIiLCJuZXdBcnIiLCJjYWxsYmFjayIsImRpZmYiXSwibWFwcGluZ3MiOiI7Ozs7Z0NBVWdCQSxVLEdBQUFBLFU7O0FBVmhCOzs7Ozs7dUJBRU8sSUFBTUMsaUZBQVksd0VBQWxCO0FBQ1BBLFVBQVVDLFFBQVYsR0FBcUIsVUFBU0MsS0FBVCxFQUFnQjtBQUNuQyxTQUFPQSxNQUFNQyxLQUFOLEVBQVA7QUFDRCxDQUZEO0FBR0FILFVBQVVJLElBQVYsR0FBaUJKLFVBQVVLLFdBQVYsR0FBd0IsVUFBU0gsS0FBVCxFQUFnQjtBQUN2RCxTQUFPQSxLQUFQO0FBQ0QsQ0FGRDs7QUFJTyxTQUFTSCxVQUFULENBQW9CTyxNQUFwQixFQUE0QkMsTUFBNUIsRUFBb0NDLFFBQXBDLEVBQThDO0FBQUUsU0FBT1IsVUFBVVMsSUFBVixDQUFlSCxNQUFmLEVBQXVCQyxNQUF2QixFQUErQkMsUUFBL0IsQ0FBUDtBQUFrRCIsImZpbGUiOiJhcnJheS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cbmV4cG9ydCBjb25zdCBhcnJheURpZmYgPSBuZXcgRGlmZigpO1xuYXJyYXlEaWZmLnRva2VuaXplID0gZnVuY3Rpb24odmFsdWUpIHtcbiAgcmV0dXJuIHZhbHVlLnNsaWNlKCk7XG59O1xuYXJyYXlEaWZmLmpvaW4gPSBhcnJheURpZmYucmVtb3ZlRW1wdHkgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWU7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZkFycmF5cyhvbGRBcnIsIG5ld0FyciwgY2FsbGJhY2spIHsgcmV0dXJuIGFycmF5RGlmZi5kaWZmKG9sZEFyciwgbmV3QXJyLCBjYWxsYmFjayk7IH1cbiJdfQ== + + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/applyPatch = applyPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = applyPatches; + + var /*istanbul ignore start*/_parse = __webpack_require__(11) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_distanceIterator = __webpack_require__(12) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _distanceIterator2 = _interopRequireDefault(_distanceIterator); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/function applyPatch(source, uniDiff) { + /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + if (typeof uniDiff === 'string') { + uniDiff = /*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(uniDiff); + } + + if (Array.isArray(uniDiff)) { + if (uniDiff.length > 1) { + throw new Error('applyPatch only works with a single input.'); + } + + uniDiff = uniDiff[0]; + } + + // Apply the diff to the input + var lines = source.split(/\r\n|[\n\v\f\r\x85]/), + delimiters = source.match(/\r\n|[\n\v\f\r\x85]/g) || [], + hunks = uniDiff.hunks, + compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) /*istanbul ignore start*/{ + return (/*istanbul ignore end*/line === patchContent + ); + }, + errorCount = 0, + fuzzFactor = options.fuzzFactor || 0, + minLine = 0, + offset = 0, + removeEOFNL = /*istanbul ignore start*/void 0 /*istanbul ignore end*/, + addEOFNL = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + + /** + * Checks if the hunk exactly fits on the provided location + */ + function hunkFits(hunk, toPos) { + for (var j = 0; j < hunk.lines.length; j++) { + var line = hunk.lines[j], + operation = line.length > 0 ? line[0] : ' ', + content = line.length > 0 ? line.substr(1) : line; + + if (operation === ' ' || operation === '-') { + // Context sanity check + if (!compareLine(toPos + 1, lines[toPos], operation, content)) { + errorCount++; + + if (errorCount > fuzzFactor) { + return false; + } + } + toPos++; + } + } + + return true; + } + + // Search best fit offsets for each hunk based on the previous ones + for (var i = 0; i < hunks.length; i++) { + var hunk = hunks[i], + maxLine = lines.length - hunk.oldLines, + localOffset = 0, + toPos = offset + hunk.oldStart - 1; + + var iterator = /*istanbul ignore start*/(0, _distanceIterator2['default']) /*istanbul ignore end*/(toPos, minLine, maxLine); + + for (; localOffset !== undefined; localOffset = iterator()) { + if (hunkFits(hunk, toPos + localOffset)) { + hunk.offset = offset += localOffset; + break; + } + } + + if (localOffset === undefined) { + return false; + } + + // Set lower text limit to end of the current hunk, so next ones don't try + // to fit over already patched text + minLine = hunk.offset + hunk.oldStart + hunk.oldLines; + } + + // Apply patch hunks + var diffOffset = 0; + for (var _i = 0; _i < hunks.length; _i++) { + var _hunk = hunks[_i], + _toPos = _hunk.oldStart + _hunk.offset + diffOffset - 1; + diffOffset += _hunk.newLines - _hunk.oldLines; + + if (_toPos < 0) { + // Creating a new file + _toPos = 0; + } + + for (var j = 0; j < _hunk.lines.length; j++) { + var line = _hunk.lines[j], + operation = line.length > 0 ? line[0] : ' ', + content = line.length > 0 ? line.substr(1) : line, + delimiter = _hunk.linedelimiters[j]; + + if (operation === ' ') { + _toPos++; + } else if (operation === '-') { + lines.splice(_toPos, 1); + delimiters.splice(_toPos, 1); + /* istanbul ignore else */ + } else if (operation === '+') { + lines.splice(_toPos, 0, content); + delimiters.splice(_toPos, 0, delimiter); + _toPos++; + } else if (operation === '\\') { + var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null; + if (previousOperation === '+') { + removeEOFNL = true; + } else if (previousOperation === '-') { + addEOFNL = true; + } + } + } + } + + // Handle EOFNL insertion/removal + if (removeEOFNL) { + while (!lines[lines.length - 1]) { + lines.pop(); + delimiters.pop(); + } + } else if (addEOFNL) { + lines.push(''); + delimiters.push('\n'); + } + for (var _k = 0; _k < lines.length - 1; _k++) { + lines[_k] = lines[_k] + delimiters[_k]; + } + return lines.join(''); + } + + // Wrapper that supports multiple file patches via callbacks. + function applyPatches(uniDiff, options) { + if (typeof uniDiff === 'string') { + uniDiff = /*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(uniDiff); + } + + var currentIndex = 0; + function processIndex() { + var index = uniDiff[currentIndex++]; + if (!index) { + return options.complete(); + } + + options.loadFile(index, function (err, data) { + if (err) { + return options.complete(err); + } + + var updatedContent = applyPatch(data, index, options); + options.patched(index, updatedContent, function (err) { + if (err) { + return options.complete(err); + } + + processIndex(); + }); + }); + } + processIndex(); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/apply.js"],"names":["applyPatch","applyPatches","source","uniDiff","options","Array","isArray","length","Error","lines","split","delimiters","match","hunks","compareLine","lineNumber","line","operation","patchContent","errorCount","fuzzFactor","minLine","offset","removeEOFNL","addEOFNL","hunkFits","hunk","toPos","j","content","substr","i","maxLine","oldLines","localOffset","oldStart","iterator","undefined","diffOffset","newLines","delimiter","linedelimiters","splice","previousOperation","pop","push","_k","join","currentIndex","processIndex","index","complete","loadFile","err","data","updatedContent","patched"],"mappings":";;;gCAGgBA,U,GAAAA,U;yDAoIAC,Y,GAAAA,Y;;AAvIhB;;AACA;;;;;;uBAEO,SAASD,UAAT,CAAoBE,MAApB,EAA4BC,OAA5B,EAAmD;AAAA,sDAAdC,OAAc,uEAAJ,EAAI;;AACxD,MAAI,OAAOD,OAAP,KAAmB,QAAvB,EAAiC;AAC/BA,cAAU,wEAAWA,OAAX,CAAV;AACD;;AAED,MAAIE,MAAMC,OAAN,CAAcH,OAAd,CAAJ,EAA4B;AAC1B,QAAIA,QAAQI,MAAR,GAAiB,CAArB,EAAwB;AACtB,YAAM,IAAIC,KAAJ,CAAU,4CAAV,CAAN;AACD;;AAEDL,cAAUA,QAAQ,CAAR,CAAV;AACD;;AAED;AACA,MAAIM,QAAQP,OAAOQ,KAAP,CAAa,qBAAb,CAAZ;AAAA,MACIC,aAAaT,OAAOU,KAAP,CAAa,sBAAb,KAAwC,EADzD;AAAA,MAEIC,QAAQV,QAAQU,KAFpB;AAAA,MAIIC,cAAcV,QAAQU,WAAR,IAAwB,UAACC,UAAD,EAAaC,IAAb,EAAmBC,SAAnB,EAA8BC,YAA9B;AAAA,mCAA+CF,SAASE;AAAxD;AAAA,GAJ1C;AAAA,MAKIC,aAAa,CALjB;AAAA,MAMIC,aAAahB,QAAQgB,UAAR,IAAsB,CANvC;AAAA,MAOIC,UAAU,CAPd;AAAA,MAQIC,SAAS,CARb;AAAA,MAUIC,6CAVJ;AAAA,MAWIC,0CAXJ;;AAaA;;;AAGA,WAASC,QAAT,CAAkBC,IAAlB,EAAwBC,KAAxB,EAA+B;AAC7B,SAAK,IAAIC,IAAI,CAAb,EAAgBA,IAAIF,KAAKjB,KAAL,CAAWF,MAA/B,EAAuCqB,GAAvC,EAA4C;AAC1C,UAAIZ,OAAOU,KAAKjB,KAAL,CAAWmB,CAAX,CAAX;AAAA,UACIX,YAAaD,KAAKT,MAAL,GAAc,CAAd,GAAkBS,KAAK,CAAL,CAAlB,GAA4B,GAD7C;AAAA,UAEIa,UAAWb,KAAKT,MAAL,GAAc,CAAd,GAAkBS,KAAKc,MAAL,CAAY,CAAZ,CAAlB,GAAmCd,IAFlD;;AAIA,UAAIC,cAAc,GAAd,IAAqBA,cAAc,GAAvC,EAA4C;AAC1C;AACA,YAAI,CAACH,YAAYa,QAAQ,CAApB,EAAuBlB,MAAMkB,KAAN,CAAvB,EAAqCV,SAArC,EAAgDY,OAAhD,CAAL,EAA+D;AAC7DV;;AAEA,cAAIA,aAAaC,UAAjB,EAA6B;AAC3B,mBAAO,KAAP;AACD;AACF;AACDO;AACD;AACF;;AAED,WAAO,IAAP;AACD;;AAED;AACA,OAAK,IAAII,IAAI,CAAb,EAAgBA,IAAIlB,MAAMN,MAA1B,EAAkCwB,GAAlC,EAAuC;AACrC,QAAIL,OAAOb,MAAMkB,CAAN,CAAX;AAAA,QACIC,UAAUvB,MAAMF,MAAN,GAAemB,KAAKO,QADlC;AAAA,QAEIC,cAAc,CAFlB;AAAA,QAGIP,QAAQL,SAASI,KAAKS,QAAd,GAAyB,CAHrC;;AAKA,QAAIC,WAAW,oFAAiBT,KAAjB,EAAwBN,OAAxB,EAAiCW,OAAjC,CAAf;;AAEA,WAAOE,gBAAgBG,SAAvB,EAAkCH,cAAcE,UAAhD,EAA4D;AAC1D,UAAIX,SAASC,IAAT,EAAeC,QAAQO,WAAvB,CAAJ,EAAyC;AACvCR,aAAKJ,MAAL,GAAcA,UAAUY,WAAxB;AACA;AACD;AACF;;AAED,QAAIA,gBAAgBG,SAApB,EAA+B;AAC7B,aAAO,KAAP;AACD;;AAED;AACA;AACAhB,cAAUK,KAAKJ,MAAL,GAAcI,KAAKS,QAAnB,GAA8BT,KAAKO,QAA7C;AACD;;AAED;AACA,MAAIK,aAAa,CAAjB;AACA,OAAK,IAAIP,KAAI,CAAb,EAAgBA,KAAIlB,MAAMN,MAA1B,EAAkCwB,IAAlC,EAAuC;AACrC,QAAIL,QAAOb,MAAMkB,EAAN,CAAX;AAAA,QACIJ,SAAQD,MAAKS,QAAL,GAAgBT,MAAKJ,MAArB,GAA8BgB,UAA9B,GAA2C,CADvD;AAEAA,kBAAcZ,MAAKa,QAAL,GAAgBb,MAAKO,QAAnC;;AAEA,QAAIN,SAAQ,CAAZ,EAAe;AAAE;AACfA,eAAQ,CAAR;AACD;;AAED,SAAK,IAAIC,IAAI,CAAb,EAAgBA,IAAIF,MAAKjB,KAAL,CAAWF,MAA/B,EAAuCqB,GAAvC,EAA4C;AAC1C,UAAIZ,OAAOU,MAAKjB,KAAL,CAAWmB,CAAX,CAAX;AAAA,UACIX,YAAaD,KAAKT,MAAL,GAAc,CAAd,GAAkBS,KAAK,CAAL,CAAlB,GAA4B,GAD7C;AAAA,UAEIa,UAAWb,KAAKT,MAAL,GAAc,CAAd,GAAkBS,KAAKc,MAAL,CAAY,CAAZ,CAAlB,GAAmCd,IAFlD;AAAA,UAGIwB,YAAYd,MAAKe,cAAL,CAAoBb,CAApB,CAHhB;;AAKA,UAAIX,cAAc,GAAlB,EAAuB;AACrBU;AACD,OAFD,MAEO,IAAIV,cAAc,GAAlB,EAAuB;AAC5BR,cAAMiC,MAAN,CAAaf,MAAb,EAAoB,CAApB;AACAhB,mBAAW+B,MAAX,CAAkBf,MAAlB,EAAyB,CAAzB;AACF;AACC,OAJM,MAIA,IAAIV,cAAc,GAAlB,EAAuB;AAC5BR,cAAMiC,MAAN,CAAaf,MAAb,EAAoB,CAApB,EAAuBE,OAAvB;AACAlB,mBAAW+B,MAAX,CAAkBf,MAAlB,EAAyB,CAAzB,EAA4Ba,SAA5B;AACAb;AACD,OAJM,MAIA,IAAIV,cAAc,IAAlB,EAAwB;AAC7B,YAAI0B,oBAAoBjB,MAAKjB,KAAL,CAAWmB,IAAI,CAAf,IAAoBF,MAAKjB,KAAL,CAAWmB,IAAI,CAAf,EAAkB,CAAlB,CAApB,GAA2C,IAAnE;AACA,YAAIe,sBAAsB,GAA1B,EAA+B;AAC7BpB,wBAAc,IAAd;AACD,SAFD,MAEO,IAAIoB,sBAAsB,GAA1B,EAA+B;AACpCnB,qBAAW,IAAX;AACD;AACF;AACF;AACF;;AAED;AACA,MAAID,WAAJ,EAAiB;AACf,WAAO,CAACd,MAAMA,MAAMF,MAAN,GAAe,CAArB,CAAR,EAAiC;AAC/BE,YAAMmC,GAAN;AACAjC,iBAAWiC,GAAX;AACD;AACF,GALD,MAKO,IAAIpB,QAAJ,EAAc;AACnBf,UAAMoC,IAAN,CAAW,EAAX;AACAlC,eAAWkC,IAAX,CAAgB,IAAhB;AACD;AACD,OAAK,IAAIC,KAAK,CAAd,EAAiBA,KAAKrC,MAAMF,MAAN,GAAe,CAArC,EAAwCuC,IAAxC,EAA8C;AAC5CrC,UAAMqC,EAAN,IAAYrC,MAAMqC,EAAN,IAAYnC,WAAWmC,EAAX,CAAxB;AACD;AACD,SAAOrC,MAAMsC,IAAN,CAAW,EAAX,CAAP;AACD;;AAED;AACO,SAAS9C,YAAT,CAAsBE,OAAtB,EAA+BC,OAA/B,EAAwC;AAC7C,MAAI,OAAOD,OAAP,KAAmB,QAAvB,EAAiC;AAC/BA,cAAU,wEAAWA,OAAX,CAAV;AACD;;AAED,MAAI6C,eAAe,CAAnB;AACA,WAASC,YAAT,GAAwB;AACtB,QAAIC,QAAQ/C,QAAQ6C,cAAR,CAAZ;AACA,QAAI,CAACE,KAAL,EAAY;AACV,aAAO9C,QAAQ+C,QAAR,EAAP;AACD;;AAED/C,YAAQgD,QAAR,CAAiBF,KAAjB,EAAwB,UAASG,GAAT,EAAcC,IAAd,EAAoB;AAC1C,UAAID,GAAJ,EAAS;AACP,eAAOjD,QAAQ+C,QAAR,CAAiBE,GAAjB,CAAP;AACD;;AAED,UAAIE,iBAAiBvD,WAAWsD,IAAX,EAAiBJ,KAAjB,EAAwB9C,OAAxB,CAArB;AACAA,cAAQoD,OAAR,CAAgBN,KAAhB,EAAuBK,cAAvB,EAAuC,UAASF,GAAT,EAAc;AACnD,YAAIA,GAAJ,EAAS;AACP,iBAAOjD,QAAQ+C,QAAR,CAAiBE,GAAjB,CAAP;AACD;;AAEDJ;AACD,OAND;AAOD,KAbD;AAcD;AACDA;AACD","file":"apply.js","sourcesContent":["import {parsePatch} from './parse';\nimport distanceIterator from '../util/distance-iterator';\n\nexport function applyPatch(source, uniDiff, options = {}) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  if (Array.isArray(uniDiff)) {\n    if (uniDiff.length > 1) {\n      throw new Error('applyPatch only works with a single input.');\n    }\n\n    uniDiff = uniDiff[0];\n  }\n\n  // Apply the diff to the input\n  let lines = source.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n      delimiters = source.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n      hunks = uniDiff.hunks,\n\n      compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent),\n      errorCount = 0,\n      fuzzFactor = options.fuzzFactor || 0,\n      minLine = 0,\n      offset = 0,\n\n      removeEOFNL,\n      addEOFNL;\n\n  /**\n   * Checks if the hunk exactly fits on the provided location\n   */\n  function hunkFits(hunk, toPos) {\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = (line.length > 0 ? line[0] : ' '),\n          content = (line.length > 0 ? line.substr(1) : line);\n\n      if (operation === ' ' || operation === '-') {\n        // Context sanity check\n        if (!compareLine(toPos + 1, lines[toPos], operation, content)) {\n          errorCount++;\n\n          if (errorCount > fuzzFactor) {\n            return false;\n          }\n        }\n        toPos++;\n      }\n    }\n\n    return true;\n  }\n\n  // Search best fit offsets for each hunk based on the previous ones\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        maxLine = lines.length - hunk.oldLines,\n        localOffset = 0,\n        toPos = offset + hunk.oldStart - 1;\n\n    let iterator = distanceIterator(toPos, minLine, maxLine);\n\n    for (; localOffset !== undefined; localOffset = iterator()) {\n      if (hunkFits(hunk, toPos + localOffset)) {\n        hunk.offset = offset += localOffset;\n        break;\n      }\n    }\n\n    if (localOffset === undefined) {\n      return false;\n    }\n\n    // Set lower text limit to end of the current hunk, so next ones don't try\n    // to fit over already patched text\n    minLine = hunk.offset + hunk.oldStart + hunk.oldLines;\n  }\n\n  // Apply patch hunks\n  let diffOffset = 0;\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        toPos = hunk.oldStart + hunk.offset + diffOffset - 1;\n    diffOffset += hunk.newLines - hunk.oldLines;\n\n    if (toPos < 0) { // Creating a new file\n      toPos = 0;\n    }\n\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = (line.length > 0 ? line[0] : ' '),\n          content = (line.length > 0 ? line.substr(1) : line),\n          delimiter = hunk.linedelimiters[j];\n\n      if (operation === ' ') {\n        toPos++;\n      } else if (operation === '-') {\n        lines.splice(toPos, 1);\n        delimiters.splice(toPos, 1);\n      /* istanbul ignore else */\n      } else if (operation === '+') {\n        lines.splice(toPos, 0, content);\n        delimiters.splice(toPos, 0, delimiter);\n        toPos++;\n      } else if (operation === '\\\\') {\n        let previousOperation = hunk.lines[j - 1] ? hunk.lines[j - 1][0] : null;\n        if (previousOperation === '+') {\n          removeEOFNL = true;\n        } else if (previousOperation === '-') {\n          addEOFNL = true;\n        }\n      }\n    }\n  }\n\n  // Handle EOFNL insertion/removal\n  if (removeEOFNL) {\n    while (!lines[lines.length - 1]) {\n      lines.pop();\n      delimiters.pop();\n    }\n  } else if (addEOFNL) {\n    lines.push('');\n    delimiters.push('\\n');\n  }\n  for (let _k = 0; _k < lines.length - 1; _k++) {\n    lines[_k] = lines[_k] + delimiters[_k];\n  }\n  return lines.join('');\n}\n\n// Wrapper that supports multiple file patches via callbacks.\nexport function applyPatches(uniDiff, options) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  let currentIndex = 0;\n  function processIndex() {\n    let index = uniDiff[currentIndex++];\n    if (!index) {\n      return options.complete();\n    }\n\n    options.loadFile(index, function(err, data) {\n      if (err) {\n        return options.complete(err);\n      }\n\n      let updatedContent = applyPatch(data, index, options);\n      options.patched(index, updatedContent, function(err) {\n        if (err) {\n          return options.complete(err);\n        }\n\n        processIndex();\n      });\n    });\n  }\n  processIndex();\n}\n"]} + + +/***/ }), +/* 11 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/parsePatch = parsePatch; + function parsePatch(uniDiff) { + /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/), + delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [], + list = [], + i = 0; + + function parseIndex() { + var index = {}; + list.push(index); + + // Parse diff metadata + while (i < diffstr.length) { + var line = diffstr[i]; + + // File header found, end parsing diff metadata + if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) { + break; + } + + // Diff index + var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line); + if (header) { + index.index = header[1]; + } + + i++; + } + + // Parse file headers if they are defined. Unified diff requires them, but + // there's no technical issues to have an isolated hunk without file header + parseFileHeader(index); + parseFileHeader(index); + + // Parse hunks + index.hunks = []; + + while (i < diffstr.length) { + var _line = diffstr[i]; + + if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) { + break; + } else if (/^@@/.test(_line)) { + index.hunks.push(parseHunk()); + } else if (_line && options.strict) { + // Ignore unexpected content unless in strict mode + throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line)); + } else { + i++; + } + } + } + + // Parses the --- and +++ headers, if none are found, no lines + // are consumed. + function parseFileHeader(index) { + var fileHeader = /^(---|\+\+\+)\s+(.*)$/.exec(diffstr[i]); + if (fileHeader) { + var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new'; + var data = fileHeader[2].split('\t', 2); + var fileName = data[0].replace(/\\\\/g, '\\'); + if (/^".*"$/.test(fileName)) { + fileName = fileName.substr(1, fileName.length - 2); + } + index[keyPrefix + 'FileName'] = fileName; + index[keyPrefix + 'Header'] = (data[1] || '').trim(); + + i++; + } + } + + // Parses a hunk + // This assumes that we are at the start of a hunk. + function parseHunk() { + var chunkHeaderIndex = i, + chunkHeaderLine = diffstr[i++], + chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/); + + var hunk = { + oldStart: +chunkHeader[1], + oldLines: +chunkHeader[2] || 1, + newStart: +chunkHeader[3], + newLines: +chunkHeader[4] || 1, + lines: [], + linedelimiters: [] + }; + + var addCount = 0, + removeCount = 0; + for (; i < diffstr.length; i++) { + // Lines starting with '---' could be mistaken for the "remove line" operation + // But they could be the header for the next file. Therefore prune such cases out. + if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) { + break; + } + var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? ' ' : diffstr[i][0]; + + if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') { + hunk.lines.push(diffstr[i]); + hunk.linedelimiters.push(delimiters[i] || '\n'); + + if (operation === '+') { + addCount++; + } else if (operation === '-') { + removeCount++; + } else if (operation === ' ') { + addCount++; + removeCount++; + } + } else { + break; + } + } + + // Handle the empty block count case + if (!addCount && hunk.newLines === 1) { + hunk.newLines = 0; + } + if (!removeCount && hunk.oldLines === 1) { + hunk.oldLines = 0; + } + + // Perform optional sanity checking + if (options.strict) { + if (addCount !== hunk.newLines) { + throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1)); + } + if (removeCount !== hunk.oldLines) { + throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1)); + } + } + + return hunk; + } + + while (i < diffstr.length) { + parseIndex(); + } + + return list; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/parse.js"],"names":["parsePatch","uniDiff","options","diffstr","split","delimiters","match","list","i","parseIndex","index","push","length","line","test","header","exec","parseFileHeader","hunks","parseHunk","strict","Error","JSON","stringify","fileHeader","keyPrefix","data","fileName","replace","substr","trim","chunkHeaderIndex","chunkHeaderLine","chunkHeader","hunk","oldStart","oldLines","newStart","newLines","lines","linedelimiters","addCount","removeCount","indexOf","operation"],"mappings":";;;gCAAgBA,U,GAAAA,U;AAAT,SAASA,UAAT,CAAoBC,OAApB,EAA2C;AAAA,sDAAdC,OAAc,uEAAJ,EAAI;;AAChD,MAAIC,UAAUF,QAAQG,KAAR,CAAc,qBAAd,CAAd;AAAA,MACIC,aAAaJ,QAAQK,KAAR,CAAc,sBAAd,KAAyC,EAD1D;AAAA,MAEIC,OAAO,EAFX;AAAA,MAGIC,IAAI,CAHR;;AAKA,WAASC,UAAT,GAAsB;AACpB,QAAIC,QAAQ,EAAZ;AACAH,SAAKI,IAAL,CAAUD,KAAV;;AAEA;AACA,WAAOF,IAAIL,QAAQS,MAAnB,EAA2B;AACzB,UAAIC,OAAOV,QAAQK,CAAR,CAAX;;AAEA;AACA,UAAI,wBAAwBM,IAAxB,CAA6BD,IAA7B,CAAJ,EAAwC;AACtC;AACD;;AAED;AACA,UAAIE,SAAU,0CAAD,CAA6CC,IAA7C,CAAkDH,IAAlD,CAAb;AACA,UAAIE,MAAJ,EAAY;AACVL,cAAMA,KAAN,GAAcK,OAAO,CAAP,CAAd;AACD;;AAEDP;AACD;;AAED;AACA;AACAS,oBAAgBP,KAAhB;AACAO,oBAAgBP,KAAhB;;AAEA;AACAA,UAAMQ,KAAN,GAAc,EAAd;;AAEA,WAAOV,IAAIL,QAAQS,MAAnB,EAA2B;AACzB,UAAIC,QAAOV,QAAQK,CAAR,CAAX;;AAEA,UAAI,iCAAiCM,IAAjC,CAAsCD,KAAtC,CAAJ,EAAiD;AAC/C;AACD,OAFD,MAEO,IAAI,MAAMC,IAAN,CAAWD,KAAX,CAAJ,EAAsB;AAC3BH,cAAMQ,KAAN,CAAYP,IAAZ,CAAiBQ,WAAjB;AACD,OAFM,MAEA,IAAIN,SAAQX,QAAQkB,MAApB,EAA4B;AACjC;AACA,cAAM,IAAIC,KAAJ,CAAU,mBAAmBb,IAAI,CAAvB,IAA4B,GAA5B,GAAkCc,KAAKC,SAAL,CAAeV,KAAf,CAA5C,CAAN;AACD,OAHM,MAGA;AACLL;AACD;AACF;AACF;;AAED;AACA;AACA,WAASS,eAAT,CAAyBP,KAAzB,EAAgC;AAC9B,QAAMc,aAAc,uBAAD,CAA0BR,IAA1B,CAA+Bb,QAAQK,CAAR,CAA/B,CAAnB;AACA,QAAIgB,UAAJ,EAAgB;AACd,UAAIC,YAAYD,WAAW,CAAX,MAAkB,KAAlB,GAA0B,KAA1B,GAAkC,KAAlD;AACA,UAAME,OAAOF,WAAW,CAAX,EAAcpB,KAAd,CAAoB,IAApB,EAA0B,CAA1B,CAAb;AACA,UAAIuB,WAAWD,KAAK,CAAL,EAAQE,OAAR,CAAgB,OAAhB,EAAyB,IAAzB,CAAf;AACA,UAAI,SAASd,IAAT,CAAca,QAAd,CAAJ,EAA6B;AAC3BA,mBAAWA,SAASE,MAAT,CAAgB,CAAhB,EAAmBF,SAASf,MAAT,GAAkB,CAArC,CAAX;AACD;AACDF,YAAMe,YAAY,UAAlB,IAAgCE,QAAhC;AACAjB,YAAMe,YAAY,QAAlB,IAA8B,CAACC,KAAK,CAAL,KAAW,EAAZ,EAAgBI,IAAhB,EAA9B;;AAEAtB;AACD;AACF;;AAED;AACA;AACA,WAASW,SAAT,GAAqB;AACnB,QAAIY,mBAAmBvB,CAAvB;AAAA,QACIwB,kBAAkB7B,QAAQK,GAAR,CADtB;AAAA,QAEIyB,cAAcD,gBAAgB5B,KAAhB,CAAsB,4CAAtB,CAFlB;;AAIA,QAAI8B,OAAO;AACTC,gBAAU,CAACF,YAAY,CAAZ,CADF;AAETG,gBAAU,CAACH,YAAY,CAAZ,CAAD,IAAmB,CAFpB;AAGTI,gBAAU,CAACJ,YAAY,CAAZ,CAHF;AAITK,gBAAU,CAACL,YAAY,CAAZ,CAAD,IAAmB,CAJpB;AAKTM,aAAO,EALE;AAMTC,sBAAgB;AANP,KAAX;;AASA,QAAIC,WAAW,CAAf;AAAA,QACIC,cAAc,CADlB;AAEA,WAAOlC,IAAIL,QAAQS,MAAnB,EAA2BJ,GAA3B,EAAgC;AAC9B;AACA;AACA,UAAIL,QAAQK,CAAR,EAAWmC,OAAX,CAAmB,MAAnB,MAA+B,CAA/B,IACMnC,IAAI,CAAJ,GAAQL,QAAQS,MADtB,IAEKT,QAAQK,IAAI,CAAZ,EAAemC,OAAf,CAAuB,MAAvB,MAAmC,CAFxC,IAGKxC,QAAQK,IAAI,CAAZ,EAAemC,OAAf,CAAuB,IAAvB,MAAiC,CAH1C,EAG6C;AACzC;AACH;AACD,UAAIC,YAAazC,QAAQK,CAAR,EAAWI,MAAX,IAAqB,CAArB,IAA0BJ,KAAML,QAAQS,MAAR,GAAiB,CAAlD,GAAwD,GAAxD,GAA8DT,QAAQK,CAAR,EAAW,CAAX,CAA9E;;AAEA,UAAIoC,cAAc,GAAd,IAAqBA,cAAc,GAAnC,IAA0CA,cAAc,GAAxD,IAA+DA,cAAc,IAAjF,EAAuF;AACrFV,aAAKK,KAAL,CAAW5B,IAAX,CAAgBR,QAAQK,CAAR,CAAhB;AACA0B,aAAKM,cAAL,CAAoB7B,IAApB,CAAyBN,WAAWG,CAAX,KAAiB,IAA1C;;AAEA,YAAIoC,cAAc,GAAlB,EAAuB;AACrBH;AACD,SAFD,MAEO,IAAIG,cAAc,GAAlB,EAAuB;AAC5BF;AACD,SAFM,MAEA,IAAIE,cAAc,GAAlB,EAAuB;AAC5BH;AACAC;AACD;AACF,OAZD,MAYO;AACL;AACD;AACF;;AAED;AACA,QAAI,CAACD,QAAD,IAAaP,KAAKI,QAAL,KAAkB,CAAnC,EAAsC;AACpCJ,WAAKI,QAAL,GAAgB,CAAhB;AACD;AACD,QAAI,CAACI,WAAD,IAAgBR,KAAKE,QAAL,KAAkB,CAAtC,EAAyC;AACvCF,WAAKE,QAAL,GAAgB,CAAhB;AACD;;AAED;AACA,QAAIlC,QAAQkB,MAAZ,EAAoB;AAClB,UAAIqB,aAAaP,KAAKI,QAAtB,EAAgC;AAC9B,cAAM,IAAIjB,KAAJ,CAAU,sDAAsDU,mBAAmB,CAAzE,CAAV,CAAN;AACD;AACD,UAAIW,gBAAgBR,KAAKE,QAAzB,EAAmC;AACjC,cAAM,IAAIf,KAAJ,CAAU,wDAAwDU,mBAAmB,CAA3E,CAAV,CAAN;AACD;AACF;;AAED,WAAOG,IAAP;AACD;;AAED,SAAO1B,IAAIL,QAAQS,MAAnB,EAA2B;AACzBH;AACD;;AAED,SAAOF,IAAP;AACD","file":"parse.js","sourcesContent":["export function parsePatch(uniDiff, options = {}) {\n  let diffstr = uniDiff.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n      delimiters = uniDiff.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n      list = [],\n      i = 0;\n\n  function parseIndex() {\n    let index = {};\n    list.push(index);\n\n    // Parse diff metadata\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      // File header found, end parsing diff metadata\n      if (/^(\\-\\-\\-|\\+\\+\\+|@@)\\s/.test(line)) {\n        break;\n      }\n\n      // Diff index\n      let header = (/^(?:Index:|diff(?: -r \\w+)+)\\s+(.+?)\\s*$/).exec(line);\n      if (header) {\n        index.index = header[1];\n      }\n\n      i++;\n    }\n\n    // Parse file headers if they are defined. Unified diff requires them, but\n    // there's no technical issues to have an isolated hunk without file header\n    parseFileHeader(index);\n    parseFileHeader(index);\n\n    // Parse hunks\n    index.hunks = [];\n\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      if (/^(Index:|diff|\\-\\-\\-|\\+\\+\\+)\\s/.test(line)) {\n        break;\n      } else if (/^@@/.test(line)) {\n        index.hunks.push(parseHunk());\n      } else if (line && options.strict) {\n        // Ignore unexpected content unless in strict mode\n        throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(line));\n      } else {\n        i++;\n      }\n    }\n  }\n\n  // Parses the --- and +++ headers, if none are found, no lines\n  // are consumed.\n  function parseFileHeader(index) {\n    const fileHeader = (/^(---|\\+\\+\\+)\\s+(.*)$/).exec(diffstr[i]);\n    if (fileHeader) {\n      let keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';\n      const data = fileHeader[2].split('\\t', 2);\n      let fileName = data[0].replace(/\\\\\\\\/g, '\\\\');\n      if (/^\".*\"$/.test(fileName)) {\n        fileName = fileName.substr(1, fileName.length - 2);\n      }\n      index[keyPrefix + 'FileName'] = fileName;\n      index[keyPrefix + 'Header'] = (data[1] || '').trim();\n\n      i++;\n    }\n  }\n\n  // Parses a hunk\n  // This assumes that we are at the start of a hunk.\n  function parseHunk() {\n    let chunkHeaderIndex = i,\n        chunkHeaderLine = diffstr[i++],\n        chunkHeader = chunkHeaderLine.split(/@@ -(\\d+)(?:,(\\d+))? \\+(\\d+)(?:,(\\d+))? @@/);\n\n    let hunk = {\n      oldStart: +chunkHeader[1],\n      oldLines: +chunkHeader[2] || 1,\n      newStart: +chunkHeader[3],\n      newLines: +chunkHeader[4] || 1,\n      lines: [],\n      linedelimiters: []\n    };\n\n    let addCount = 0,\n        removeCount = 0;\n    for (; i < diffstr.length; i++) {\n      // Lines starting with '---' could be mistaken for the \"remove line\" operation\n      // But they could be the header for the next file. Therefore prune such cases out.\n      if (diffstr[i].indexOf('--- ') === 0\n            && (i + 2 < diffstr.length)\n            && diffstr[i + 1].indexOf('+++ ') === 0\n            && diffstr[i + 2].indexOf('@@') === 0) {\n          break;\n      }\n      let operation = (diffstr[i].length == 0 && i != (diffstr.length - 1)) ? ' ' : diffstr[i][0];\n\n      if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\\\') {\n        hunk.lines.push(diffstr[i]);\n        hunk.linedelimiters.push(delimiters[i] || '\\n');\n\n        if (operation === '+') {\n          addCount++;\n        } else if (operation === '-') {\n          removeCount++;\n        } else if (operation === ' ') {\n          addCount++;\n          removeCount++;\n        }\n      } else {\n        break;\n      }\n    }\n\n    // Handle the empty block count case\n    if (!addCount && hunk.newLines === 1) {\n      hunk.newLines = 0;\n    }\n    if (!removeCount && hunk.oldLines === 1) {\n      hunk.oldLines = 0;\n    }\n\n    // Perform optional sanity checking\n    if (options.strict) {\n      if (addCount !== hunk.newLines) {\n        throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n      if (removeCount !== hunk.oldLines) {\n        throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n    }\n\n    return hunk;\n  }\n\n  while (i < diffstr.length) {\n    parseIndex();\n  }\n\n  return list;\n}\n"]} + + +/***/ }), +/* 12 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/"use strict"; + + exports.__esModule = true; + + exports["default"] = /*istanbul ignore end*/function (start, minLine, maxLine) { + var wantForward = true, + backwardExhausted = false, + forwardExhausted = false, + localOffset = 1; + + return function iterator() { + if (wantForward && !forwardExhausted) { + if (backwardExhausted) { + localOffset++; + } else { + wantForward = false; + } + + // Check if trying to fit beyond text length, and if not, check it fits + // after offset location (or desired location on first iteration) + if (start + localOffset <= maxLine) { + return localOffset; + } + + forwardExhausted = true; + } + + if (!backwardExhausted) { + if (!forwardExhausted) { + wantForward = true; + } + + // Check if trying to fit before text beginning, and if not, check it fits + // before offset location + if (minLine <= start - localOffset) { + return -localOffset++; + } + + backwardExhausted = true; + return iterator(); + } + + // We tried to fit hunk before text beginning and beyond text length, then + // hunk can't fit on the text. Return undefined + }; + }; + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 13 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/calcLineCount = calcLineCount; + /*istanbul ignore start*/exports. /*istanbul ignore end*/merge = merge; + + var /*istanbul ignore start*/_create = __webpack_require__(14) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_parse = __webpack_require__(11) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_array = __webpack_require__(15) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + + /*istanbul ignore end*/function calcLineCount(hunk) { + /*istanbul ignore start*/var _calcOldNewLineCount = /*istanbul ignore end*/calcOldNewLineCount(hunk.lines), + oldLines = _calcOldNewLineCount.oldLines, + newLines = _calcOldNewLineCount.newLines; + + if (oldLines !== undefined) { + hunk.oldLines = oldLines; + } else { + delete hunk.oldLines; + } + + if (newLines !== undefined) { + hunk.newLines = newLines; + } else { + delete hunk.newLines; + } + } + + function merge(mine, theirs, base) { + mine = loadPatch(mine, base); + theirs = loadPatch(theirs, base); + + var ret = {}; + + // For index we just let it pass through as it doesn't have any necessary meaning. + // Leaving sanity checks on this to the API consumer that may know more about the + // meaning in their own context. + if (mine.index || theirs.index) { + ret.index = mine.index || theirs.index; + } + + if (mine.newFileName || theirs.newFileName) { + if (!fileNameChanged(mine)) { + // No header or no change in ours, use theirs (and ours if theirs does not exist) + ret.oldFileName = theirs.oldFileName || mine.oldFileName; + ret.newFileName = theirs.newFileName || mine.newFileName; + ret.oldHeader = theirs.oldHeader || mine.oldHeader; + ret.newHeader = theirs.newHeader || mine.newHeader; + } else if (!fileNameChanged(theirs)) { + // No header or no change in theirs, use ours + ret.oldFileName = mine.oldFileName; + ret.newFileName = mine.newFileName; + ret.oldHeader = mine.oldHeader; + ret.newHeader = mine.newHeader; + } else { + // Both changed... figure it out + ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName); + ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName); + ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader); + ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader); + } + } + + ret.hunks = []; + + var mineIndex = 0, + theirsIndex = 0, + mineOffset = 0, + theirsOffset = 0; + + while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) { + var mineCurrent = mine.hunks[mineIndex] || { oldStart: Infinity }, + theirsCurrent = theirs.hunks[theirsIndex] || { oldStart: Infinity }; + + if (hunkBefore(mineCurrent, theirsCurrent)) { + // This patch does not overlap with any of the others, yay. + ret.hunks.push(cloneHunk(mineCurrent, mineOffset)); + mineIndex++; + theirsOffset += mineCurrent.newLines - mineCurrent.oldLines; + } else if (hunkBefore(theirsCurrent, mineCurrent)) { + // This patch does not overlap with any of the others, yay. + ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset)); + theirsIndex++; + mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines; + } else { + // Overlap, merge as best we can + var mergedHunk = { + oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart), + oldLines: 0, + newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset), + newLines: 0, + lines: [] + }; + mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines); + theirsIndex++; + mineIndex++; + + ret.hunks.push(mergedHunk); + } + } + + return ret; + } + + function loadPatch(param, base) { + if (typeof param === 'string') { + if (/^@@/m.test(param) || /^Index:/m.test(param)) { + return (/*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(param)[0] + ); + } + + if (!base) { + throw new Error('Must provide a base reference or pass in a patch'); + } + return (/*istanbul ignore start*/(0, _create.structuredPatch) /*istanbul ignore end*/(undefined, undefined, base, param) + ); + } + + return param; + } + + function fileNameChanged(patch) { + return patch.newFileName && patch.newFileName !== patch.oldFileName; + } + + function selectField(index, mine, theirs) { + if (mine === theirs) { + return mine; + } else { + index.conflict = true; + return { mine: mine, theirs: theirs }; + } + } + + function hunkBefore(test, check) { + return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart; + } + + function cloneHunk(hunk, offset) { + return { + oldStart: hunk.oldStart, oldLines: hunk.oldLines, + newStart: hunk.newStart + offset, newLines: hunk.newLines, + lines: hunk.lines + }; + } + + function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) { + // This will generally result in a conflicted hunk, but there are cases where the context + // is the only overlap where we can successfully merge the content here. + var mine = { offset: mineOffset, lines: mineLines, index: 0 }, + their = { offset: theirOffset, lines: theirLines, index: 0 }; + + // Handle any leading content + insertLeading(hunk, mine, their); + insertLeading(hunk, their, mine); + + // Now in the overlap content. Scan through and select the best changes from each. + while (mine.index < mine.lines.length && their.index < their.lines.length) { + var mineCurrent = mine.lines[mine.index], + theirCurrent = their.lines[their.index]; + + if ((mineCurrent[0] === '-' || mineCurrent[0] === '+') && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) { + // Both modified ... + mutualChange(hunk, mine, their); + } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') { + /*istanbul ignore start*/var _hunk$lines; + + /*istanbul ignore end*/ // Mine inserted + /*istanbul ignore start*/(_hunk$lines = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/collectChange(mine))); + } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') { + /*istanbul ignore start*/var _hunk$lines2; + + /*istanbul ignore end*/ // Theirs inserted + /*istanbul ignore start*/(_hunk$lines2 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines2 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/collectChange(their))); + } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') { + // Mine removed or edited + removal(hunk, mine, their); + } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') { + // Their removed or edited + removal(hunk, their, mine, true); + } else if (mineCurrent === theirCurrent) { + // Context identity + hunk.lines.push(mineCurrent); + mine.index++; + their.index++; + } else { + // Context mismatch + conflict(hunk, collectChange(mine), collectChange(their)); + } + } + + // Now push anything that may be remaining + insertTrailing(hunk, mine); + insertTrailing(hunk, their); + + calcLineCount(hunk); + } + + function mutualChange(hunk, mine, their) { + var myChanges = collectChange(mine), + theirChanges = collectChange(their); + + if (allRemoves(myChanges) && allRemoves(theirChanges)) { + // Special case for remove changes that are supersets of one another + if ( /*istanbul ignore start*/(0, _array.arrayStartsWith) /*istanbul ignore end*/(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) { + /*istanbul ignore start*/var _hunk$lines3; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines3 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines3 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/myChanges)); + return; + } else if ( /*istanbul ignore start*/(0, _array.arrayStartsWith) /*istanbul ignore end*/(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) { + /*istanbul ignore start*/var _hunk$lines4; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines4 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines4 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/theirChanges)); + return; + } + } else if ( /*istanbul ignore start*/(0, _array.arrayEqual) /*istanbul ignore end*/(myChanges, theirChanges)) { + /*istanbul ignore start*/var _hunk$lines5; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines5 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines5 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/myChanges)); + return; + } + + conflict(hunk, myChanges, theirChanges); + } + + function removal(hunk, mine, their, swap) { + var myChanges = collectChange(mine), + theirChanges = collectContext(their, myChanges); + if (theirChanges.merged) { + /*istanbul ignore start*/var _hunk$lines6; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines6 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines6 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/theirChanges.merged)); + } else { + conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges); + } + } + + function conflict(hunk, mine, their) { + hunk.conflict = true; + hunk.lines.push({ + conflict: true, + mine: mine, + theirs: their + }); + } + + function insertLeading(hunk, insert, their) { + while (insert.offset < their.offset && insert.index < insert.lines.length) { + var line = insert.lines[insert.index++]; + hunk.lines.push(line); + insert.offset++; + } + } + function insertTrailing(hunk, insert) { + while (insert.index < insert.lines.length) { + var line = insert.lines[insert.index++]; + hunk.lines.push(line); + } + } + + function collectChange(state) { + var ret = [], + operation = state.lines[state.index][0]; + while (state.index < state.lines.length) { + var line = state.lines[state.index]; + + // Group additions that are immediately after subtractions and treat them as one "atomic" modify change. + if (operation === '-' && line[0] === '+') { + operation = '+'; + } + + if (operation === line[0]) { + ret.push(line); + state.index++; + } else { + break; + } + } + + return ret; + } + function collectContext(state, matchChanges) { + var changes = [], + merged = [], + matchIndex = 0, + contextChanges = false, + conflicted = false; + while (matchIndex < matchChanges.length && state.index < state.lines.length) { + var change = state.lines[state.index], + match = matchChanges[matchIndex]; + + // Once we've hit our add, then we are done + if (match[0] === '+') { + break; + } + + contextChanges = contextChanges || change[0] !== ' '; + + merged.push(match); + matchIndex++; + + // Consume any additions in the other block as a conflict to attempt + // to pull in the remaining context after this + if (change[0] === '+') { + conflicted = true; + + while (change[0] === '+') { + changes.push(change); + change = state.lines[++state.index]; + } + } + + if (match.substr(1) === change.substr(1)) { + changes.push(change); + state.index++; + } else { + conflicted = true; + } + } + + if ((matchChanges[matchIndex] || '')[0] === '+' && contextChanges) { + conflicted = true; + } + + if (conflicted) { + return changes; + } + + while (matchIndex < matchChanges.length) { + merged.push(matchChanges[matchIndex++]); + } + + return { + merged: merged, + changes: changes + }; + } + + function allRemoves(changes) { + return changes.reduce(function (prev, change) { + return prev && change[0] === '-'; + }, true); + } + function skipRemoveSuperset(state, removeChanges, delta) { + for (var i = 0; i < delta; i++) { + var changeContent = removeChanges[removeChanges.length - delta + i].substr(1); + if (state.lines[state.index + i] !== ' ' + changeContent) { + return false; + } + } + + state.index += delta; + return true; + } + + function calcOldNewLineCount(lines) { + var oldLines = 0; + var newLines = 0; + + lines.forEach(function (line) { + if (typeof line !== 'string') { + var myCount = calcOldNewLineCount(line.mine); + var theirCount = calcOldNewLineCount(line.theirs); + + if (oldLines !== undefined) { + if (myCount.oldLines === theirCount.oldLines) { + oldLines += myCount.oldLines; + } else { + oldLines = undefined; + } + } + + if (newLines !== undefined) { + if (myCount.newLines === theirCount.newLines) { + newLines += myCount.newLines; + } else { + newLines = undefined; + } + } + } else { + if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) { + newLines++; + } + if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) { + oldLines++; + } + } + }); + + return { oldLines: oldLines, newLines: newLines }; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/merge.js"],"names":["calcLineCount","merge","hunk","calcOldNewLineCount","lines","oldLines","newLines","undefined","mine","theirs","base","loadPatch","ret","index","newFileName","fileNameChanged","oldFileName","oldHeader","newHeader","selectField","hunks","mineIndex","theirsIndex","mineOffset","theirsOffset","length","mineCurrent","oldStart","Infinity","theirsCurrent","hunkBefore","push","cloneHunk","mergedHunk","Math","min","newStart","mergeLines","param","test","Error","patch","conflict","check","offset","mineLines","theirOffset","theirLines","their","insertLeading","theirCurrent","mutualChange","collectChange","removal","insertTrailing","myChanges","theirChanges","allRemoves","skipRemoveSuperset","swap","collectContext","merged","insert","line","state","operation","matchChanges","changes","matchIndex","contextChanges","conflicted","change","match","substr","reduce","prev","removeChanges","delta","i","changeContent","forEach","myCount","theirCount"],"mappings":";;;gCAKgBA,a,GAAAA,a;yDAgBAC,K,GAAAA,K;;AArBhB;;AACA;;AAEA;;;;uBAEO,SAASD,aAAT,CAAuBE,IAAvB,EAA6B;AAAA,6EACLC,oBAAoBD,KAAKE,KAAzB,CADK;AAAA,MAC3BC,QAD2B,wBAC3BA,QAD2B;AAAA,MACjBC,QADiB,wBACjBA,QADiB;;AAGlC,MAAID,aAAaE,SAAjB,EAA4B;AAC1BL,SAAKG,QAAL,GAAgBA,QAAhB;AACD,GAFD,MAEO;AACL,WAAOH,KAAKG,QAAZ;AACD;;AAED,MAAIC,aAAaC,SAAjB,EAA4B;AAC1BL,SAAKI,QAAL,GAAgBA,QAAhB;AACD,GAFD,MAEO;AACL,WAAOJ,KAAKI,QAAZ;AACD;AACF;;AAEM,SAASL,KAAT,CAAeO,IAAf,EAAqBC,MAArB,EAA6BC,IAA7B,EAAmC;AACxCF,SAAOG,UAAUH,IAAV,EAAgBE,IAAhB,CAAP;AACAD,WAASE,UAAUF,MAAV,EAAkBC,IAAlB,CAAT;;AAEA,MAAIE,MAAM,EAAV;;AAEA;AACA;AACA;AACA,MAAIJ,KAAKK,KAAL,IAAcJ,OAAOI,KAAzB,EAAgC;AAC9BD,QAAIC,KAAJ,GAAYL,KAAKK,KAAL,IAAcJ,OAAOI,KAAjC;AACD;;AAED,MAAIL,KAAKM,WAAL,IAAoBL,OAAOK,WAA/B,EAA4C;AAC1C,QAAI,CAACC,gBAAgBP,IAAhB,CAAL,EAA4B;AAC1B;AACAI,UAAII,WAAJ,GAAkBP,OAAOO,WAAP,IAAsBR,KAAKQ,WAA7C;AACAJ,UAAIE,WAAJ,GAAkBL,OAAOK,WAAP,IAAsBN,KAAKM,WAA7C;AACAF,UAAIK,SAAJ,GAAgBR,OAAOQ,SAAP,IAAoBT,KAAKS,SAAzC;AACAL,UAAIM,SAAJ,GAAgBT,OAAOS,SAAP,IAAoBV,KAAKU,SAAzC;AACD,KAND,MAMO,IAAI,CAACH,gBAAgBN,MAAhB,CAAL,EAA8B;AACnC;AACAG,UAAII,WAAJ,GAAkBR,KAAKQ,WAAvB;AACAJ,UAAIE,WAAJ,GAAkBN,KAAKM,WAAvB;AACAF,UAAIK,SAAJ,GAAgBT,KAAKS,SAArB;AACAL,UAAIM,SAAJ,GAAgBV,KAAKU,SAArB;AACD,KANM,MAMA;AACL;AACAN,UAAII,WAAJ,GAAkBG,YAAYP,GAAZ,EAAiBJ,KAAKQ,WAAtB,EAAmCP,OAAOO,WAA1C,CAAlB;AACAJ,UAAIE,WAAJ,GAAkBK,YAAYP,GAAZ,EAAiBJ,KAAKM,WAAtB,EAAmCL,OAAOK,WAA1C,CAAlB;AACAF,UAAIK,SAAJ,GAAgBE,YAAYP,GAAZ,EAAiBJ,KAAKS,SAAtB,EAAiCR,OAAOQ,SAAxC,CAAhB;AACAL,UAAIM,SAAJ,GAAgBC,YAAYP,GAAZ,EAAiBJ,KAAKU,SAAtB,EAAiCT,OAAOS,SAAxC,CAAhB;AACD;AACF;;AAEDN,MAAIQ,KAAJ,GAAY,EAAZ;;AAEA,MAAIC,YAAY,CAAhB;AAAA,MACIC,cAAc,CADlB;AAAA,MAEIC,aAAa,CAFjB;AAAA,MAGIC,eAAe,CAHnB;;AAKA,SAAOH,YAAYb,KAAKY,KAAL,CAAWK,MAAvB,IAAiCH,cAAcb,OAAOW,KAAP,CAAaK,MAAnE,EAA2E;AACzE,QAAIC,cAAclB,KAAKY,KAAL,CAAWC,SAAX,KAAyB,EAACM,UAAUC,QAAX,EAA3C;AAAA,QACIC,gBAAgBpB,OAAOW,KAAP,CAAaE,WAAb,KAA6B,EAACK,UAAUC,QAAX,EADjD;;AAGA,QAAIE,WAAWJ,WAAX,EAAwBG,aAAxB,CAAJ,EAA4C;AAC1C;AACAjB,UAAIQ,KAAJ,CAAUW,IAAV,CAAeC,UAAUN,WAAV,EAAuBH,UAAvB,CAAf;AACAF;AACAG,sBAAgBE,YAAYpB,QAAZ,GAAuBoB,YAAYrB,QAAnD;AACD,KALD,MAKO,IAAIyB,WAAWD,aAAX,EAA0BH,WAA1B,CAAJ,EAA4C;AACjD;AACAd,UAAIQ,KAAJ,CAAUW,IAAV,CAAeC,UAAUH,aAAV,EAAyBL,YAAzB,CAAf;AACAF;AACAC,oBAAcM,cAAcvB,QAAd,GAAyBuB,cAAcxB,QAArD;AACD,KALM,MAKA;AACL;AACA,UAAI4B,aAAa;AACfN,kBAAUO,KAAKC,GAAL,CAAST,YAAYC,QAArB,EAA+BE,cAAcF,QAA7C,CADK;AAEftB,kBAAU,CAFK;AAGf+B,kBAAUF,KAAKC,GAAL,CAAST,YAAYU,QAAZ,GAAuBb,UAAhC,EAA4CM,cAAcF,QAAd,GAAyBH,YAArE,CAHK;AAIflB,kBAAU,CAJK;AAKfF,eAAO;AALQ,OAAjB;AAOAiC,iBAAWJ,UAAX,EAAuBP,YAAYC,QAAnC,EAA6CD,YAAYtB,KAAzD,EAAgEyB,cAAcF,QAA9E,EAAwFE,cAAczB,KAAtG;AACAkB;AACAD;;AAEAT,UAAIQ,KAAJ,CAAUW,IAAV,CAAeE,UAAf;AACD;AACF;;AAED,SAAOrB,GAAP;AACD;;AAED,SAASD,SAAT,CAAmB2B,KAAnB,EAA0B5B,IAA1B,EAAgC;AAC9B,MAAI,OAAO4B,KAAP,KAAiB,QAArB,EAA+B;AAC7B,QAAI,OAAOC,IAAP,CAAYD,KAAZ,KAAuB,WAAWC,IAAX,CAAgBD,KAAhB,CAA3B,EAAoD;AAClD,aAAO,yEAAWA,KAAX,EAAkB,CAAlB;AAAP;AACD;;AAED,QAAI,CAAC5B,IAAL,EAAW;AACT,YAAM,IAAI8B,KAAJ,CAAU,kDAAV,CAAN;AACD;AACD,WAAO,+EAAgBjC,SAAhB,EAA2BA,SAA3B,EAAsCG,IAAtC,EAA4C4B,KAA5C;AAAP;AACD;;AAED,SAAOA,KAAP;AACD;;AAED,SAASvB,eAAT,CAAyB0B,KAAzB,EAAgC;AAC9B,SAAOA,MAAM3B,WAAN,IAAqB2B,MAAM3B,WAAN,KAAsB2B,MAAMzB,WAAxD;AACD;;AAED,SAASG,WAAT,CAAqBN,KAArB,EAA4BL,IAA5B,EAAkCC,MAAlC,EAA0C;AACxC,MAAID,SAASC,MAAb,EAAqB;AACnB,WAAOD,IAAP;AACD,GAFD,MAEO;AACLK,UAAM6B,QAAN,GAAiB,IAAjB;AACA,WAAO,EAAClC,UAAD,EAAOC,cAAP,EAAP;AACD;AACF;;AAED,SAASqB,UAAT,CAAoBS,IAApB,EAA0BI,KAA1B,EAAiC;AAC/B,SAAOJ,KAAKZ,QAAL,GAAgBgB,MAAMhB,QAAtB,IACDY,KAAKZ,QAAL,GAAgBY,KAAKlC,QAAtB,GAAkCsC,MAAMhB,QAD7C;AAED;;AAED,SAASK,SAAT,CAAmB9B,IAAnB,EAAyB0C,MAAzB,EAAiC;AAC/B,SAAO;AACLjB,cAAUzB,KAAKyB,QADV,EACoBtB,UAAUH,KAAKG,QADnC;AAEL+B,cAAUlC,KAAKkC,QAAL,GAAgBQ,MAFrB,EAE6BtC,UAAUJ,KAAKI,QAF5C;AAGLF,WAAOF,KAAKE;AAHP,GAAP;AAKD;;AAED,SAASiC,UAAT,CAAoBnC,IAApB,EAA0BqB,UAA1B,EAAsCsB,SAAtC,EAAiDC,WAAjD,EAA8DC,UAA9D,EAA0E;AACxE;AACA;AACA,MAAIvC,OAAO,EAACoC,QAAQrB,UAAT,EAAqBnB,OAAOyC,SAA5B,EAAuChC,OAAO,CAA9C,EAAX;AAAA,MACImC,QAAQ,EAACJ,QAAQE,WAAT,EAAsB1C,OAAO2C,UAA7B,EAAyClC,OAAO,CAAhD,EADZ;;AAGA;AACAoC,gBAAc/C,IAAd,EAAoBM,IAApB,EAA0BwC,KAA1B;AACAC,gBAAc/C,IAAd,EAAoB8C,KAApB,EAA2BxC,IAA3B;;AAEA;AACA,SAAOA,KAAKK,KAAL,GAAaL,KAAKJ,KAAL,CAAWqB,MAAxB,IAAkCuB,MAAMnC,KAAN,GAAcmC,MAAM5C,KAAN,CAAYqB,MAAnE,EAA2E;AACzE,QAAIC,cAAclB,KAAKJ,KAAL,CAAWI,KAAKK,KAAhB,CAAlB;AAAA,QACIqC,eAAeF,MAAM5C,KAAN,CAAY4C,MAAMnC,KAAlB,CADnB;;AAGA,QAAI,CAACa,YAAY,CAAZ,MAAmB,GAAnB,IAA0BA,YAAY,CAAZ,MAAmB,GAA9C,MACIwB,aAAa,CAAb,MAAoB,GAApB,IAA2BA,aAAa,CAAb,MAAoB,GADnD,CAAJ,EAC6D;AAC3D;AACAC,mBAAajD,IAAb,EAAmBM,IAAnB,EAAyBwC,KAAzB;AACD,KAJD,MAIO,IAAItB,YAAY,CAAZ,MAAmB,GAAnB,IAA0BwB,aAAa,CAAb,MAAoB,GAAlD,EAAuD;AAAA;;AAAA,8BAC5D;AACA,0EAAK9C,KAAL,EAAW2B,IAAX,4LAAoBqB,cAAc5C,IAAd,CAApB;AACD,KAHM,MAGA,IAAI0C,aAAa,CAAb,MAAoB,GAApB,IAA2BxB,YAAY,CAAZ,MAAmB,GAAlD,EAAuD;AAAA;;AAAA,8BAC5D;AACA,2EAAKtB,KAAL,EAAW2B,IAAX,6LAAoBqB,cAAcJ,KAAd,CAApB;AACD,KAHM,MAGA,IAAItB,YAAY,CAAZ,MAAmB,GAAnB,IAA0BwB,aAAa,CAAb,MAAoB,GAAlD,EAAuD;AAC5D;AACAG,cAAQnD,IAAR,EAAcM,IAAd,EAAoBwC,KAApB;AACD,KAHM,MAGA,IAAIE,aAAa,CAAb,MAAoB,GAApB,IAA2BxB,YAAY,CAAZ,MAAmB,GAAlD,EAAuD;AAC5D;AACA2B,cAAQnD,IAAR,EAAc8C,KAAd,EAAqBxC,IAArB,EAA2B,IAA3B;AACD,KAHM,MAGA,IAAIkB,gBAAgBwB,YAApB,EAAkC;AACvC;AACAhD,WAAKE,KAAL,CAAW2B,IAAX,CAAgBL,WAAhB;AACAlB,WAAKK,KAAL;AACAmC,YAAMnC,KAAN;AACD,KALM,MAKA;AACL;AACA6B,eAASxC,IAAT,EAAekD,cAAc5C,IAAd,CAAf,EAAoC4C,cAAcJ,KAAd,CAApC;AACD;AACF;;AAED;AACAM,iBAAepD,IAAf,EAAqBM,IAArB;AACA8C,iBAAepD,IAAf,EAAqB8C,KAArB;;AAEAhD,gBAAcE,IAAd;AACD;;AAED,SAASiD,YAAT,CAAsBjD,IAAtB,EAA4BM,IAA5B,EAAkCwC,KAAlC,EAAyC;AACvC,MAAIO,YAAYH,cAAc5C,IAAd,CAAhB;AAAA,MACIgD,eAAeJ,cAAcJ,KAAd,CADnB;;AAGA,MAAIS,WAAWF,SAAX,KAAyBE,WAAWD,YAAX,CAA7B,EAAuD;AACrD;AACA,QAAI,8EAAgBD,SAAhB,EAA2BC,YAA3B,KACGE,mBAAmBV,KAAnB,EAA0BO,SAA1B,EAAqCA,UAAU9B,MAAV,GAAmB+B,aAAa/B,MAArE,CADP,EACqF;AAAA;;AAAA,6BACnF,sEAAKrB,KAAL,EAAW2B,IAAX,6LAAoBwB,SAApB;AACA;AACD,KAJD,MAIO,IAAI,8EAAgBC,YAAhB,EAA8BD,SAA9B,KACJG,mBAAmBlD,IAAnB,EAAyBgD,YAAzB,EAAuCA,aAAa/B,MAAb,GAAsB8B,UAAU9B,MAAvE,CADA,EACgF;AAAA;;AAAA,6BACrF,sEAAKrB,KAAL,EAAW2B,IAAX,6LAAoByB,YAApB;AACA;AACD;AACF,GAXD,MAWO,IAAI,yEAAWD,SAAX,EAAsBC,YAAtB,CAAJ,EAAyC;AAAA;;AAAA,2BAC9C,sEAAKpD,KAAL,EAAW2B,IAAX,6LAAoBwB,SAApB;AACA;AACD;;AAEDb,WAASxC,IAAT,EAAeqD,SAAf,EAA0BC,YAA1B;AACD;;AAED,SAASH,OAAT,CAAiBnD,IAAjB,EAAuBM,IAAvB,EAA6BwC,KAA7B,EAAoCW,IAApC,EAA0C;AACxC,MAAIJ,YAAYH,cAAc5C,IAAd,CAAhB;AAAA,MACIgD,eAAeI,eAAeZ,KAAf,EAAsBO,SAAtB,CADnB;AAEA,MAAIC,aAAaK,MAAjB,EAAyB;AAAA;;AAAA,2BACvB,sEAAKzD,KAAL,EAAW2B,IAAX,6LAAoByB,aAAaK,MAAjC;AACD,GAFD,MAEO;AACLnB,aAASxC,IAAT,EAAeyD,OAAOH,YAAP,GAAsBD,SAArC,EAAgDI,OAAOJ,SAAP,GAAmBC,YAAnE;AACD;AACF;;AAED,SAASd,QAAT,CAAkBxC,IAAlB,EAAwBM,IAAxB,EAA8BwC,KAA9B,EAAqC;AACnC9C,OAAKwC,QAAL,GAAgB,IAAhB;AACAxC,OAAKE,KAAL,CAAW2B,IAAX,CAAgB;AACdW,cAAU,IADI;AAEdlC,UAAMA,IAFQ;AAGdC,YAAQuC;AAHM,GAAhB;AAKD;;AAED,SAASC,aAAT,CAAuB/C,IAAvB,EAA6B4D,MAA7B,EAAqCd,KAArC,EAA4C;AAC1C,SAAOc,OAAOlB,MAAP,GAAgBI,MAAMJ,MAAtB,IAAgCkB,OAAOjD,KAAP,GAAeiD,OAAO1D,KAAP,CAAaqB,MAAnE,EAA2E;AACzE,QAAIsC,OAAOD,OAAO1D,KAAP,CAAa0D,OAAOjD,KAAP,EAAb,CAAX;AACAX,SAAKE,KAAL,CAAW2B,IAAX,CAAgBgC,IAAhB;AACAD,WAAOlB,MAAP;AACD;AACF;AACD,SAASU,cAAT,CAAwBpD,IAAxB,EAA8B4D,MAA9B,EAAsC;AACpC,SAAOA,OAAOjD,KAAP,GAAeiD,OAAO1D,KAAP,CAAaqB,MAAnC,EAA2C;AACzC,QAAIsC,OAAOD,OAAO1D,KAAP,CAAa0D,OAAOjD,KAAP,EAAb,CAAX;AACAX,SAAKE,KAAL,CAAW2B,IAAX,CAAgBgC,IAAhB;AACD;AACF;;AAED,SAASX,aAAT,CAAuBY,KAAvB,EAA8B;AAC5B,MAAIpD,MAAM,EAAV;AAAA,MACIqD,YAAYD,MAAM5D,KAAN,CAAY4D,MAAMnD,KAAlB,EAAyB,CAAzB,CADhB;AAEA,SAAOmD,MAAMnD,KAAN,GAAcmD,MAAM5D,KAAN,CAAYqB,MAAjC,EAAyC;AACvC,QAAIsC,OAAOC,MAAM5D,KAAN,CAAY4D,MAAMnD,KAAlB,CAAX;;AAEA;AACA,QAAIoD,cAAc,GAAd,IAAqBF,KAAK,CAAL,MAAY,GAArC,EAA0C;AACxCE,kBAAY,GAAZ;AACD;;AAED,QAAIA,cAAcF,KAAK,CAAL,CAAlB,EAA2B;AACzBnD,UAAImB,IAAJ,CAASgC,IAAT;AACAC,YAAMnD,KAAN;AACD,KAHD,MAGO;AACL;AACD;AACF;;AAED,SAAOD,GAAP;AACD;AACD,SAASgD,cAAT,CAAwBI,KAAxB,EAA+BE,YAA/B,EAA6C;AAC3C,MAAIC,UAAU,EAAd;AAAA,MACIN,SAAS,EADb;AAAA,MAEIO,aAAa,CAFjB;AAAA,MAGIC,iBAAiB,KAHrB;AAAA,MAIIC,aAAa,KAJjB;AAKA,SAAOF,aAAaF,aAAazC,MAA1B,IACEuC,MAAMnD,KAAN,GAAcmD,MAAM5D,KAAN,CAAYqB,MADnC,EAC2C;AACzC,QAAI8C,SAASP,MAAM5D,KAAN,CAAY4D,MAAMnD,KAAlB,CAAb;AAAA,QACI2D,QAAQN,aAAaE,UAAb,CADZ;;AAGA;AACA,QAAII,MAAM,CAAN,MAAa,GAAjB,EAAsB;AACpB;AACD;;AAEDH,qBAAiBA,kBAAkBE,OAAO,CAAP,MAAc,GAAjD;;AAEAV,WAAO9B,IAAP,CAAYyC,KAAZ;AACAJ;;AAEA;AACA;AACA,QAAIG,OAAO,CAAP,MAAc,GAAlB,EAAuB;AACrBD,mBAAa,IAAb;;AAEA,aAAOC,OAAO,CAAP,MAAc,GAArB,EAA0B;AACxBJ,gBAAQpC,IAAR,CAAawC,MAAb;AACAA,iBAASP,MAAM5D,KAAN,CAAY,EAAE4D,MAAMnD,KAApB,CAAT;AACD;AACF;;AAED,QAAI2D,MAAMC,MAAN,CAAa,CAAb,MAAoBF,OAAOE,MAAP,CAAc,CAAd,CAAxB,EAA0C;AACxCN,cAAQpC,IAAR,CAAawC,MAAb;AACAP,YAAMnD,KAAN;AACD,KAHD,MAGO;AACLyD,mBAAa,IAAb;AACD;AACF;;AAED,MAAI,CAACJ,aAAaE,UAAb,KAA4B,EAA7B,EAAiC,CAAjC,MAAwC,GAAxC,IACGC,cADP,EACuB;AACrBC,iBAAa,IAAb;AACD;;AAED,MAAIA,UAAJ,EAAgB;AACd,WAAOH,OAAP;AACD;;AAED,SAAOC,aAAaF,aAAazC,MAAjC,EAAyC;AACvCoC,WAAO9B,IAAP,CAAYmC,aAAaE,YAAb,CAAZ;AACD;;AAED,SAAO;AACLP,kBADK;AAELM;AAFK,GAAP;AAID;;AAED,SAASV,UAAT,CAAoBU,OAApB,EAA6B;AAC3B,SAAOA,QAAQO,MAAR,CAAe,UAASC,IAAT,EAAeJ,MAAf,EAAuB;AAC3C,WAAOI,QAAQJ,OAAO,CAAP,MAAc,GAA7B;AACD,GAFM,EAEJ,IAFI,CAAP;AAGD;AACD,SAASb,kBAAT,CAA4BM,KAA5B,EAAmCY,aAAnC,EAAkDC,KAAlD,EAAyD;AACvD,OAAK,IAAIC,IAAI,CAAb,EAAgBA,IAAID,KAApB,EAA2BC,GAA3B,EAAgC;AAC9B,QAAIC,gBAAgBH,cAAcA,cAAcnD,MAAd,GAAuBoD,KAAvB,GAA+BC,CAA7C,EAAgDL,MAAhD,CAAuD,CAAvD,CAApB;AACA,QAAIT,MAAM5D,KAAN,CAAY4D,MAAMnD,KAAN,GAAciE,CAA1B,MAAiC,MAAMC,aAA3C,EAA0D;AACxD,aAAO,KAAP;AACD;AACF;;AAEDf,QAAMnD,KAAN,IAAegE,KAAf;AACA,SAAO,IAAP;AACD;;AAED,SAAS1E,mBAAT,CAA6BC,KAA7B,EAAoC;AAClC,MAAIC,WAAW,CAAf;AACA,MAAIC,WAAW,CAAf;;AAEAF,QAAM4E,OAAN,CAAc,UAASjB,IAAT,EAAe;AAC3B,QAAI,OAAOA,IAAP,KAAgB,QAApB,EAA8B;AAC5B,UAAIkB,UAAU9E,oBAAoB4D,KAAKvD,IAAzB,CAAd;AACA,UAAI0E,aAAa/E,oBAAoB4D,KAAKtD,MAAzB,CAAjB;;AAEA,UAAIJ,aAAaE,SAAjB,EAA4B;AAC1B,YAAI0E,QAAQ5E,QAAR,KAAqB6E,WAAW7E,QAApC,EAA8C;AAC5CA,sBAAY4E,QAAQ5E,QAApB;AACD,SAFD,MAEO;AACLA,qBAAWE,SAAX;AACD;AACF;;AAED,UAAID,aAAaC,SAAjB,EAA4B;AAC1B,YAAI0E,QAAQ3E,QAAR,KAAqB4E,WAAW5E,QAApC,EAA8C;AAC5CA,sBAAY2E,QAAQ3E,QAApB;AACD,SAFD,MAEO;AACLA,qBAAWC,SAAX;AACD;AACF;AACF,KAnBD,MAmBO;AACL,UAAID,aAAaC,SAAb,KAA2BwD,KAAK,CAAL,MAAY,GAAZ,IAAmBA,KAAK,CAAL,MAAY,GAA1D,CAAJ,EAAoE;AAClEzD;AACD;AACD,UAAID,aAAaE,SAAb,KAA2BwD,KAAK,CAAL,MAAY,GAAZ,IAAmBA,KAAK,CAAL,MAAY,GAA1D,CAAJ,EAAoE;AAClE1D;AACD;AACF;AACF,GA5BD;;AA8BA,SAAO,EAACA,kBAAD,EAAWC,kBAAX,EAAP;AACD","file":"merge.js","sourcesContent":["import {structuredPatch} from './create';\nimport {parsePatch} from './parse';\n\nimport {arrayEqual, arrayStartsWith} from '../util/array';\n\nexport function calcLineCount(hunk) {\n  const {oldLines, newLines} = calcOldNewLineCount(hunk.lines);\n\n  if (oldLines !== undefined) {\n    hunk.oldLines = oldLines;\n  } else {\n    delete hunk.oldLines;\n  }\n\n  if (newLines !== undefined) {\n    hunk.newLines = newLines;\n  } else {\n    delete hunk.newLines;\n  }\n}\n\nexport function merge(mine, theirs, base) {\n  mine = loadPatch(mine, base);\n  theirs = loadPatch(theirs, base);\n\n  let ret = {};\n\n  // For index we just let it pass through as it doesn't have any necessary meaning.\n  // Leaving sanity checks on this to the API consumer that may know more about the\n  // meaning in their own context.\n  if (mine.index || theirs.index) {\n    ret.index = mine.index || theirs.index;\n  }\n\n  if (mine.newFileName || theirs.newFileName) {\n    if (!fileNameChanged(mine)) {\n      // No header or no change in ours, use theirs (and ours if theirs does not exist)\n      ret.oldFileName = theirs.oldFileName || mine.oldFileName;\n      ret.newFileName = theirs.newFileName || mine.newFileName;\n      ret.oldHeader = theirs.oldHeader || mine.oldHeader;\n      ret.newHeader = theirs.newHeader || mine.newHeader;\n    } else if (!fileNameChanged(theirs)) {\n      // No header or no change in theirs, use ours\n      ret.oldFileName = mine.oldFileName;\n      ret.newFileName = mine.newFileName;\n      ret.oldHeader = mine.oldHeader;\n      ret.newHeader = mine.newHeader;\n    } else {\n      // Both changed... figure it out\n      ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);\n      ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);\n      ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);\n      ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);\n    }\n  }\n\n  ret.hunks = [];\n\n  let mineIndex = 0,\n      theirsIndex = 0,\n      mineOffset = 0,\n      theirsOffset = 0;\n\n  while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {\n    let mineCurrent = mine.hunks[mineIndex] || {oldStart: Infinity},\n        theirsCurrent = theirs.hunks[theirsIndex] || {oldStart: Infinity};\n\n    if (hunkBefore(mineCurrent, theirsCurrent)) {\n      // This patch does not overlap with any of the others, yay.\n      ret.hunks.push(cloneHunk(mineCurrent, mineOffset));\n      mineIndex++;\n      theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;\n    } else if (hunkBefore(theirsCurrent, mineCurrent)) {\n      // This patch does not overlap with any of the others, yay.\n      ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));\n      theirsIndex++;\n      mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;\n    } else {\n      // Overlap, merge as best we can\n      let mergedHunk = {\n        oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),\n        oldLines: 0,\n        newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),\n        newLines: 0,\n        lines: []\n      };\n      mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);\n      theirsIndex++;\n      mineIndex++;\n\n      ret.hunks.push(mergedHunk);\n    }\n  }\n\n  return ret;\n}\n\nfunction loadPatch(param, base) {\n  if (typeof param === 'string') {\n    if (/^@@/m.test(param) || (/^Index:/m.test(param))) {\n      return parsePatch(param)[0];\n    }\n\n    if (!base) {\n      throw new Error('Must provide a base reference or pass in a patch');\n    }\n    return structuredPatch(undefined, undefined, base, param);\n  }\n\n  return param;\n}\n\nfunction fileNameChanged(patch) {\n  return patch.newFileName && patch.newFileName !== patch.oldFileName;\n}\n\nfunction selectField(index, mine, theirs) {\n  if (mine === theirs) {\n    return mine;\n  } else {\n    index.conflict = true;\n    return {mine, theirs};\n  }\n}\n\nfunction hunkBefore(test, check) {\n  return test.oldStart < check.oldStart\n    && (test.oldStart + test.oldLines) < check.oldStart;\n}\n\nfunction cloneHunk(hunk, offset) {\n  return {\n    oldStart: hunk.oldStart, oldLines: hunk.oldLines,\n    newStart: hunk.newStart + offset, newLines: hunk.newLines,\n    lines: hunk.lines\n  };\n}\n\nfunction mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {\n  // This will generally result in a conflicted hunk, but there are cases where the context\n  // is the only overlap where we can successfully merge the content here.\n  let mine = {offset: mineOffset, lines: mineLines, index: 0},\n      their = {offset: theirOffset, lines: theirLines, index: 0};\n\n  // Handle any leading content\n  insertLeading(hunk, mine, their);\n  insertLeading(hunk, their, mine);\n\n  // Now in the overlap content. Scan through and select the best changes from each.\n  while (mine.index < mine.lines.length && their.index < their.lines.length) {\n    let mineCurrent = mine.lines[mine.index],\n        theirCurrent = their.lines[their.index];\n\n    if ((mineCurrent[0] === '-' || mineCurrent[0] === '+')\n        && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) {\n      // Both modified ...\n      mutualChange(hunk, mine, their);\n    } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {\n      // Mine inserted\n      hunk.lines.push(... collectChange(mine));\n    } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {\n      // Theirs inserted\n      hunk.lines.push(... collectChange(their));\n    } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') {\n      // Mine removed or edited\n      removal(hunk, mine, their);\n    } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') {\n      // Their removed or edited\n      removal(hunk, their, mine, true);\n    } else if (mineCurrent === theirCurrent) {\n      // Context identity\n      hunk.lines.push(mineCurrent);\n      mine.index++;\n      their.index++;\n    } else {\n      // Context mismatch\n      conflict(hunk, collectChange(mine), collectChange(their));\n    }\n  }\n\n  // Now push anything that may be remaining\n  insertTrailing(hunk, mine);\n  insertTrailing(hunk, their);\n\n  calcLineCount(hunk);\n}\n\nfunction mutualChange(hunk, mine, their) {\n  let myChanges = collectChange(mine),\n      theirChanges = collectChange(their);\n\n  if (allRemoves(myChanges) && allRemoves(theirChanges)) {\n    // Special case for remove changes that are supersets of one another\n    if (arrayStartsWith(myChanges, theirChanges)\n        && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {\n      hunk.lines.push(... myChanges);\n      return;\n    } else if (arrayStartsWith(theirChanges, myChanges)\n        && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {\n      hunk.lines.push(... theirChanges);\n      return;\n    }\n  } else if (arrayEqual(myChanges, theirChanges)) {\n    hunk.lines.push(... myChanges);\n    return;\n  }\n\n  conflict(hunk, myChanges, theirChanges);\n}\n\nfunction removal(hunk, mine, their, swap) {\n  let myChanges = collectChange(mine),\n      theirChanges = collectContext(their, myChanges);\n  if (theirChanges.merged) {\n    hunk.lines.push(... theirChanges.merged);\n  } else {\n    conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);\n  }\n}\n\nfunction conflict(hunk, mine, their) {\n  hunk.conflict = true;\n  hunk.lines.push({\n    conflict: true,\n    mine: mine,\n    theirs: their\n  });\n}\n\nfunction insertLeading(hunk, insert, their) {\n  while (insert.offset < their.offset && insert.index < insert.lines.length) {\n    let line = insert.lines[insert.index++];\n    hunk.lines.push(line);\n    insert.offset++;\n  }\n}\nfunction insertTrailing(hunk, insert) {\n  while (insert.index < insert.lines.length) {\n    let line = insert.lines[insert.index++];\n    hunk.lines.push(line);\n  }\n}\n\nfunction collectChange(state) {\n  let ret = [],\n      operation = state.lines[state.index][0];\n  while (state.index < state.lines.length) {\n    let line = state.lines[state.index];\n\n    // Group additions that are immediately after subtractions and treat them as one \"atomic\" modify change.\n    if (operation === '-' && line[0] === '+') {\n      operation = '+';\n    }\n\n    if (operation === line[0]) {\n      ret.push(line);\n      state.index++;\n    } else {\n      break;\n    }\n  }\n\n  return ret;\n}\nfunction collectContext(state, matchChanges) {\n  let changes = [],\n      merged = [],\n      matchIndex = 0,\n      contextChanges = false,\n      conflicted = false;\n  while (matchIndex < matchChanges.length\n        && state.index < state.lines.length) {\n    let change = state.lines[state.index],\n        match = matchChanges[matchIndex];\n\n    // Once we've hit our add, then we are done\n    if (match[0] === '+') {\n      break;\n    }\n\n    contextChanges = contextChanges || change[0] !== ' ';\n\n    merged.push(match);\n    matchIndex++;\n\n    // Consume any additions in the other block as a conflict to attempt\n    // to pull in the remaining context after this\n    if (change[0] === '+') {\n      conflicted = true;\n\n      while (change[0] === '+') {\n        changes.push(change);\n        change = state.lines[++state.index];\n      }\n    }\n\n    if (match.substr(1) === change.substr(1)) {\n      changes.push(change);\n      state.index++;\n    } else {\n      conflicted = true;\n    }\n  }\n\n  if ((matchChanges[matchIndex] || '')[0] === '+'\n      && contextChanges) {\n    conflicted = true;\n  }\n\n  if (conflicted) {\n    return changes;\n  }\n\n  while (matchIndex < matchChanges.length) {\n    merged.push(matchChanges[matchIndex++]);\n  }\n\n  return {\n    merged,\n    changes\n  };\n}\n\nfunction allRemoves(changes) {\n  return changes.reduce(function(prev, change) {\n    return prev && change[0] === '-';\n  }, true);\n}\nfunction skipRemoveSuperset(state, removeChanges, delta) {\n  for (let i = 0; i < delta; i++) {\n    let changeContent = removeChanges[removeChanges.length - delta + i].substr(1);\n    if (state.lines[state.index + i] !== ' ' + changeContent) {\n      return false;\n    }\n  }\n\n  state.index += delta;\n  return true;\n}\n\nfunction calcOldNewLineCount(lines) {\n  let oldLines = 0;\n  let newLines = 0;\n\n  lines.forEach(function(line) {\n    if (typeof line !== 'string') {\n      let myCount = calcOldNewLineCount(line.mine);\n      let theirCount = calcOldNewLineCount(line.theirs);\n\n      if (oldLines !== undefined) {\n        if (myCount.oldLines === theirCount.oldLines) {\n          oldLines += myCount.oldLines;\n        } else {\n          oldLines = undefined;\n        }\n      }\n\n      if (newLines !== undefined) {\n        if (myCount.newLines === theirCount.newLines) {\n          newLines += myCount.newLines;\n        } else {\n          newLines = undefined;\n        }\n      }\n    } else {\n      if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {\n        newLines++;\n      }\n      if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {\n        oldLines++;\n      }\n    }\n  });\n\n  return {oldLines, newLines};\n}\n"]} + + +/***/ }), +/* 14 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/structuredPatch = structuredPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = createTwoFilesPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = createPatch; + + var /*istanbul ignore start*/_line = __webpack_require__(5) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + + /*istanbul ignore end*/function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { + if (!options) { + options = {}; + } + if (typeof options.context === 'undefined') { + options.context = 4; + } + + var diff = /*istanbul ignore start*/(0, _line.diffLines) /*istanbul ignore end*/(oldStr, newStr, options); + diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier + + function contextLines(lines) { + return lines.map(function (entry) { + return ' ' + entry; + }); + } + + var hunks = []; + var oldRangeStart = 0, + newRangeStart = 0, + curRange = [], + oldLine = 1, + newLine = 1; + + /*istanbul ignore start*/var _loop = function _loop( /*istanbul ignore end*/i) { + var current = diff[i], + lines = current.lines || current.value.replace(/\n$/, '').split('\n'); + current.lines = lines; + + if (current.added || current.removed) { + /*istanbul ignore start*/var _curRange; + + /*istanbul ignore end*/ // If we have previous context, start with that + if (!oldRangeStart) { + var prev = diff[i - 1]; + oldRangeStart = oldLine; + newRangeStart = newLine; + + if (prev) { + curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : []; + oldRangeStart -= curRange.length; + newRangeStart -= curRange.length; + } + } + + // Output our changes + /*istanbul ignore start*/(_curRange = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/lines.map(function (entry) { + return (current.added ? '+' : '-') + entry; + }))); + + // Track the updated file position + if (current.added) { + newLine += lines.length; + } else { + oldLine += lines.length; + } + } else { + // Identical context lines. Track line changes + if (oldRangeStart) { + // Close out any changes that have been output (or join overlapping) + if (lines.length <= options.context * 2 && i < diff.length - 2) { + /*istanbul ignore start*/var _curRange2; + + /*istanbul ignore end*/ // Overlapping + /*istanbul ignore start*/(_curRange2 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange2 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines))); + } else { + /*istanbul ignore start*/var _curRange3; + + /*istanbul ignore end*/ // end the range and output + var contextSize = Math.min(lines.length, options.context); + /*istanbul ignore start*/(_curRange3 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange3 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines.slice(0, contextSize)))); + + var hunk = { + oldStart: oldRangeStart, + oldLines: oldLine - oldRangeStart + contextSize, + newStart: newRangeStart, + newLines: newLine - newRangeStart + contextSize, + lines: curRange + }; + if (i >= diff.length - 2 && lines.length <= options.context) { + // EOF is inside this hunk + var oldEOFNewline = /\n$/.test(oldStr); + var newEOFNewline = /\n$/.test(newStr); + if (lines.length == 0 && !oldEOFNewline) { + // special case: old has no eol and no trailing context; no-nl can end up before adds + curRange.splice(hunk.oldLines, 0, '\\ No newline at end of file'); + } else if (!oldEOFNewline || !newEOFNewline) { + curRange.push('\\ No newline at end of file'); + } + } + hunks.push(hunk); + + oldRangeStart = 0; + newRangeStart = 0; + curRange = []; + } + } + oldLine += lines.length; + newLine += lines.length; + } + }; + + for (var i = 0; i < diff.length; i++) { + /*istanbul ignore start*/_loop( /*istanbul ignore end*/i); + } + + return { + oldFileName: oldFileName, newFileName: newFileName, + oldHeader: oldHeader, newHeader: newHeader, + hunks: hunks + }; + } + + function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { + var diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options); + + var ret = []; + if (oldFileName == newFileName) { + ret.push('Index: ' + oldFileName); + } + ret.push('==================================================================='); + ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader)); + ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader)); + + for (var i = 0; i < diff.hunks.length; i++) { + var hunk = diff.hunks[i]; + ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@'); + ret.push.apply(ret, hunk.lines); + } + + return ret.join('\n') + '\n'; + } + + function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) { + return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/create.js"],"names":["structuredPatch","createTwoFilesPatch","createPatch","oldFileName","newFileName","oldStr","newStr","oldHeader","newHeader","options","context","diff","push","value","lines","contextLines","map","entry","hunks","oldRangeStart","newRangeStart","curRange","oldLine","newLine","i","current","replace","split","added","removed","prev","slice","length","contextSize","Math","min","hunk","oldStart","oldLines","newStart","newLines","oldEOFNewline","test","newEOFNewline","splice","ret","apply","join","fileName"],"mappings":";;;gCAEgBA,e,GAAAA,e;yDAiGAC,mB,GAAAA,mB;yDAwBAC,W,GAAAA,W;;AA3HhB;;;;uBAEO,SAASF,eAAT,CAAyBG,WAAzB,EAAsCC,WAAtC,EAAmDC,MAAnD,EAA2DC,MAA3D,EAAmEC,SAAnE,EAA8EC,SAA9E,EAAyFC,OAAzF,EAAkG;AACvG,MAAI,CAACA,OAAL,EAAc;AACZA,cAAU,EAAV;AACD;AACD,MAAI,OAAOA,QAAQC,OAAf,KAA2B,WAA/B,EAA4C;AAC1CD,YAAQC,OAAR,GAAkB,CAAlB;AACD;;AAED,MAAMC,OAAO,sEAAUN,MAAV,EAAkBC,MAAlB,EAA0BG,OAA1B,CAAb;AACAE,OAAKC,IAAL,CAAU,EAACC,OAAO,EAAR,EAAYC,OAAO,EAAnB,EAAV,EATuG,CASlE;;AAErC,WAASC,YAAT,CAAsBD,KAAtB,EAA6B;AAC3B,WAAOA,MAAME,GAAN,CAAU,UAASC,KAAT,EAAgB;AAAE,aAAO,MAAMA,KAAb;AAAqB,KAAjD,CAAP;AACD;;AAED,MAAIC,QAAQ,EAAZ;AACA,MAAIC,gBAAgB,CAApB;AAAA,MAAuBC,gBAAgB,CAAvC;AAAA,MAA0CC,WAAW,EAArD;AAAA,MACIC,UAAU,CADd;AAAA,MACiBC,UAAU,CAD3B;;AAhBuG,8EAkB9FC,CAlB8F;AAmBrG,QAAMC,UAAUd,KAAKa,CAAL,CAAhB;AAAA,QACMV,QAAQW,QAAQX,KAAR,IAAiBW,QAAQZ,KAAR,CAAca,OAAd,CAAsB,KAAtB,EAA6B,EAA7B,EAAiCC,KAAjC,CAAuC,IAAvC,CAD/B;AAEAF,YAAQX,KAAR,GAAgBA,KAAhB;;AAEA,QAAIW,QAAQG,KAAR,IAAiBH,QAAQI,OAA7B,EAAsC;AAAA;;AAAA,8BACpC;AACA,UAAI,CAACV,aAAL,EAAoB;AAClB,YAAMW,OAAOnB,KAAKa,IAAI,CAAT,CAAb;AACAL,wBAAgBG,OAAhB;AACAF,wBAAgBG,OAAhB;;AAEA,YAAIO,IAAJ,EAAU;AACRT,qBAAWZ,QAAQC,OAAR,GAAkB,CAAlB,GAAsBK,aAAae,KAAKhB,KAAL,CAAWiB,KAAX,CAAiB,CAACtB,QAAQC,OAA1B,CAAb,CAAtB,GAAyE,EAApF;AACAS,2BAAiBE,SAASW,MAA1B;AACAZ,2BAAiBC,SAASW,MAA1B;AACD;AACF;;AAED;AACA,6EAASpB,IAAT,0LAAkBE,MAAME,GAAN,CAAU,UAASC,KAAT,EAAgB;AAC1C,eAAO,CAACQ,QAAQG,KAAR,GAAgB,GAAhB,GAAsB,GAAvB,IAA8BX,KAArC;AACD,OAFiB,CAAlB;;AAIA;AACA,UAAIQ,QAAQG,KAAZ,EAAmB;AACjBL,mBAAWT,MAAMkB,MAAjB;AACD,OAFD,MAEO;AACLV,mBAAWR,MAAMkB,MAAjB;AACD;AACF,KAzBD,MAyBO;AACL;AACA,UAAIb,aAAJ,EAAmB;AACjB;AACA,YAAIL,MAAMkB,MAAN,IAAgBvB,QAAQC,OAAR,GAAkB,CAAlC,IAAuCc,IAAIb,KAAKqB,MAAL,GAAc,CAA7D,EAAgE;AAAA;;AAAA,kCAC9D;AACA,kFAASpB,IAAT,2LAAkBG,aAAaD,KAAb,CAAlB;AACD,SAHD,MAGO;AAAA;;AAAA,kCACL;AACA,cAAImB,cAAcC,KAAKC,GAAL,CAASrB,MAAMkB,MAAf,EAAuBvB,QAAQC,OAA/B,CAAlB;AACA,kFAASE,IAAT,2LAAkBG,aAAaD,MAAMiB,KAAN,CAAY,CAAZ,EAAeE,WAAf,CAAb,CAAlB;;AAEA,cAAIG,OAAO;AACTC,sBAAUlB,aADD;AAETmB,sBAAWhB,UAAUH,aAAV,GAA0Bc,WAF5B;AAGTM,sBAAUnB,aAHD;AAIToB,sBAAWjB,UAAUH,aAAV,GAA0Ba,WAJ5B;AAKTnB,mBAAOO;AALE,WAAX;AAOA,cAAIG,KAAKb,KAAKqB,MAAL,GAAc,CAAnB,IAAwBlB,MAAMkB,MAAN,IAAgBvB,QAAQC,OAApD,EAA6D;AAC3D;AACA,gBAAI+B,gBAAiB,MAAMC,IAAN,CAAWrC,MAAX,CAArB;AACA,gBAAIsC,gBAAiB,MAAMD,IAAN,CAAWpC,MAAX,CAArB;AACA,gBAAIQ,MAAMkB,MAAN,IAAgB,CAAhB,IAAqB,CAACS,aAA1B,EAAyC;AACvC;AACApB,uBAASuB,MAAT,CAAgBR,KAAKE,QAArB,EAA+B,CAA/B,EAAkC,8BAAlC;AACD,aAHD,MAGO,IAAI,CAACG,aAAD,IAAkB,CAACE,aAAvB,EAAsC;AAC3CtB,uBAAST,IAAT,CAAc,8BAAd;AACD;AACF;AACDM,gBAAMN,IAAN,CAAWwB,IAAX;;AAEAjB,0BAAgB,CAAhB;AACAC,0BAAgB,CAAhB;AACAC,qBAAW,EAAX;AACD;AACF;AACDC,iBAAWR,MAAMkB,MAAjB;AACAT,iBAAWT,MAAMkB,MAAjB;AACD;AAvFoG;;AAkBvG,OAAK,IAAIR,IAAI,CAAb,EAAgBA,IAAIb,KAAKqB,MAAzB,EAAiCR,GAAjC,EAAsC;AAAA,2DAA7BA,CAA6B;AAsErC;;AAED,SAAO;AACLrB,iBAAaA,WADR,EACqBC,aAAaA,WADlC;AAELG,eAAWA,SAFN,EAEiBC,WAAWA,SAF5B;AAGLU,WAAOA;AAHF,GAAP;AAKD;;AAEM,SAASjB,mBAAT,CAA6BE,WAA7B,EAA0CC,WAA1C,EAAuDC,MAAvD,EAA+DC,MAA/D,EAAuEC,SAAvE,EAAkFC,SAAlF,EAA6FC,OAA7F,EAAsG;AAC3G,MAAME,OAAOX,gBAAgBG,WAAhB,EAA6BC,WAA7B,EAA0CC,MAA1C,EAAkDC,MAAlD,EAA0DC,SAA1D,EAAqEC,SAArE,EAAgFC,OAAhF,CAAb;;AAEA,MAAMoC,MAAM,EAAZ;AACA,MAAI1C,eAAeC,WAAnB,EAAgC;AAC9ByC,QAAIjC,IAAJ,CAAS,YAAYT,WAArB;AACD;AACD0C,MAAIjC,IAAJ,CAAS,qEAAT;AACAiC,MAAIjC,IAAJ,CAAS,SAASD,KAAKR,WAAd,IAA6B,OAAOQ,KAAKJ,SAAZ,KAA0B,WAA1B,GAAwC,EAAxC,GAA6C,OAAOI,KAAKJ,SAAtF,CAAT;AACAsC,MAAIjC,IAAJ,CAAS,SAASD,KAAKP,WAAd,IAA6B,OAAOO,KAAKH,SAAZ,KAA0B,WAA1B,GAAwC,EAAxC,GAA6C,OAAOG,KAAKH,SAAtF,CAAT;;AAEA,OAAK,IAAIgB,IAAI,CAAb,EAAgBA,IAAIb,KAAKO,KAAL,CAAWc,MAA/B,EAAuCR,GAAvC,EAA4C;AAC1C,QAAMY,OAAOzB,KAAKO,KAAL,CAAWM,CAAX,CAAb;AACAqB,QAAIjC,IAAJ,CACE,SAASwB,KAAKC,QAAd,GAAyB,GAAzB,GAA+BD,KAAKE,QAApC,GACE,IADF,GACSF,KAAKG,QADd,GACyB,GADzB,GAC+BH,KAAKI,QADpC,GAEE,KAHJ;AAKAK,QAAIjC,IAAJ,CAASkC,KAAT,CAAeD,GAAf,EAAoBT,KAAKtB,KAAzB;AACD;;AAED,SAAO+B,IAAIE,IAAJ,CAAS,IAAT,IAAiB,IAAxB;AACD;;AAEM,SAAS7C,WAAT,CAAqB8C,QAArB,EAA+B3C,MAA/B,EAAuCC,MAAvC,EAA+CC,SAA/C,EAA0DC,SAA1D,EAAqEC,OAArE,EAA8E;AACnF,SAAOR,oBAAoB+C,QAApB,EAA8BA,QAA9B,EAAwC3C,MAAxC,EAAgDC,MAAhD,EAAwDC,SAAxD,EAAmEC,SAAnE,EAA8EC,OAA9E,CAAP;AACD","file":"create.js","sourcesContent":["import {diffLines} from '../diff/line';\n\nexport function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  if (!options) {\n    options = {};\n  }\n  if (typeof options.context === 'undefined') {\n    options.context = 4;\n  }\n\n  const diff = diffLines(oldStr, newStr, options);\n  diff.push({value: '', lines: []});   // Append an empty value to make cleanup easier\n\n  function contextLines(lines) {\n    return lines.map(function(entry) { return ' ' + entry; });\n  }\n\n  let hunks = [];\n  let oldRangeStart = 0, newRangeStart = 0, curRange = [],\n      oldLine = 1, newLine = 1;\n  for (let i = 0; i < diff.length; i++) {\n    const current = diff[i],\n          lines = current.lines || current.value.replace(/\\n$/, '').split('\\n');\n    current.lines = lines;\n\n    if (current.added || current.removed) {\n      // If we have previous context, start with that\n      if (!oldRangeStart) {\n        const prev = diff[i - 1];\n        oldRangeStart = oldLine;\n        newRangeStart = newLine;\n\n        if (prev) {\n          curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];\n          oldRangeStart -= curRange.length;\n          newRangeStart -= curRange.length;\n        }\n      }\n\n      // Output our changes\n      curRange.push(... lines.map(function(entry) {\n        return (current.added ? '+' : '-') + entry;\n      }));\n\n      // Track the updated file position\n      if (current.added) {\n        newLine += lines.length;\n      } else {\n        oldLine += lines.length;\n      }\n    } else {\n      // Identical context lines. Track line changes\n      if (oldRangeStart) {\n        // Close out any changes that have been output (or join overlapping)\n        if (lines.length <= options.context * 2 && i < diff.length - 2) {\n          // Overlapping\n          curRange.push(... contextLines(lines));\n        } else {\n          // end the range and output\n          let contextSize = Math.min(lines.length, options.context);\n          curRange.push(... contextLines(lines.slice(0, contextSize)));\n\n          let hunk = {\n            oldStart: oldRangeStart,\n            oldLines: (oldLine - oldRangeStart + contextSize),\n            newStart: newRangeStart,\n            newLines: (newLine - newRangeStart + contextSize),\n            lines: curRange\n          };\n          if (i >= diff.length - 2 && lines.length <= options.context) {\n            // EOF is inside this hunk\n            let oldEOFNewline = (/\\n$/.test(oldStr));\n            let newEOFNewline = (/\\n$/.test(newStr));\n            if (lines.length == 0 && !oldEOFNewline) {\n              // special case: old has no eol and no trailing context; no-nl can end up before adds\n              curRange.splice(hunk.oldLines, 0, '\\\\ No newline at end of file');\n            } else if (!oldEOFNewline || !newEOFNewline) {\n              curRange.push('\\\\ No newline at end of file');\n            }\n          }\n          hunks.push(hunk);\n\n          oldRangeStart = 0;\n          newRangeStart = 0;\n          curRange = [];\n        }\n      }\n      oldLine += lines.length;\n      newLine += lines.length;\n    }\n  }\n\n  return {\n    oldFileName: oldFileName, newFileName: newFileName,\n    oldHeader: oldHeader, newHeader: newHeader,\n    hunks: hunks\n  };\n}\n\nexport function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  const diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);\n\n  const ret = [];\n  if (oldFileName == newFileName) {\n    ret.push('Index: ' + oldFileName);\n  }\n  ret.push('===================================================================');\n  ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\\t' + diff.oldHeader));\n  ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\\t' + diff.newHeader));\n\n  for (let i = 0; i < diff.hunks.length; i++) {\n    const hunk = diff.hunks[i];\n    ret.push(\n      '@@ -' + hunk.oldStart + ',' + hunk.oldLines\n      + ' +' + hunk.newStart + ',' + hunk.newLines\n      + ' @@'\n    );\n    ret.push.apply(ret, hunk.lines);\n  }\n\n  return ret.join('\\n') + '\\n';\n}\n\nexport function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n"]} + + +/***/ }), +/* 15 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/"use strict"; + + exports.__esModule = true; + exports. /*istanbul ignore end*/arrayEqual = arrayEqual; + /*istanbul ignore start*/exports. /*istanbul ignore end*/arrayStartsWith = arrayStartsWith; + function arrayEqual(a, b) { + if (a.length !== b.length) { + return false; + } + + return arrayStartsWith(a, b); + } + + function arrayStartsWith(array, start) { + if (start.length > array.length) { + return false; + } + + for (var i = 0; i < start.length; i++) { + if (start[i] !== array[i]) { + return false; + } + } + + return true; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL2FycmF5LmpzIl0sIm5hbWVzIjpbImFycmF5RXF1YWwiLCJhcnJheVN0YXJ0c1dpdGgiLCJhIiwiYiIsImxlbmd0aCIsImFycmF5Iiwic3RhcnQiLCJpIl0sIm1hcHBpbmdzIjoiOzs7Z0NBQWdCQSxVLEdBQUFBLFU7eURBUUFDLGUsR0FBQUEsZTtBQVJULFNBQVNELFVBQVQsQ0FBb0JFLENBQXBCLEVBQXVCQyxDQUF2QixFQUEwQjtBQUMvQixNQUFJRCxFQUFFRSxNQUFGLEtBQWFELEVBQUVDLE1BQW5CLEVBQTJCO0FBQ3pCLFdBQU8sS0FBUDtBQUNEOztBQUVELFNBQU9ILGdCQUFnQkMsQ0FBaEIsRUFBbUJDLENBQW5CLENBQVA7QUFDRDs7QUFFTSxTQUFTRixlQUFULENBQXlCSSxLQUF6QixFQUFnQ0MsS0FBaEMsRUFBdUM7QUFDNUMsTUFBSUEsTUFBTUYsTUFBTixHQUFlQyxNQUFNRCxNQUF6QixFQUFpQztBQUMvQixXQUFPLEtBQVA7QUFDRDs7QUFFRCxPQUFLLElBQUlHLElBQUksQ0FBYixFQUFnQkEsSUFBSUQsTUFBTUYsTUFBMUIsRUFBa0NHLEdBQWxDLEVBQXVDO0FBQ3JDLFFBQUlELE1BQU1DLENBQU4sTUFBYUYsTUFBTUUsQ0FBTixDQUFqQixFQUEyQjtBQUN6QixhQUFPLEtBQVA7QUFDRDtBQUNGOztBQUVELFNBQU8sSUFBUDtBQUNEIiwiZmlsZSI6ImFycmF5LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGFycmF5RXF1YWwoYSwgYikge1xuICBpZiAoYS5sZW5ndGggIT09IGIubGVuZ3RoKSB7XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG5cbiAgcmV0dXJuIGFycmF5U3RhcnRzV2l0aChhLCBiKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGFycmF5U3RhcnRzV2l0aChhcnJheSwgc3RhcnQpIHtcbiAgaWYgKHN0YXJ0Lmxlbmd0aCA+IGFycmF5Lmxlbmd0aCkge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuXG4gIGZvciAobGV0IGkgPSAwOyBpIDwgc3RhcnQubGVuZ3RoOyBpKyspIHtcbiAgICBpZiAoc3RhcnRbaV0gIT09IGFycmF5W2ldKSB7XG4gICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIHRydWU7XG59XG4iXX0= + + +/***/ }), +/* 16 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/"use strict"; + + exports.__esModule = true; + exports. /*istanbul ignore end*/convertChangesToDMP = convertChangesToDMP; + // See: http://code.google.com/p/google-diff-match-patch/wiki/API + function convertChangesToDMP(changes) { + var ret = [], + change = /*istanbul ignore start*/void 0 /*istanbul ignore end*/, + operation = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + for (var i = 0; i < changes.length; i++) { + change = changes[i]; + if (change.added) { + operation = 1; + } else if (change.removed) { + operation = -1; + } else { + operation = 0; + } + + ret.push([operation, change.value]); + } + return ret; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb252ZXJ0L2RtcC5qcyJdLCJuYW1lcyI6WyJjb252ZXJ0Q2hhbmdlc1RvRE1QIiwiY2hhbmdlcyIsInJldCIsImNoYW5nZSIsIm9wZXJhdGlvbiIsImkiLCJsZW5ndGgiLCJhZGRlZCIsInJlbW92ZWQiLCJwdXNoIiwidmFsdWUiXSwibWFwcGluZ3MiOiI7OztnQ0FDZ0JBLG1CLEdBQUFBLG1CO0FBRGhCO0FBQ08sU0FBU0EsbUJBQVQsQ0FBNkJDLE9BQTdCLEVBQXNDO0FBQzNDLE1BQUlDLE1BQU0sRUFBVjtBQUFBLE1BQ0lDLHdDQURKO0FBQUEsTUFFSUMsMkNBRko7QUFHQSxPQUFLLElBQUlDLElBQUksQ0FBYixFQUFnQkEsSUFBSUosUUFBUUssTUFBNUIsRUFBb0NELEdBQXBDLEVBQXlDO0FBQ3ZDRixhQUFTRixRQUFRSSxDQUFSLENBQVQ7QUFDQSxRQUFJRixPQUFPSSxLQUFYLEVBQWtCO0FBQ2hCSCxrQkFBWSxDQUFaO0FBQ0QsS0FGRCxNQUVPLElBQUlELE9BQU9LLE9BQVgsRUFBb0I7QUFDekJKLGtCQUFZLENBQUMsQ0FBYjtBQUNELEtBRk0sTUFFQTtBQUNMQSxrQkFBWSxDQUFaO0FBQ0Q7O0FBRURGLFFBQUlPLElBQUosQ0FBUyxDQUFDTCxTQUFELEVBQVlELE9BQU9PLEtBQW5CLENBQVQ7QUFDRDtBQUNELFNBQU9SLEdBQVA7QUFDRCIsImZpbGUiOiJkbXAuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTZWU6IGh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vcC9nb29nbGUtZGlmZi1tYXRjaC1wYXRjaC93aWtpL0FQSVxuZXhwb3J0IGZ1bmN0aW9uIGNvbnZlcnRDaGFuZ2VzVG9ETVAoY2hhbmdlcykge1xuICBsZXQgcmV0ID0gW10sXG4gICAgICBjaGFuZ2UsXG4gICAgICBvcGVyYXRpb247XG4gIGZvciAobGV0IGkgPSAwOyBpIDwgY2hhbmdlcy5sZW5ndGg7IGkrKykge1xuICAgIGNoYW5nZSA9IGNoYW5nZXNbaV07XG4gICAgaWYgKGNoYW5nZS5hZGRlZCkge1xuICAgICAgb3BlcmF0aW9uID0gMTtcbiAgICB9IGVsc2UgaWYgKGNoYW5nZS5yZW1vdmVkKSB7XG4gICAgICBvcGVyYXRpb24gPSAtMTtcbiAgICB9IGVsc2Uge1xuICAgICAgb3BlcmF0aW9uID0gMDtcbiAgICB9XG5cbiAgICByZXQucHVzaChbb3BlcmF0aW9uLCBjaGFuZ2UudmFsdWVdKTtcbiAgfVxuICByZXR1cm4gcmV0O1xufVxuIl19 + + +/***/ }), +/* 17 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/convertChangesToXML = convertChangesToXML; + function convertChangesToXML(changes) { + var ret = []; + for (var i = 0; i < changes.length; i++) { + var change = changes[i]; + if (change.added) { + ret.push('<ins>'); + } else if (change.removed) { + ret.push('<del>'); + } + + ret.push(escapeHTML(change.value)); + + if (change.added) { + ret.push('</ins>'); + } else if (change.removed) { + ret.push('</del>'); + } + } + return ret.join(''); + } + + function escapeHTML(s) { + var n = s; + n = n.replace(/&/g, '&'); + n = n.replace(/</g, '<'); + n = n.replace(/>/g, '>'); + n = n.replace(/"/g, '"'); + + return n; + } + + +/***/ }) +/******/ ]) +}); +; + +/***/ }), + +/***/ 22: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["richText"]; }()); + +/***/ }), + +/***/ 220: +/***/ (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, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js +var arrayWithHoles = __webpack_require__(38); + +// 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__(39); + +// 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 */])(); +} + +/***/ }), + +/***/ 25: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["dom"]; }()); + +/***/ }), + +/***/ 26: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["url"]; }()); + +/***/ }), + +/***/ 27: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["hooks"]; }()); + +/***/ }), + +/***/ 28: +/***/ (function(module, exports) { + +(function() { module.exports = this["React"]; }()); + +/***/ }), + +/***/ 3: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["components"]; }()); + +/***/ }), + +/***/ 30: +/***/ (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); +} + +/***/ }), + +/***/ 31: +/***/ (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, __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, ReactIs; } else { + // By explicitly using `prop-types` you are opting into new production behavior. + // http://fb.me/prop-types-in-prod + module.exports = __webpack_require__(87)(); +} + + +/***/ }), + +/***/ 342: +/***/ (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, "resetBlocks", function() { return resetBlocks; }); +__webpack_require__.d(actions_namespaceObject, "receiveBlocks", function() { return receiveBlocks; }); +__webpack_require__.d(actions_namespaceObject, "updateBlockAttributes", function() { return actions_updateBlockAttributes; }); +__webpack_require__.d(actions_namespaceObject, "updateBlock", function() { return updateBlock; }); +__webpack_require__.d(actions_namespaceObject, "selectBlock", function() { return actions_selectBlock; }); +__webpack_require__.d(actions_namespaceObject, "selectPreviousBlock", function() { return selectPreviousBlock; }); +__webpack_require__.d(actions_namespaceObject, "selectNextBlock", function() { return selectNextBlock; }); +__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 actions_multiSelect; }); +__webpack_require__.d(actions_namespaceObject, "clearSelectedBlock", function() { return clearSelectedBlock; }); +__webpack_require__.d(actions_namespaceObject, "toggleSelection", function() { return actions_toggleSelection; }); +__webpack_require__.d(actions_namespaceObject, "replaceBlocks", function() { return actions_replaceBlocks; }); +__webpack_require__.d(actions_namespaceObject, "replaceBlock", function() { return replaceBlock; }); +__webpack_require__.d(actions_namespaceObject, "moveBlocksDown", function() { return actions_moveBlocksDown; }); +__webpack_require__.d(actions_namespaceObject, "moveBlocksUp", function() { return actions_moveBlocksUp; }); +__webpack_require__.d(actions_namespaceObject, "moveBlockToPosition", function() { return moveBlockToPosition; }); +__webpack_require__.d(actions_namespaceObject, "insertBlock", function() { return actions_insertBlock; }); +__webpack_require__.d(actions_namespaceObject, "insertBlocks", function() { return actions_insertBlocks; }); +__webpack_require__.d(actions_namespaceObject, "showInsertionPoint", function() { return actions_showInsertionPoint; }); +__webpack_require__.d(actions_namespaceObject, "hideInsertionPoint", function() { return actions_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 actions_mergeBlocks; }); +__webpack_require__.d(actions_namespaceObject, "removeBlocks", function() { return actions_removeBlocks; }); +__webpack_require__.d(actions_namespaceObject, "removeBlock", function() { return actions_removeBlock; }); +__webpack_require__.d(actions_namespaceObject, "replaceInnerBlocks", function() { return actions_replaceInnerBlocks; }); +__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, "selectionChange", function() { return selectionChange; }); +__webpack_require__.d(actions_namespaceObject, "insertDefaultBlock", function() { return actions_insertDefaultBlock; }); +__webpack_require__.d(actions_namespaceObject, "updateBlockListSettings", function() { return updateBlockListSettings; }); +__webpack_require__.d(actions_namespaceObject, "updateSettings", function() { return updateSettings; }); +__webpack_require__.d(actions_namespaceObject, "__unstableSaveReusableBlock", function() { return __unstableSaveReusableBlock; }); +__webpack_require__.d(actions_namespaceObject, "__unstableMarkLastChangeAsPersistent", function() { return actions_unstableMarkLastChangeAsPersistent; }); +__webpack_require__.d(actions_namespaceObject, "__unstableMarkAutomaticChange", function() { return __unstableMarkAutomaticChange; }); +__webpack_require__.d(actions_namespaceObject, "setNavigationMode", function() { return actions_setNavigationMode; }); +var selectors_namespaceObject = {}; +__webpack_require__.r(selectors_namespaceObject); +__webpack_require__.d(selectors_namespaceObject, "INSERTER_UTILITY_HIGH", function() { return INSERTER_UTILITY_HIGH; }); +__webpack_require__.d(selectors_namespaceObject, "INSERTER_UTILITY_MEDIUM", function() { return INSERTER_UTILITY_MEDIUM; }); +__webpack_require__.d(selectors_namespaceObject, "INSERTER_UTILITY_LOW", function() { return INSERTER_UTILITY_LOW; }); +__webpack_require__.d(selectors_namespaceObject, "INSERTER_UTILITY_NONE", function() { return INSERTER_UTILITY_NONE; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockName", function() { return selectors_getBlockName; }); +__webpack_require__.d(selectors_namespaceObject, "isBlockValid", function() { return selectors_isBlockValid; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockAttributes", function() { return getBlockAttributes; }); +__webpack_require__.d(selectors_namespaceObject, "getBlock", function() { return selectors_getBlock; }); +__webpack_require__.d(selectors_namespaceObject, "__unstableGetBlockWithoutInnerBlocks", function() { return selectors_unstableGetBlockWithoutInnerBlocks; }); +__webpack_require__.d(selectors_namespaceObject, "getBlocks", function() { return selectors_getBlocks; }); +__webpack_require__.d(selectors_namespaceObject, "getClientIdsOfDescendants", function() { return selectors_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 selectors_getBlocksByClientId; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockCount", function() { return selectors_getBlockCount; }); +__webpack_require__.d(selectors_namespaceObject, "getSelectionStart", function() { return getSelectionStart; }); +__webpack_require__.d(selectors_namespaceObject, "getSelectionEnd", function() { return getSelectionEnd; }); +__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 selectors_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 selectors_getSelectedBlock; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockRootClientId", function() { return selectors_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 selectors_getSelectedBlocksInitialCaretPosition; }); +__webpack_require__.d(selectors_namespaceObject, "getSelectedBlockClientIds", function() { return selectors_getSelectedBlockClientIds; }); +__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 selectors_isFirstMultiSelectedBlock; }); +__webpack_require__.d(selectors_namespaceObject, "isBlockMultiSelected", function() { return selectors_isBlockMultiSelected; }); +__webpack_require__.d(selectors_namespaceObject, "isAncestorMultiSelected", function() { return selectors_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 selectors_getBlockOrder; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockIndex", function() { return selectors_getBlockIndex; }); +__webpack_require__.d(selectors_namespaceObject, "isBlockSelected", function() { return selectors_isBlockSelected; }); +__webpack_require__.d(selectors_namespaceObject, "hasSelectedInnerBlock", function() { return selectors_hasSelectedInnerBlock; }); +__webpack_require__.d(selectors_namespaceObject, "isBlockWithinSelection", function() { return isBlockWithinSelection; }); +__webpack_require__.d(selectors_namespaceObject, "hasMultiSelection", function() { return selectors_hasMultiSelection; }); +__webpack_require__.d(selectors_namespaceObject, "isMultiSelecting", function() { return isMultiSelecting; }); +__webpack_require__.d(selectors_namespaceObject, "isSelectionEnabled", function() { return selectors_isSelectionEnabled; }); +__webpack_require__.d(selectors_namespaceObject, "getBlockMode", function() { return selectors_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 selectors_getTemplateLock; }); +__webpack_require__.d(selectors_namespaceObject, "canInsertBlockType", function() { return selectors_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; }); +__webpack_require__.d(selectors_namespaceObject, "getSettings", function() { return selectors_getSettings; }); +__webpack_require__.d(selectors_namespaceObject, "isLastBlockChangePersistent", function() { return selectors_isLastBlockChangePersistent; }); +__webpack_require__.d(selectors_namespaceObject, "__experimentalGetParsedReusableBlock", function() { return __experimentalGetParsedReusableBlock; }); +__webpack_require__.d(selectors_namespaceObject, "__unstableIsLastBlockChangeIgnored", function() { return selectors_unstableIsLastBlockChangeIgnored; }); +__webpack_require__.d(selectors_namespaceObject, "__experimentalGetLastBlockAttributeChanges", function() { return __experimentalGetLastBlockAttributeChanges; }); +__webpack_require__.d(selectors_namespaceObject, "isNavigationMode", function() { return selectors_isNavigationMode; }); +__webpack_require__.d(selectors_namespaceObject, "didAutomaticChange", function() { return selectors_didAutomaticChange; }); + +// EXTERNAL MODULE: external {"this":["wp","blocks"]} +var external_this_wp_blocks_ = __webpack_require__(9); + +// EXTERNAL MODULE: external {"this":["wp","richText"]} +var external_this_wp_richText_ = __webpack_require__(22); + +// EXTERNAL MODULE: external {"this":["wp","viewport"]} +var external_this_wp_viewport_ = __webpack_require__(42); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread.js +var objectSpread = __webpack_require__(7); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js +var esm_extends = __webpack_require__(18); + +// EXTERNAL MODULE: external {"this":["wp","element"]} +var external_this_wp_element_ = __webpack_require__(0); + +// EXTERNAL MODULE: ./node_modules/classnames/index.js +var classnames = __webpack_require__(16); +var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames); + +// EXTERNAL MODULE: external "lodash" +var external_lodash_ = __webpack_require__(2); + +// EXTERNAL MODULE: external {"this":["wp","compose"]} +var external_this_wp_compose_ = __webpack_require__(8); + +// EXTERNAL MODULE: external {"this":["wp","hooks"]} +var external_this_wp_hooks_ = __webpack_require__(27); + +// EXTERNAL MODULE: external {"this":["wp","data"]} +var external_this_wp_data_ = __webpack_require__(4); + +// EXTERNAL MODULE: ./node_modules/tinycolor2/tinycolor.js +var tinycolor = __webpack_require__(48); +var tinycolor_default = /*#__PURE__*/__webpack_require__.n(tinycolor); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/colors/utils.js +/** + * External dependencies + */ + + +/** + * Provided an array of color objects as set by the theme or by the editor defaults, + * and the values of the defined color or custom color returns a color object describing the color. + * + * @param {Array} colors Array of color objects as set by the theme or by the editor defaults. + * @param {?string} definedColor A string containing the color slug. + * @param {?string} customColor A string containing the customColor value. + * + * @return {?Object} If definedColor is passed and the name is found in colors, + * the color object exactly as set by the theme or editor defaults is returned. + * Otherwise, an object that just sets the color is defined. + */ + +var utils_getColorObjectByAttributeValues = function getColorObjectByAttributeValues(colors, definedColor, customColor) { + if (definedColor) { + var colorObj = Object(external_lodash_["find"])(colors, { + slug: definedColor + }); + + if (colorObj) { + return colorObj; + } + } + + return { + color: customColor + }; +}; +/** + * Provided an array of color objects as set by the theme or by the editor defaults, and a color value returns the color object matching that value or undefined. + * + * @param {Array} colors Array of color objects as set by the theme or by the editor defaults. + * @param {?string} colorValue A string containing the color value. + * + * @return {?Object} Color object included in the colors array whose color property equals colorValue. + * Returns undefined if no color object matches this requirement. + */ + +var utils_getColorObjectByColorValue = function getColorObjectByColorValue(colors, colorValue) { + return Object(external_lodash_["find"])(colors, { + color: colorValue + }); +}; +/** + * Returns a class based on the context a color is being used and its slug. + * + * @param {string} colorContextName Context/place where color is being used e.g: background, text etc... + * @param {string} colorSlug Slug of the color. + * + * @return {?string} String with the class corresponding to the color in the provided context. + * Returns undefined if either colorContextName or colorSlug are not provided. + */ + +function getColorClassName(colorContextName, colorSlug) { + if (!colorContextName || !colorSlug) { + return undefined; + } + + return "has-".concat(Object(external_lodash_["kebabCase"])(colorSlug), "-").concat(colorContextName); +} +/** + * Given an array of color objects and a color value returns the color value of the most readable color in the array. + * + * @param {Array} colors Array of color objects as set by the theme or by the editor defaults. + * @param {?string} colorValue A string containing the color value. + * + * @return {string} String with the color value of the most readable color. + */ + +function utils_getMostReadableColor(colors, colorValue) { + return tinycolor_default.a.mostReadable(colorValue, Object(external_lodash_["map"])(colors, 'color')).toHexString(); +} + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js +var classCallCheck = __webpack_require__(12); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js +var createClass = __webpack_require__(11); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js +var possibleConstructorReturn = __webpack_require__(13); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js +var getPrototypeOf = __webpack_require__(14); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js +var assertThisInitialized = __webpack_require__(5); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js + 1 modules +var inherits = __webpack_require__(15); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js +var defineProperty = __webpack_require__(10); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/colors/with-colors.js + + + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +var DEFAULT_COLORS = []; +/** + * Higher order component factory for injecting the `colorsArray` argument as + * the colors prop in the `withCustomColors` HOC. + * + * @param {Array} colorsArray An array of color objects. + * + * @return {Function} The higher order component. + */ + +var with_colors_withCustomColorPalette = function withCustomColorPalette(colorsArray) { + return Object(external_this_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { + return function (props) { + return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, props, { + colors: colorsArray + })); + }; + }, 'withCustomColorPalette'); +}; +/** + * Higher order component factory for injecting the editor colors as the + * `colors` prop in the `withColors` HOC. + * + * @return {Function} The higher order component. + */ + + +var with_colors_withEditorColorPalette = function withEditorColorPalette() { + return Object(external_this_wp_data_["withSelect"])(function (select) { + var settings = select('core/block-editor').getSettings(); + return { + colors: Object(external_lodash_["get"])(settings, ['colors'], DEFAULT_COLORS) + }; + }); +}; +/** + * Helper function used with `createHigherOrderComponent` to create + * higher order components for managing color logic. + * + * @param {Array} colorTypes An array of color types (e.g. 'backgroundColor, borderColor). + * @param {Function} withColorPalette A HOC for injecting the 'colors' prop into the WrappedComponent. + * + * @return {Component} The component that can be used as a HOC. + */ + + +function createColorHOC(colorTypes, withColorPalette) { + var colorMap = Object(external_lodash_["reduce"])(colorTypes, function (colorObject, colorType) { + return Object(objectSpread["a" /* default */])({}, colorObject, Object(external_lodash_["isString"])(colorType) ? Object(defineProperty["a" /* default */])({}, colorType, Object(external_lodash_["kebabCase"])(colorType)) : colorType); + }, {}); + return Object(external_this_wp_compose_["compose"])([withColorPalette, function (WrappedComponent) { + return ( + /*#__PURE__*/ + function (_Component) { + Object(inherits["a" /* default */])(_class, _Component); + + function _class(props) { + var _this; + + Object(classCallCheck["a" /* default */])(this, _class); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).call(this, props)); + _this.setters = _this.createSetters(); + _this.colorUtils = { + getMostReadableColor: _this.getMostReadableColor.bind(Object(assertThisInitialized["a" /* default */])(_this)) + }; + _this.state = {}; + return _this; + } + + Object(createClass["a" /* default */])(_class, [{ + key: "getMostReadableColor", + value: function getMostReadableColor(colorValue) { + var colors = this.props.colors; + return utils_getMostReadableColor(colors, colorValue); + } + }, { + key: "createSetters", + value: function createSetters() { + var _this2 = this; + + return Object(external_lodash_["reduce"])(colorMap, function (settersAccumulator, colorContext, colorAttributeName) { + var upperFirstColorAttributeName = Object(external_lodash_["upperFirst"])(colorAttributeName); + var customColorAttributeName = "custom".concat(upperFirstColorAttributeName); + settersAccumulator["set".concat(upperFirstColorAttributeName)] = _this2.createSetColor(colorAttributeName, customColorAttributeName); + return settersAccumulator; + }, {}); + } + }, { + key: "createSetColor", + value: function createSetColor(colorAttributeName, customColorAttributeName) { + var _this3 = this; + + return function (colorValue) { + var _this3$props$setAttri; + + var colorObject = utils_getColorObjectByColorValue(_this3.props.colors, colorValue); + + _this3.props.setAttributes((_this3$props$setAttri = {}, Object(defineProperty["a" /* default */])(_this3$props$setAttri, colorAttributeName, colorObject && colorObject.slug ? colorObject.slug : undefined), Object(defineProperty["a" /* default */])(_this3$props$setAttri, customColorAttributeName, colorObject && colorObject.slug ? undefined : colorValue), _this3$props$setAttri)); + }; + } + }, { + key: "render", + value: function render() { + return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(objectSpread["a" /* default */])({}, this.props, { + colors: undefined + }, this.state, this.setters, { + colorUtils: this.colorUtils + })); + } + }], [{ + key: "getDerivedStateFromProps", + value: function getDerivedStateFromProps(_ref2, previousState) { + var attributes = _ref2.attributes, + colors = _ref2.colors; + return Object(external_lodash_["reduce"])(colorMap, function (newState, colorContext, colorAttributeName) { + var colorObject = utils_getColorObjectByAttributeValues(colors, attributes[colorAttributeName], attributes["custom".concat(Object(external_lodash_["upperFirst"])(colorAttributeName))]); + var previousColorObject = previousState[colorAttributeName]; + var previousColor = Object(external_lodash_["get"])(previousColorObject, ['color']); + /** + * The "and previousColorObject" condition checks that a previous color object was already computed. + * At the start previousColorObject and colorValue are both equal to undefined + * bus as previousColorObject does not exist we should compute the object. + */ + + if (previousColor === colorObject.color && previousColorObject) { + newState[colorAttributeName] = previousColorObject; + } else { + newState[colorAttributeName] = Object(objectSpread["a" /* default */])({}, colorObject, { + class: getColorClassName(colorContext, colorObject.slug) + }); + } + + return newState; + }, {}); + } + }]); + + return _class; + }(external_this_wp_element_["Component"]) + ); + }]); +} +/** + * A higher-order component factory for creating a 'withCustomColors' HOC, which handles color logic + * for class generation color value, retrieval and color attribute setting. + * + * Use this higher-order component to work with a custom set of colors. + * + * @example + * + * ```jsx + * const CUSTOM_COLORS = [ { name: 'Red', slug: 'red', color: '#ff0000' }, { name: 'Blue', slug: 'blue', color: '#0000ff' } ]; + * const withCustomColors = createCustomColorsHOC( CUSTOM_COLORS ); + * // ... + * export default compose( + * withCustomColors( 'backgroundColor', 'borderColor' ), + * MyColorfulComponent, + * ); + * ``` + * + * @param {Array} colorsArray The array of color objects (name, slug, color, etc... ). + * + * @return {Function} Higher-order component. + */ + + +function createCustomColorsHOC(colorsArray) { + return function () { + var withColorPalette = with_colors_withCustomColorPalette(colorsArray); + + for (var _len = arguments.length, colorTypes = new Array(_len), _key = 0; _key < _len; _key++) { + colorTypes[_key] = arguments[_key]; + } + + return Object(external_this_wp_compose_["createHigherOrderComponent"])(createColorHOC(colorTypes, withColorPalette), 'withCustomColors'); + }; +} +/** + * A higher-order component, which handles color logic for class generation color value, retrieval and color attribute setting. + * + * For use with the default editor/theme color palette. + * + * @example + * + * ```jsx + * export default compose( + * withColors( 'backgroundColor', { textColor: 'color' } ), + * MyColorfulComponent, + * ); + * ``` + * + * @param {...(Object|string)} colorTypes The arguments can be strings or objects. If the argument is an object, + * it should contain the color attribute name as key and the color context as value. + * If the argument is a string the value should be the color attribute name, + * the color context is computed by applying a kebab case transform to the value. + * Color context represents the context/place where the color is going to be used. + * The class name of the color is generated using 'has' followed by the color name + * and ending with the color context all in kebab case e.g: has-green-background-color. + * + * @return {Function} Higher-order component. + */ + +function withColors() { + var withColorPalette = with_colors_withEditorColorPalette(); + + for (var _len2 = arguments.length, colorTypes = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + colorTypes[_key2] = arguments[_key2]; + } + + return Object(external_this_wp_compose_["createHigherOrderComponent"])(createColorHOC(colorTypes, withColorPalette), 'withColors'); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/colors/index.js + + + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/utils.js +/** + * External dependencies + */ + +/** + * Returns the font size object based on an array of named font sizes and the namedFontSize and customFontSize values. + * If namedFontSize is undefined or not found in fontSizes an object with just the size value based on customFontSize is returned. + * + * @param {Array} fontSizes Array of font size objects containing at least the "name" and "size" values as properties. + * @param {?string} fontSizeAttribute Content of the font size attribute (slug). + * @param {?number} customFontSizeAttribute Contents of the custom font size attribute (value). + * + * @return {?string} If fontSizeAttribute is set and an equal slug is found in fontSizes it returns the font size object for that slug. + * Otherwise, an object with just the size value based on customFontSize is returned. + */ + +var utils_getFontSize = function getFontSize(fontSizes, fontSizeAttribute, customFontSizeAttribute) { + if (fontSizeAttribute) { + var fontSizeObject = Object(external_lodash_["find"])(fontSizes, { + slug: fontSizeAttribute + }); + + if (fontSizeObject) { + return fontSizeObject; + } + } + + return { + size: customFontSizeAttribute + }; +}; +/** + * Returns a class based on fontSizeName. + * + * @param {string} fontSizeSlug Slug of the fontSize. + * + * @return {string} String with the class corresponding to the fontSize passed. + * The class is generated by appending 'has-' followed by fontSizeSlug in kebabCase and ending with '-font-size'. + */ + +function getFontSizeClass(fontSizeSlug) { + if (!fontSizeSlug) { + return; + } + + return "has-".concat(Object(external_lodash_["kebabCase"])(fontSizeSlug), "-font-size"); +} + +// EXTERNAL MODULE: external {"this":["wp","components"]} +var external_this_wp_components_ = __webpack_require__(3); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/font-size-picker.js +/** + * WordPress dependencies + */ + + +/* harmony default export */ var font_size_picker = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select$getSettings = select('core/block-editor').getSettings(), + disableCustomFontSizes = _select$getSettings.disableCustomFontSizes, + fontSizes = _select$getSettings.fontSizes; + + return { + disableCustomFontSizes: disableCustomFontSizes, + fontSizes: fontSizes + }; +})(external_this_wp_components_["FontSizePicker"])); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/with-font-sizes.js + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +/** + * Higher-order component, which handles font size logic for class generation, + * font size value retrieval, and font size change handling. + * + * @param {...(Object|string)} fontSizeNames The arguments should all be strings. + * Each string contains the font size + * attribute name e.g: 'fontSize'. + * + * @return {Function} Higher-order component. + */ + +/* harmony default export */ var with_font_sizes = (function () { + for (var _len = arguments.length, fontSizeNames = new Array(_len), _key = 0; _key < _len; _key++) { + fontSizeNames[_key] = arguments[_key]; + } + + /* + * Computes an object whose key is the font size attribute name as passed in the array, + * and the value is the custom font size attribute name. + * Custom font size is automatically compted by appending custom followed by the font size attribute name in with the first letter capitalized. + */ + var fontSizeAttributeNames = Object(external_lodash_["reduce"])(fontSizeNames, function (fontSizeAttributeNamesAccumulator, fontSizeAttributeName) { + fontSizeAttributeNamesAccumulator[fontSizeAttributeName] = "custom".concat(Object(external_lodash_["upperFirst"])(fontSizeAttributeName)); + return fontSizeAttributeNamesAccumulator; + }, {}); + return Object(external_this_wp_compose_["createHigherOrderComponent"])(Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select$getSettings = select('core/block-editor').getSettings(), + fontSizes = _select$getSettings.fontSizes; + + return { + fontSizes: fontSizes + }; + }), function (WrappedComponent) { + return ( + /*#__PURE__*/ + function (_Component) { + Object(inherits["a" /* default */])(_class, _Component); + + function _class(props) { + var _this; + + Object(classCallCheck["a" /* default */])(this, _class); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(_class).call(this, props)); + _this.setters = _this.createSetters(); + _this.state = {}; + return _this; + } + + Object(createClass["a" /* default */])(_class, [{ + key: "createSetters", + value: function createSetters() { + var _this2 = this; + + return Object(external_lodash_["reduce"])(fontSizeAttributeNames, function (settersAccumulator, customFontSizeAttributeName, fontSizeAttributeName) { + var upperFirstFontSizeAttributeName = Object(external_lodash_["upperFirst"])(fontSizeAttributeName); + settersAccumulator["set".concat(upperFirstFontSizeAttributeName)] = _this2.createSetFontSize(fontSizeAttributeName, customFontSizeAttributeName); + return settersAccumulator; + }, {}); + } + }, { + key: "createSetFontSize", + value: function createSetFontSize(fontSizeAttributeName, customFontSizeAttributeName) { + var _this3 = this; + + return function (fontSizeValue) { + var _this3$props$setAttri; + + var fontSizeObject = Object(external_lodash_["find"])(_this3.props.fontSizes, { + size: Number(fontSizeValue) + }); + + _this3.props.setAttributes((_this3$props$setAttri = {}, Object(defineProperty["a" /* default */])(_this3$props$setAttri, fontSizeAttributeName, fontSizeObject && fontSizeObject.slug ? fontSizeObject.slug : undefined), Object(defineProperty["a" /* default */])(_this3$props$setAttri, customFontSizeAttributeName, fontSizeObject && fontSizeObject.slug ? undefined : fontSizeValue), _this3$props$setAttri)); + }; + } + }, { + key: "render", + value: function render() { + return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(objectSpread["a" /* default */])({}, this.props, { + fontSizes: undefined + }, this.state, this.setters)); + } + }], [{ + key: "getDerivedStateFromProps", + value: function getDerivedStateFromProps(_ref, previousState) { + var attributes = _ref.attributes, + fontSizes = _ref.fontSizes; + + var didAttributesChange = function didAttributesChange(customFontSizeAttributeName, fontSizeAttributeName) { + if (previousState[fontSizeAttributeName]) { + // if new font size is name compare with the previous slug + if (attributes[fontSizeAttributeName]) { + return attributes[fontSizeAttributeName] !== previousState[fontSizeAttributeName].slug; + } // if font size is not named, update when the font size value changes. + + + return previousState[fontSizeAttributeName].size !== attributes[customFontSizeAttributeName]; + } // in this case we need to build the font size object + + + return true; + }; + + if (!Object(external_lodash_["some"])(fontSizeAttributeNames, didAttributesChange)) { + return null; + } + + var newState = Object(external_lodash_["reduce"])(Object(external_lodash_["pickBy"])(fontSizeAttributeNames, didAttributesChange), function (newStateAccumulator, customFontSizeAttributeName, fontSizeAttributeName) { + var fontSizeAttributeValue = attributes[fontSizeAttributeName]; + var fontSizeObject = utils_getFontSize(fontSizes, fontSizeAttributeValue, attributes[customFontSizeAttributeName]); + newStateAccumulator[fontSizeAttributeName] = Object(objectSpread["a" /* default */])({}, fontSizeObject, { + class: getFontSizeClass(fontSizeAttributeValue) + }); + return newStateAccumulator; + }, {}); + return Object(objectSpread["a" /* default */])({}, previousState, newState); + } + }]); + + return _class; + }(external_this_wp_element_["Component"]) + ); + }]), 'withFontSizes'); +}); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/font-sizes/index.js + + + + +// EXTERNAL MODULE: external {"this":["wp","i18n"]} +var external_this_wp_i18n_ = __webpack_require__(1); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/alignment-toolbar/index.js + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +var DEFAULT_ALIGNMENT_CONTROLS = [{ + icon: 'editor-alignleft', + title: Object(external_this_wp_i18n_["__"])('Align Text Left'), + align: 'left' +}, { + icon: 'editor-aligncenter', + title: Object(external_this_wp_i18n_["__"])('Align Text Center'), + align: 'center' +}, { + icon: 'editor-alignright', + title: Object(external_this_wp_i18n_["__"])('Align Text Right'), + align: 'right' +}]; +function AlignmentToolbar(props) { + var value = props.value, + onChange = props.onChange, + _props$alignmentContr = props.alignmentControls, + alignmentControls = _props$alignmentContr === void 0 ? DEFAULT_ALIGNMENT_CONTROLS : _props$alignmentContr, + _props$label = props.label, + label = _props$label === void 0 ? Object(external_this_wp_i18n_["__"])('Change text alignment') : _props$label, + _props$isCollapsed = props.isCollapsed, + isCollapsed = _props$isCollapsed === void 0 ? true : _props$isCollapsed; + + function applyOrUnset(align) { + return function () { + return onChange(value === align ? undefined : align); + }; + } + + var activeAlignment = Object(external_lodash_["find"])(alignmentControls, function (control) { + return control.align === value; + }); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Toolbar"], { + isCollapsed: isCollapsed, + icon: activeAlignment ? activeAlignment.icon : 'editor-alignleft', + label: label, + controls: alignmentControls.map(function (control) { + var align = control.align; + var isActive = value === align; + return Object(objectSpread["a" /* default */])({}, control, { + isActive: isActive, + onClick: applyOrUnset(align) + }); + }) + }); +} +/* harmony default export */ var alignment_toolbar = (AlignmentToolbar); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-edit/context.js + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +var _createContext = Object(external_this_wp_element_["createContext"])({ + name: '', + isSelected: false, + focusedElement: null, + setFocusedElement: external_lodash_["noop"], + clientId: null +}), + Consumer = _createContext.Consumer, + Provider = _createContext.Provider; + + +/** + * A Higher Order Component used to inject BlockEdit context to the + * wrapped component. + * + * @param {Function} mapContextToProps Function called on every context change, + * expected to return object of props to + * merge with the component's own props. + * + * @return {Component} Enhanced component with injected context as props. + */ + +var context_withBlockEditContext = function withBlockEditContext(mapContextToProps) { + return Object(external_this_wp_compose_["createHigherOrderComponent"])(function (OriginalComponent) { + return function (props) { + return Object(external_this_wp_element_["createElement"])(Consumer, null, function (context) { + return Object(external_this_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, props, mapContextToProps(context, props))); + }); + }; + }, 'withBlockEditContext'); +}; +/** + * A Higher Order Component used to render conditionally the wrapped + * component only when the BlockEdit has selected state set. + * + * @param {Component} OriginalComponent Component to wrap. + * + * @return {Component} Component which renders only when the BlockEdit is selected. + */ + +var ifBlockEditSelected = Object(external_this_wp_compose_["createHigherOrderComponent"])(function (OriginalComponent) { + return function (props) { + return Object(external_this_wp_element_["createElement"])(Consumer, null, function (_ref) { + var isSelected = _ref.isSelected; + return isSelected && Object(external_this_wp_element_["createElement"])(OriginalComponent, props); + }); + }; +}, 'ifBlockEditSelected'); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/autocomplete/index.js + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +/** + * Wrap the default Autocomplete component with one that + * supports a filter hook for customizing its list of autocompleters. + * + * This function is exported for unit test. + * + * @param {Function} Autocomplete Original component. + * @return {Function} Wrapped component + */ + +function withFilteredAutocompleters(Autocomplete) { + return function (props) { + var _props$completers = props.completers, + completers = _props$completers === void 0 ? [] : _props$completers; + + if (Object(external_this_wp_hooks_["hasFilter"])('editor.Autocomplete.completers')) { + completers = Object(external_this_wp_hooks_["applyFilters"])('editor.Autocomplete.completers', // Provide copies so filters may directly modify them. + completers.map(external_lodash_["clone"]), props.blockName); + } + + return Object(external_this_wp_element_["createElement"])(Autocomplete, Object(esm_extends["a" /* default */])({}, props, { + completers: completers + })); + }; +} +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/autocomplete/README.md + */ + +/* harmony default export */ var autocomplete = (Object(external_this_wp_compose_["compose"])([context_withBlockEditContext(function (_ref) { + var name = _ref.name; + return { + blockName: name + }; +}), withFilteredAutocompleters])(external_this_wp_components_["Autocomplete"])); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-alignment-toolbar/index.js + + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +var BLOCK_ALIGNMENTS_CONTROLS = { + left: { + icon: 'align-left', + title: Object(external_this_wp_i18n_["__"])('Align Left') + }, + center: { + icon: 'align-center', + title: Object(external_this_wp_i18n_["__"])('Align Center') + }, + right: { + icon: 'align-right', + title: Object(external_this_wp_i18n_["__"])('Align Right') + }, + wide: { + icon: 'align-wide', + title: Object(external_this_wp_i18n_["__"])('Wide Width') + }, + full: { + icon: 'align-full-width', + title: Object(external_this_wp_i18n_["__"])('Full Width') + } +}; +var DEFAULT_CONTROLS = ['left', 'center', 'right', 'wide', 'full']; +var DEFAULT_CONTROL = 'center'; +var WIDE_CONTROLS = ['wide', 'full']; +function BlockAlignmentToolbar(_ref) { + var value = _ref.value, + onChange = _ref.onChange, + _ref$controls = _ref.controls, + controls = _ref$controls === void 0 ? DEFAULT_CONTROLS : _ref$controls, + _ref$isCollapsed = _ref.isCollapsed, + isCollapsed = _ref$isCollapsed === void 0 ? true : _ref$isCollapsed, + _ref$wideControlsEnab = _ref.wideControlsEnabled, + wideControlsEnabled = _ref$wideControlsEnab === void 0 ? false : _ref$wideControlsEnab; + + function applyOrUnset(align) { + return function () { + return onChange(value === align ? undefined : align); + }; + } + + var enabledControls = wideControlsEnabled ? controls : controls.filter(function (control) { + return WIDE_CONTROLS.indexOf(control) === -1; + }); + var activeAlignmentControl = BLOCK_ALIGNMENTS_CONTROLS[value]; + var defaultAlignmentControl = BLOCK_ALIGNMENTS_CONTROLS[DEFAULT_CONTROL]; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Toolbar"], { + isCollapsed: isCollapsed, + icon: activeAlignmentControl ? activeAlignmentControl.icon : defaultAlignmentControl.icon, + label: Object(external_this_wp_i18n_["__"])('Change alignment'), + controls: enabledControls.map(function (control) { + return Object(objectSpread["a" /* default */])({}, BLOCK_ALIGNMENTS_CONTROLS[control], { + isActive: value === control, + onClick: applyOrUnset(control) + }); + }) + }); +} +/* harmony default export */ var block_alignment_toolbar = (Object(external_this_wp_compose_["compose"])(context_withBlockEditContext(function (_ref2) { + var clientId = _ref2.clientId; + return { + clientId: clientId + }; +}), Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getSettings = _select.getSettings; + + var settings = getSettings(); + return { + wideControlsEnabled: settings.alignWide + }; +}))(BlockAlignmentToolbar)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-controls/index.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + +var _createSlotFill = Object(external_this_wp_components_["createSlotFill"])('BlockControls'), + Fill = _createSlotFill.Fill, + Slot = _createSlotFill.Slot; + +var block_controls_BlockControlsFill = function BlockControlsFill(_ref) { + var controls = _ref.controls, + children = _ref.children; + return Object(external_this_wp_element_["createElement"])(Fill, null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Toolbar"], { + controls: controls + }), children); +}; + +var BlockControls = ifBlockEditSelected(block_controls_BlockControlsFill); +BlockControls.Slot = Slot; +/* harmony default export */ var block_controls = (BlockControls); + +// EXTERNAL MODULE: ./node_modules/memize/index.js +var memize = __webpack_require__(44); +var memize_default = /*#__PURE__*/__webpack_require__.n(memize); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-edit/edit.js + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +var edit_Edit = function Edit(props) { + var _props$attributes = props.attributes, + attributes = _props$attributes === void 0 ? {} : _props$attributes, + name = props.name; + var blockType = Object(external_this_wp_blocks_["getBlockType"])(name); + + if (!blockType) { + return null; + } // Generate a class name for the block's editable form + + + var generatedClassName = Object(external_this_wp_blocks_["hasBlockSupport"])(blockType, 'className', true) ? Object(external_this_wp_blocks_["getBlockDefaultClassName"])(name) : null; + var className = classnames_default()(generatedClassName, attributes.className); // `edit` and `save` are functions or components describing the markup + // with which a block is displayed. If `blockType` is valid, assign + // them preferentially as the render value for the block. + + var Component = blockType.edit || blockType.save; + return Object(external_this_wp_element_["createElement"])(Component, Object(esm_extends["a" /* default */])({}, props, { + className: className + })); +}; +/* harmony default export */ var edit = (Object(external_this_wp_components_["withFilters"])('editor.BlockEdit')(edit_Edit)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-edit/index.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + + + +var block_edit_BlockEdit = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockEdit, _Component); + + function BlockEdit() { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockEdit); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockEdit).apply(this, arguments)); // It is important to return the same object if props haven't changed + // to avoid unnecessary rerenders. + // See https://reactjs.org/docs/context.html#caveats. + + _this.propsToContext = memize_default()(_this.propsToContext.bind(Object(assertThisInitialized["a" /* default */])(_this)), { + maxSize: 1 + }); + return _this; + } + + Object(createClass["a" /* default */])(BlockEdit, [{ + key: "propsToContext", + value: function propsToContext(name, isSelected, clientId, onFocus, onCaretVerticalPositionChange) { + return { + name: name, + isSelected: isSelected, + clientId: clientId, + onFocus: onFocus, + onCaretVerticalPositionChange: onCaretVerticalPositionChange + }; + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + name = _this$props.name, + isSelected = _this$props.isSelected, + clientId = _this$props.clientId, + onFocus = _this$props.onFocus, + onCaretVerticalPositionChange = _this$props.onCaretVerticalPositionChange; + var value = this.propsToContext(name, isSelected, clientId, onFocus, onCaretVerticalPositionChange); + return Object(external_this_wp_element_["createElement"])(Provider, { + value: value + }, Object(external_this_wp_element_["createElement"])(edit, this.props)); + } + }]); + + return BlockEdit; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var block_edit = (block_edit_BlockEdit); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-format-controls/index.js +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + +var block_format_controls_createSlotFill = Object(external_this_wp_components_["createSlotFill"])('BlockFormatControls'), + block_format_controls_Fill = block_format_controls_createSlotFill.Fill, + block_format_controls_Slot = block_format_controls_createSlotFill.Slot; + +var BlockFormatControls = ifBlockEditSelected(block_format_controls_Fill); +BlockFormatControls.Slot = block_format_controls_Slot; +/* harmony default export */ var block_format_controls = (BlockFormatControls); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-icon/index.js + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + +function BlockIcon(_ref) { + var icon = _ref.icon, + _ref$showColors = _ref.showColors, + showColors = _ref$showColors === void 0 ? false : _ref$showColors, + className = _ref.className; + + if (Object(external_lodash_["get"])(icon, ['src']) === 'block-default') { + icon = { + src: Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 24 24" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + d: "M19 7h-1V5h-4v2h-4V5H6v2H5c-1.1 0-2 .9-2 2v10h18V9c0-1.1-.9-2-2-2zm0 10H5V9h14v8z" + })) + }; + } + + var renderedIcon = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Icon"], { + icon: icon && icon.src ? icon.src : icon + }); + var style = showColors ? { + backgroundColor: icon && icon.background, + color: icon && icon.foreground + } : {}; + return Object(external_this_wp_element_["createElement"])("span", { + style: style, + className: classnames_default()('editor-block-icon block-editor-block-icon', className, { + 'has-colors': showColors + }) + }, renderedIcon); +} + +// EXTERNAL MODULE: external {"this":["wp","keycodes"]} +var external_this_wp_keycodes_ = __webpack_require__(19); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-navigation/list.js + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +function BlockNavigationList(_ref) { + var blocks = _ref.blocks, + selectedBlockClientId = _ref.selectedBlockClientId, + selectBlock = _ref.selectBlock, + showNestedBlocks = _ref.showNestedBlocks; + return ( + /* + * Disable reason: The `list` ARIA role is redundant but + * Safari+VoiceOver won't announce the list otherwise. + */ + + /* eslint-disable jsx-a11y/no-redundant-roles */ + Object(external_this_wp_element_["createElement"])("ul", { + className: "editor-block-navigation__list block-editor-block-navigation__list", + role: "list" + }, Object(external_lodash_["map"])(blocks, function (block) { + var blockType = Object(external_this_wp_blocks_["getBlockType"])(block.name); + var isSelected = block.clientId === selectedBlockClientId; + return Object(external_this_wp_element_["createElement"])("li", { + key: block.clientId + }, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-navigation__item block-editor-block-navigation__item" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: classnames_default()('editor-block-navigation__item-button block-editor-block-navigation__item-button', { + 'is-selected': isSelected + }), + onClick: function onClick() { + return selectBlock(block.clientId); + } + }, Object(external_this_wp_element_["createElement"])(BlockIcon, { + icon: blockType.icon, + showColors: true + }), blockType.title, isSelected && Object(external_this_wp_element_["createElement"])("span", { + className: "screen-reader-text" + }, Object(external_this_wp_i18n_["__"])('(selected block)')))), showNestedBlocks && !!block.innerBlocks && !!block.innerBlocks.length && Object(external_this_wp_element_["createElement"])(BlockNavigationList, { + blocks: block.innerBlocks, + selectedBlockClientId: selectedBlockClientId, + selectBlock: selectBlock, + showNestedBlocks: true + })); + })) + /* eslint-enable jsx-a11y/no-redundant-roles */ + + ); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-navigation/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + + +function BlockNavigation(_ref) { + var rootBlock = _ref.rootBlock, + rootBlocks = _ref.rootBlocks, + selectedBlockClientId = _ref.selectedBlockClientId, + selectBlock = _ref.selectBlock; + + if (!rootBlocks || rootBlocks.length === 0) { + return null; + } + + var hasHierarchy = rootBlock && (rootBlock.clientId !== selectedBlockClientId || rootBlock.innerBlocks && rootBlock.innerBlocks.length !== 0); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["NavigableMenu"], { + role: "presentation", + className: "editor-block-navigation__container block-editor-block-navigation__container" + }, Object(external_this_wp_element_["createElement"])("p", { + className: "editor-block-navigation__label block-editor-block-navigation__label" + }, Object(external_this_wp_i18n_["__"])('Block navigation')), hasHierarchy && Object(external_this_wp_element_["createElement"])(BlockNavigationList, { + blocks: [rootBlock], + selectedBlockClientId: selectedBlockClientId, + selectBlock: selectBlock, + showNestedBlocks: true + }), !hasHierarchy && Object(external_this_wp_element_["createElement"])(BlockNavigationList, { + blocks: rootBlocks, + selectedBlockClientId: selectedBlockClientId, + selectBlock: selectBlock + })); +} + +/* harmony default export */ var block_navigation = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getSelectedBlockClientId = _select.getSelectedBlockClientId, + getBlockHierarchyRootClientId = _select.getBlockHierarchyRootClientId, + getBlock = _select.getBlock, + getBlocks = _select.getBlocks; + + var selectedBlockClientId = getSelectedBlockClientId(); + return { + rootBlocks: getBlocks(), + rootBlock: selectedBlockClientId ? getBlock(getBlockHierarchyRootClientId(selectedBlockClientId)) : null, + selectedBlockClientId: selectedBlockClientId + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref2) { + var _ref2$onSelect = _ref2.onSelect, + onSelect = _ref2$onSelect === void 0 ? external_lodash_["noop"] : _ref2$onSelect; + return { + selectBlock: function selectBlock(clientId) { + dispatch('core/block-editor').selectBlock(clientId); + onSelect(clientId); + } + }; +}))(BlockNavigation)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-navigation/dropdown.js + + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + +var MenuIcon = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 24 24", + width: "20", + height: "20" +}, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + d: "M5 5H3v2h2V5zm3 8h11v-2H8v2zm9-8H6v2h11V5zM7 11H5v2h2v-2zm0 8h2v-2H7v2zm3-2v2h11v-2H10z" +})); + +function BlockNavigationDropdown(_ref) { + var hasBlocks = _ref.hasBlocks, + isDisabled = _ref.isDisabled; + var isEnabled = hasBlocks && !isDisabled; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Dropdown"], { + contentClassName: "editor-block-navigation__popover block-editor-block-navigation__popover", + renderToggle: function renderToggle(_ref2) { + var isOpen = _ref2.isOpen, + onToggle = _ref2.onToggle; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, isEnabled && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["KeyboardShortcuts"], { + bindGlobal: true, + shortcuts: Object(defineProperty["a" /* default */])({}, external_this_wp_keycodes_["rawShortcut"].access('o'), onToggle) + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + icon: MenuIcon, + "aria-expanded": isOpen, + onClick: isEnabled ? onToggle : undefined, + label: Object(external_this_wp_i18n_["__"])('Block navigation'), + className: "editor-block-navigation block-editor-block-navigation", + shortcut: external_this_wp_keycodes_["displayShortcut"].access('o'), + "aria-disabled": !isEnabled + })); + }, + renderContent: function renderContent(_ref4) { + var onClose = _ref4.onClose; + return Object(external_this_wp_element_["createElement"])(block_navigation, { + onSelect: onClose + }); + } + }); +} + +/* harmony default export */ var dropdown = (Object(external_this_wp_data_["withSelect"])(function (select) { + return { + hasBlocks: !!select('core/block-editor').getBlockCount() + }; +})(BlockNavigationDropdown)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-vertical-alignment-toolbar/icons.js + + +/** + * WordPress dependencies + */ + +var alignBottom = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + xmlns: "http://www.w3.org/2000/svg", + width: "20", + height: "20", + viewBox: "0 0 24 24" +}, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + fill: "none", + d: "M0 0h24v24H0V0z" +}), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + d: "M16 13h-3V3h-2v10H8l4 4 4-4zM4 19v2h16v-2H4z" +})); +var alignCenter = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + xmlns: "http://www.w3.org/2000/svg", + width: "20", + height: "20", + viewBox: "0 0 24 24" +}, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + fill: "none", + d: "M0 0h24v24H0V0z" +}), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + d: "M8 19h3v4h2v-4h3l-4-4-4 4zm8-14h-3V1h-2v4H8l4 4 4-4zM4 11v2h16v-2H4z" +})); +var alignTop = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + xmlns: "http://www.w3.org/2000/svg", + width: "20", + height: "20", + viewBox: "0 0 24 24" +}, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + fill: "none", + d: "M0 0h24v24H0V0z" +}), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + d: "M8 11h3v10h2V11h3l-4-4-4 4zM4 3v2h16V3H4z" +})); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-vertical-alignment-toolbar/index.js + + + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +var block_vertical_alignment_toolbar_BLOCK_ALIGNMENTS_CONTROLS = { + top: { + icon: alignTop, + title: Object(external_this_wp_i18n_["_x"])('Vertically Align Top', 'Block vertical alignment setting') + }, + center: { + icon: alignCenter, + title: Object(external_this_wp_i18n_["_x"])('Vertically Align Middle', 'Block vertical alignment setting') + }, + bottom: { + icon: alignBottom, + title: Object(external_this_wp_i18n_["_x"])('Vertically Align Bottom', 'Block vertical alignment setting') + } +}; +var block_vertical_alignment_toolbar_DEFAULT_CONTROLS = ['top', 'center', 'bottom']; +var block_vertical_alignment_toolbar_DEFAULT_CONTROL = 'top'; +function BlockVerticalAlignmentToolbar(_ref) { + var value = _ref.value, + onChange = _ref.onChange, + _ref$controls = _ref.controls, + controls = _ref$controls === void 0 ? block_vertical_alignment_toolbar_DEFAULT_CONTROLS : _ref$controls, + _ref$isCollapsed = _ref.isCollapsed, + isCollapsed = _ref$isCollapsed === void 0 ? true : _ref$isCollapsed; + + function applyOrUnset(align) { + return function () { + return onChange(value === align ? undefined : align); + }; + } + + var activeAlignment = block_vertical_alignment_toolbar_BLOCK_ALIGNMENTS_CONTROLS[value]; + var defaultAlignmentControl = block_vertical_alignment_toolbar_BLOCK_ALIGNMENTS_CONTROLS[block_vertical_alignment_toolbar_DEFAULT_CONTROL]; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Toolbar"], { + isCollapsed: isCollapsed, + icon: activeAlignment ? activeAlignment.icon : defaultAlignmentControl.icon, + label: Object(external_this_wp_i18n_["_x"])('Change vertical alignment', 'Block vertical alignment setting label'), + controls: controls.map(function (control) { + return Object(objectSpread["a" /* default */])({}, block_vertical_alignment_toolbar_BLOCK_ALIGNMENTS_CONTROLS[control], { + isActive: value === control, + onClick: applyOrUnset(control) + }); + }) + }); +} +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/block-vertical-alignment-toolbar/README.md + */ + +/* harmony default export */ var block_vertical_alignment_toolbar = (BlockVerticalAlignmentToolbar); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/media-upload/check.js +/** + * WordPress dependencies + */ + +function MediaUploadCheck(_ref) { + var hasUploadPermissions = _ref.hasUploadPermissions, + _ref$fallback = _ref.fallback, + fallback = _ref$fallback === void 0 ? null : _ref$fallback, + children = _ref.children; + return hasUploadPermissions ? children : fallback; +} +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/media-upload/README.md + */ + +/* harmony default export */ var check = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getSettings = _select.getSettings; + + return { + hasUploadPermissions: !!getSettings().__experimentalMediaUpload + }; +})(MediaUploadCheck)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-drop-zone/index.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + +var parseDropEvent = function parseDropEvent(event) { + var result = { + srcRootClientId: null, + srcClientId: null, + srcIndex: null, + type: null + }; + + if (!event.dataTransfer) { + return result; + } + + try { + result = Object.assign(result, JSON.parse(event.dataTransfer.getData('text'))); + } catch (err) { + return result; + } + + return result; +}; + +var block_drop_zone_BlockDropZone = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockDropZone, _Component); + + function BlockDropZone() { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockDropZone); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockDropZone).apply(this, arguments)); + _this.onFilesDrop = _this.onFilesDrop.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onHTMLDrop = _this.onHTMLDrop.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onDrop = _this.onDrop.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(BlockDropZone, [{ + key: "getInsertIndex", + value: function getInsertIndex(position) { + var _this$props = this.props, + clientId = _this$props.clientId, + rootClientId = _this$props.rootClientId, + getBlockIndex = _this$props.getBlockIndex; + + if (clientId !== undefined) { + var index = getBlockIndex(clientId, rootClientId); + return position && position.y === 'top' ? index : index + 1; + } + } + }, { + key: "onFilesDrop", + value: function onFilesDrop(files, position) { + var transformation = Object(external_this_wp_blocks_["findTransform"])(Object(external_this_wp_blocks_["getBlockTransforms"])('from'), function (transform) { + return transform.type === 'files' && transform.isMatch(files); + }); + + if (transformation) { + var insertIndex = this.getInsertIndex(position); + var blocks = transformation.transform(files, this.props.updateBlockAttributes); + this.props.insertBlocks(blocks, insertIndex); + } + } + }, { + key: "onHTMLDrop", + value: function onHTMLDrop(HTML, position) { + var blocks = Object(external_this_wp_blocks_["pasteHandler"])({ + HTML: HTML, + mode: 'BLOCKS' + }); + + if (blocks.length) { + this.props.insertBlocks(blocks, this.getInsertIndex(position)); + } + } + }, { + key: "onDrop", + value: function onDrop(event, position) { + var _this$props2 = this.props, + dstRootClientId = _this$props2.rootClientId, + dstClientId = _this$props2.clientId, + getClientIdsOfDescendants = _this$props2.getClientIdsOfDescendants, + getBlockIndex = _this$props2.getBlockIndex; + + var _parseDropEvent = parseDropEvent(event), + srcRootClientId = _parseDropEvent.srcRootClientId, + srcClientId = _parseDropEvent.srcClientId, + srcIndex = _parseDropEvent.srcIndex, + type = _parseDropEvent.type; + + var isBlockDropType = function isBlockDropType(dropType) { + return dropType === 'block'; + }; + + var isSameLevel = function isSameLevel(srcRoot, dstRoot) { + // Note that rootClientId of top-level blocks will be undefined OR a void string, + // so we also need to account for that case separately. + return srcRoot === dstRoot || !srcRoot === true && !dstRoot === true; + }; + + var isSameBlock = function isSameBlock(src, dst) { + return src === dst; + }; + + var isSrcBlockAnAncestorOfDstBlock = function isSrcBlockAnAncestorOfDstBlock(src, dst) { + return getClientIdsOfDescendants([src]).some(function (id) { + return id === dst; + }); + }; + + if (!isBlockDropType(type) || isSameBlock(srcClientId, dstClientId) || isSrcBlockAnAncestorOfDstBlock(srcClientId, dstClientId || dstRootClientId)) { + return; + } + + var dstIndex = dstClientId ? getBlockIndex(dstClientId, dstRootClientId) : undefined; + var positionIndex = this.getInsertIndex(position); // If the block is kept at the same level and moved downwards, + // subtract to account for blocks shifting upward to occupy its old position. + + var insertIndex = dstIndex && srcIndex < dstIndex && isSameLevel(srcRootClientId, dstRootClientId) ? positionIndex - 1 : positionIndex; + this.props.moveBlockToPosition(srcClientId, srcRootClientId, insertIndex); + } + }, { + key: "render", + value: function render() { + var isLockedAll = this.props.isLockedAll; + + if (isLockedAll) { + return null; + } + + var index = this.getInsertIndex(); + var isAppender = index === undefined; + return Object(external_this_wp_element_["createElement"])(check, null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["DropZone"], { + className: classnames_default()('editor-block-drop-zone block-editor-block-drop-zone', { + 'is-appender': isAppender + }), + onFilesDrop: this.onFilesDrop, + onHTMLDrop: this.onHTMLDrop, + onDrop: this.onDrop + })); + } + }]); + + return BlockDropZone; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var block_drop_zone = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withDispatch"])(function (dispatch, ownProps) { + var _dispatch = dispatch('core/block-editor'), + _insertBlocks = _dispatch.insertBlocks, + _updateBlockAttributes = _dispatch.updateBlockAttributes, + _moveBlockToPosition = _dispatch.moveBlockToPosition; + + return { + insertBlocks: function insertBlocks(blocks, index) { + var rootClientId = ownProps.rootClientId; + + _insertBlocks(blocks, index, rootClientId); + }, + updateBlockAttributes: function updateBlockAttributes() { + _updateBlockAttributes.apply(void 0, arguments); + }, + moveBlockToPosition: function moveBlockToPosition(srcClientId, srcRootClientId, dstIndex) { + var dstRootClientId = ownProps.rootClientId; + + _moveBlockToPosition(srcClientId, srcRootClientId, dstRootClientId, dstIndex); + } + }; +}), Object(external_this_wp_data_["withSelect"])(function (select, _ref) { + var rootClientId = _ref.rootClientId; + + var _select = select('core/block-editor'), + getClientIdsOfDescendants = _select.getClientIdsOfDescendants, + getTemplateLock = _select.getTemplateLock, + getBlockIndex = _select.getBlockIndex; + + return { + isLockedAll: getTemplateLock(rootClientId) === 'all', + getClientIdsOfDescendants: getClientIdsOfDescendants, + getBlockIndex: getBlockIndex + }; +}), Object(external_this_wp_components_["withFilters"])('editor.BlockDropZone'))(block_drop_zone_BlockDropZone)); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules +var toConsumableArray = __webpack_require__(17); + +// EXTERNAL MODULE: ./node_modules/dom-scroll-into-view/lib/index.js +var lib = __webpack_require__(68); +var lib_default = /*#__PURE__*/__webpack_require__.n(lib); + +// EXTERNAL MODULE: external {"this":["wp","url"]} +var external_this_wp_url_ = __webpack_require__(26); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules +var slicedToArray = __webpack_require__(23); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js + 1 modules +var objectWithoutProperties = __webpack_require__(21); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/defaults.js +/** + * WordPress dependencies + */ + +var PREFERENCES_DEFAULTS = { + insertUsage: {} +}; +/** + * The default editor settings + * + * alignWide boolean Enable/Disable Wide/Full Alignments + * availableLegacyWidgets Array Array of objects representing the legacy widgets available. + * colors Array Palette colors + * disableCustomColors boolean Whether or not the custom colors are disabled + * fontSizes Array Available font sizes + * disableCustomFontSizes boolean Whether or not the custom font sizes are disabled + * imageSizes Array Available image sizes + * maxWidth number Max width to constraint resizing + * allowedBlockTypes boolean|Array Allowed block types + * hasFixedToolbar boolean Whether or not the editor toolbar is fixed + * hasPermissionsToManageWidgets boolean Whether or not the user is able to manage widgets. + * focusMode boolean Whether the focus mode is enabled or not + * styles Array Editor Styles + * isRTL boolean Whether the editor is in RTL mode + * bodyPlaceholder string Empty post placeholder + * titlePlaceholder string Empty title placeholder + * codeEditingEnabled string Whether or not the user can switch to the code editor + * showInserterHelpPanel boolean Whether or not the inserter help panel is shown + * __experimentalCanUserUseUnfilteredHTML string Whether the user should be able to use unfiltered HTML or the HTML should be filtered e.g., to remove elements considered insecure like iframes. + * __experimentalEnableLegacyWidgetBlock boolean Whether the user has enabled the Legacy Widget Block + * __experimentalEnableMenuBlock boolean Whether the user has enabled the Menu Block + * __experimentalBlockDirectory boolean Whether the user has enabled the Block Directory + */ + +var SETTINGS_DEFAULTS = { + alignWide: false, + colors: [{ + name: Object(external_this_wp_i18n_["__"])('Pale pink'), + slug: 'pale-pink', + color: '#f78da7' + }, { + name: Object(external_this_wp_i18n_["__"])('Vivid red'), + slug: 'vivid-red', + color: '#cf2e2e' + }, { + name: Object(external_this_wp_i18n_["__"])('Luminous vivid orange'), + slug: 'luminous-vivid-orange', + color: '#ff6900' + }, { + name: Object(external_this_wp_i18n_["__"])('Luminous vivid amber'), + slug: 'luminous-vivid-amber', + color: '#fcb900' + }, { + name: Object(external_this_wp_i18n_["__"])('Light green cyan'), + slug: 'light-green-cyan', + color: '#7bdcb5' + }, { + name: Object(external_this_wp_i18n_["__"])('Vivid green cyan'), + slug: 'vivid-green-cyan', + color: '#00d084' + }, { + name: Object(external_this_wp_i18n_["__"])('Pale cyan blue'), + slug: 'pale-cyan-blue', + color: '#8ed1fc' + }, { + name: Object(external_this_wp_i18n_["__"])('Vivid cyan blue'), + slug: 'vivid-cyan-blue', + color: '#0693e3' + }, { + name: Object(external_this_wp_i18n_["__"])('Vivid purple'), + slug: 'vivid-purple', + color: '#9b51e0' + }, { + name: Object(external_this_wp_i18n_["__"])('Very light gray'), + slug: 'very-light-gray', + color: '#eeeeee' + }, { + name: Object(external_this_wp_i18n_["__"])('Cyan bluish gray'), + slug: 'cyan-bluish-gray', + color: '#abb8c3' + }, { + name: Object(external_this_wp_i18n_["__"])('Very dark gray'), + slug: 'very-dark-gray', + color: '#313131' + }], + fontSizes: [{ + name: Object(external_this_wp_i18n_["_x"])('Small', 'font size name'), + size: 13, + slug: 'small' + }, { + name: Object(external_this_wp_i18n_["_x"])('Normal', 'font size name'), + size: 16, + slug: 'normal' + }, { + name: Object(external_this_wp_i18n_["_x"])('Medium', 'font size name'), + size: 20, + slug: 'medium' + }, { + name: Object(external_this_wp_i18n_["_x"])('Large', 'font size name'), + size: 36, + slug: 'large' + }, { + name: Object(external_this_wp_i18n_["_x"])('Huge', 'font size name'), + size: 48, + slug: 'huge' + }], + imageSizes: [{ + slug: 'thumbnail', + label: Object(external_this_wp_i18n_["__"])('Thumbnail') + }, { + slug: 'medium', + label: Object(external_this_wp_i18n_["__"])('Medium') + }, { + slug: 'large', + label: Object(external_this_wp_i18n_["__"])('Large') + }, { + slug: 'full', + label: Object(external_this_wp_i18n_["__"])('Full Size') + }], + // This is current max width of the block inner area + // It's used to constraint image resizing and this value could be overridden later by themes + maxWidth: 580, + // Allowed block types for the editor, defaulting to true (all supported). + allowedBlockTypes: true, + // Maximum upload size in bytes allowed for the site. + maxUploadFileSize: 0, + // List of allowed mime types and file extensions. + allowedMimeTypes: null, + availableLegacyWidgets: {}, + hasPermissionsToManageWidgets: false, + showInserterHelpPanel: true, + __experimentalCanUserUseUnfilteredHTML: false, + __experimentalEnableLegacyWidgetBlock: false, + __experimentalEnableMenuBlock: false, + __experimentalBlockDirectory: false +}; + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/array.js + + +/** + * External dependencies + */ + +/** + * Insert one or multiple elements into a given position of an array. + * + * @param {Array} array Source array. + * @param {*} elements Elements to insert. + * @param {number} index Insert Position. + * + * @return {Array} Result. + */ + +function insertAt(array, elements, index) { + return [].concat(Object(toConsumableArray["a" /* default */])(array.slice(0, index)), Object(toConsumableArray["a" /* default */])(Object(external_lodash_["castArray"])(elements)), Object(toConsumableArray["a" /* default */])(array.slice(index))); +} +/** + * Moves an element in an array. + * + * @param {Array} array Source array. + * @param {number} from Source index. + * @param {number} to Destination index. + * @param {number} count Number of elements to move. + * + * @return {Array} Result. + */ + +function moveTo(array, from, to) { + var count = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1; + + var withoutMovedElements = Object(toConsumableArray["a" /* default */])(array); + + withoutMovedElements.splice(from, count); + return insertAt(withoutMovedElements, array.slice(from, from + count), to); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/reducer.js + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + +/** + * Given an array of blocks, returns an object where each key is a nesting + * context, the value of which is an array of block client IDs existing within + * that nesting context. + * + * @param {Array} blocks Blocks to map. + * @param {?string} rootClientId Assumed root client ID. + * + * @return {Object} Block order map object. + */ + +function mapBlockOrder(blocks) { + var rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + + var result = Object(defineProperty["a" /* default */])({}, rootClientId, []); + + blocks.forEach(function (block) { + var clientId = block.clientId, + innerBlocks = block.innerBlocks; + result[rootClientId].push(clientId); + Object.assign(result, mapBlockOrder(innerBlocks, clientId)); + }); + return result; +} +/** + * Given an array of blocks, returns an object where each key contains + * the clientId of the block and the value is the parent of the block. + * + * @param {Array} blocks Blocks to map. + * @param {?string} rootClientId Assumed root client ID. + * + * @return {Object} Block order map object. + */ + + +function mapBlockParents(blocks) { + var rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + return blocks.reduce(function (result, block) { + return Object.assign(result, Object(defineProperty["a" /* default */])({}, block.clientId, rootClientId), mapBlockParents(block.innerBlocks, block.clientId)); + }, {}); +} +/** + * Helper method to iterate through all blocks, recursing into inner blocks, + * applying a transformation function to each one. + * Returns a flattened object with the transformed blocks. + * + * @param {Array} blocks Blocks to flatten. + * @param {Function} transform Transforming function to be applied to each block. + * + * @return {Object} Flattened object. + */ + + +function flattenBlocks(blocks) { + var transform = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : external_lodash_["identity"]; + var result = {}; + + var stack = Object(toConsumableArray["a" /* default */])(blocks); + + while (stack.length) { + var _stack$shift = stack.shift(), + innerBlocks = _stack$shift.innerBlocks, + block = Object(objectWithoutProperties["a" /* default */])(_stack$shift, ["innerBlocks"]); + + stack.push.apply(stack, Object(toConsumableArray["a" /* default */])(innerBlocks)); + result[block.clientId] = transform(block); + } + + return result; +} +/** + * Given an array of blocks, returns an object containing all blocks, without + * attributes, recursing into inner blocks. Keys correspond to the block client + * ID, the value of which is the attributes object. + * + * @param {Array} blocks Blocks to flatten. + * + * @return {Object} Flattened block attributes object. + */ + + +function getFlattenedBlocksWithoutAttributes(blocks) { + return flattenBlocks(blocks, function (block) { + return Object(external_lodash_["omit"])(block, 'attributes'); + }); +} +/** + * Given an array of blocks, returns an object containing all block attributes, + * recursing into inner blocks. Keys correspond to the block client ID, the + * value of which is the attributes object. + * + * @param {Array} blocks Blocks to flatten. + * + * @return {Object} Flattened block attributes object. + */ + + +function getFlattenedBlockAttributes(blocks) { + return flattenBlocks(blocks, function (block) { + return block.attributes; + }); +} +/** + * Given a block order map object, returns *all* of the block client IDs that are + * a descendant of the given root client ID. + * + * Calling this with `rootClientId` set to `''` results in a list of client IDs + * that are in the post. That is, it excludes blocks like fetched reusable + * blocks which are stored into state but not visible. + * + * @param {Object} blocksOrder Object that maps block client IDs to a list of + * nested block client IDs. + * @param {?string} rootClientId The root client ID to search. Defaults to ''. + * + * @return {Array} List of descendant client IDs. + */ + + +function getNestedBlockClientIds(blocksOrder) { + var rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + return Object(external_lodash_["reduce"])(blocksOrder[rootClientId], function (result, clientId) { + return [].concat(Object(toConsumableArray["a" /* default */])(result), [clientId], Object(toConsumableArray["a" /* default */])(getNestedBlockClientIds(blocksOrder, clientId))); + }, []); +} +/** + * 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 updating the same block attribute, or + * false otherwise. + * + * @param {Object} action Currently dispatching action. + * @param {Object} lastAction Previously dispatched action. + * + * @return {boolean} Whether actions are updating the same block attribute. + */ + +function isUpdatingSameBlockAttribute(action, lastAction) { + return action.type === 'UPDATE_BLOCK_ATTRIBUTES' && lastAction !== undefined && lastAction.type === 'UPDATE_BLOCK_ATTRIBUTES' && action.clientId === lastAction.clientId && hasSameKeys(action.attributes, lastAction.attributes); +} +/** + * Utility returning an object with an empty object value for each key. + * + * @param {Array} objectKeys Keys to fill. + * @return {Object} Object filled with empty object as values for each clientId. + */ + +var fillKeysWithEmptyObject = function fillKeysWithEmptyObject(objectKeys) { + return objectKeys.reduce(function (result, key) { + result[key] = {}; + return result; + }, {}); +}; +/** + * Higher-order reducer intended to compute a cache key for each block in the post. + * A new instance of the cache key (empty object) is created each time the block object + * needs to be refreshed (for any change in the block or its children). + * + * @param {Function} reducer Original reducer function. + * + * @return {Function} Enhanced reducer function. + */ + + +var reducer_withBlockCache = function withBlockCache(reducer) { + return function () { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + var newState = reducer(state, action); + + if (newState === state) { + return state; + } + + newState.cache = state.cache ? state.cache : {}; + /** + * For each clientId provided, traverses up parents, adding the provided clientIds + * and each parent's clientId to the returned array. + * + * When calling this function consider that it uses the old state, so any state + * modifications made by the `reducer` will not be present. + * + * @param {Array} clientIds an Array of block clientIds. + * + * @return {Array} The provided clientIds and all of their parent clientIds. + */ + + var getBlocksWithParentsClientIds = function getBlocksWithParentsClientIds(clientIds) { + return clientIds.reduce(function (result, clientId) { + var current = clientId; + + do { + result.push(current); + current = state.parents[current]; + } while (current); + + return result; + }, []); + }; + + switch (action.type) { + case 'RESET_BLOCKS': + newState.cache = Object(external_lodash_["mapValues"])(flattenBlocks(action.blocks), function () { + return {}; + }); + break; + + case 'RECEIVE_BLOCKS': + case 'INSERT_BLOCKS': + { + var updatedBlockUids = Object(external_lodash_["keys"])(flattenBlocks(action.blocks)); + + if (action.rootClientId) { + updatedBlockUids.push(action.rootClientId); + } + + newState.cache = Object(objectSpread["a" /* default */])({}, newState.cache, fillKeysWithEmptyObject(getBlocksWithParentsClientIds(updatedBlockUids))); + break; + } + + case 'UPDATE_BLOCK': + case 'UPDATE_BLOCK_ATTRIBUTES': + newState.cache = Object(objectSpread["a" /* default */])({}, newState.cache, fillKeysWithEmptyObject(getBlocksWithParentsClientIds([action.clientId]))); + break; + + case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': + var parentClientIds = fillKeysWithEmptyObject(getBlocksWithParentsClientIds(action.replacedClientIds)); + newState.cache = Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(newState.cache, action.replacedClientIds), Object(external_lodash_["omit"])(parentClientIds, action.replacedClientIds), fillKeysWithEmptyObject(Object(external_lodash_["keys"])(flattenBlocks(action.blocks)))); + break; + + case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': + newState.cache = Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(newState.cache, action.removedClientIds), fillKeysWithEmptyObject(Object(external_lodash_["difference"])(getBlocksWithParentsClientIds(action.clientIds), action.clientIds))); + break; + + case 'MOVE_BLOCK_TO_POSITION': + { + var _updatedBlockUids = [action.clientId]; + + if (action.fromRootClientId) { + _updatedBlockUids.push(action.fromRootClientId); + } + + if (action.toRootClientId) { + _updatedBlockUids.push(action.toRootClientId); + } + + newState.cache = Object(objectSpread["a" /* default */])({}, newState.cache, fillKeysWithEmptyObject(getBlocksWithParentsClientIds(_updatedBlockUids))); + break; + } + + case 'MOVE_BLOCKS_UP': + case 'MOVE_BLOCKS_DOWN': + { + var _updatedBlockUids2 = []; + + if (action.rootClientId) { + _updatedBlockUids2.push(action.rootClientId); + } + + newState.cache = Object(objectSpread["a" /* default */])({}, newState.cache, fillKeysWithEmptyObject(getBlocksWithParentsClientIds(_updatedBlockUids2))); + break; + } + + case 'SAVE_REUSABLE_BLOCK_SUCCESS': + { + var _updatedBlockUids3 = Object(external_lodash_["keys"])(Object(external_lodash_["omitBy"])(newState.attributes, function (attributes, clientId) { + return newState.byClientId[clientId].name !== 'core/block' || attributes.ref !== action.updatedId; + })); + + newState.cache = Object(objectSpread["a" /* default */])({}, newState.cache, fillKeysWithEmptyObject(getBlocksWithParentsClientIds(_updatedBlockUids3))); + } + } + + return newState; + }; +}; +/** + * Higher-order reducer intended to augment the blocks reducer, assigning an + * `isPersistentChange` property value corresponding to whether a change in + * state can be considered as persistent. All changes are considered persistent + * except when updating the same block attribute as in the previous action. + * + * @param {Function} reducer Original reducer function. + * + * @return {Function} Enhanced reducer function. + */ + + +function withPersistentBlockChange(reducer) { + var lastAction; + return function (state, action) { + var nextState = reducer(state, action); + var isExplicitPersistentChange = action.type === 'MARK_LAST_CHANGE_AS_PERSISTENT'; // Defer to previous state value (or default) unless changing or + // explicitly marking as persistent. + + if (state === nextState && !isExplicitPersistentChange) { + var nextIsPersistentChange = Object(external_lodash_["get"])(state, ['isPersistentChange'], true); + + if (state.isPersistentChange === nextIsPersistentChange) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, nextState, { + isPersistentChange: nextIsPersistentChange + }); + } + + nextState = Object(objectSpread["a" /* default */])({}, nextState, { + isPersistentChange: isExplicitPersistentChange || !isUpdatingSameBlockAttribute(action, lastAction) + }); // In comparing against the previous action, consider only those which + // would have qualified as one which would have been ignored or not + // have resulted in a changed state. + + lastAction = action; + return nextState; + }; +} +/** + * Higher-order reducer intended to augment the blocks reducer, assigning an + * `isIgnoredChange` property value corresponding to whether a change in state + * can be considered as ignored. A change is considered ignored when the result + * of an action not incurred by direct user interaction. + * + * @param {Function} reducer Original reducer function. + * + * @return {Function} Enhanced reducer function. + */ + + +function withIgnoredBlockChange(reducer) { + /** + * Set of action types for which a blocks state change should be ignored. + * + * @type {Set} + */ + var IGNORED_ACTION_TYPES = new Set(['RECEIVE_BLOCKS']); + return function (state, action) { + var nextState = reducer(state, action); + + if (nextState !== state) { + nextState.isIgnoredChange = IGNORED_ACTION_TYPES.has(action.type); + } + + return nextState; + }; +} +/** + * Higher-order reducer targeting the combined blocks reducer, augmenting + * block client IDs in remove action to include cascade of inner blocks. + * + * @param {Function} reducer Original reducer function. + * + * @return {Function} Enhanced reducer function. + */ + + +var reducer_withInnerBlocksRemoveCascade = function withInnerBlocksRemoveCascade(reducer) { + return function (state, action) { + var getAllChildren = function getAllChildren(clientIds) { + var result = clientIds; + + for (var i = 0; i < result.length; i++) { + var _result2; + + if (!state.order[result[i]]) { + continue; + } + + if (result === clientIds) { + result = Object(toConsumableArray["a" /* default */])(result); + } + + (_result2 = result).push.apply(_result2, Object(toConsumableArray["a" /* default */])(state.order[result[i]])); + } + + return result; + }; + + if (state) { + switch (action.type) { + case 'REMOVE_BLOCKS': + action = Object(objectSpread["a" /* default */])({}, action, { + type: 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN', + removedClientIds: getAllChildren(action.clientIds) + }); + break; + + case 'REPLACE_BLOCKS': + action = Object(objectSpread["a" /* default */])({}, action, { + type: 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN', + replacedClientIds: getAllChildren(action.clientIds) + }); + break; + } + } + + return reducer(state, action); + }; +}; +/** + * Higher-order reducer which targets the combined blocks reducer and handles + * the `RESET_BLOCKS` action. When dispatched, this action will replace all + * blocks that exist in the post, leaving blocks that exist only in state (e.g. + * reusable blocks) alone. + * + * @param {Function} reducer Original reducer function. + * + * @return {Function} Enhanced reducer function. + */ + + +var reducer_withBlockReset = function withBlockReset(reducer) { + return function (state, action) { + if (state && action.type === 'RESET_BLOCKS') { + var visibleClientIds = getNestedBlockClientIds(state.order); + return Object(objectSpread["a" /* default */])({}, state, { + byClientId: Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(state.byClientId, visibleClientIds), getFlattenedBlocksWithoutAttributes(action.blocks)), + attributes: Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(state.attributes, visibleClientIds), getFlattenedBlockAttributes(action.blocks)), + order: Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(state.order, visibleClientIds), mapBlockOrder(action.blocks)), + parents: Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(state.parents, visibleClientIds), mapBlockParents(action.blocks)), + cache: Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(state.cache, visibleClientIds), Object(external_lodash_["mapValues"])(flattenBlocks(action.blocks), function () { + return {}; + })) + }); + } + + return reducer(state, action); + }; +}; +/** + * Higher-order reducer which targets the combined blocks reducer and handles + * the `REPLACE_INNER_BLOCKS` action. When dispatched, this action the state should become equivalent + * to the execution of a `REMOVE_BLOCKS` action containing all the child's of the root block followed by + * the execution of `INSERT_BLOCKS` with the new blocks. + * + * @param {Function} reducer Original reducer function. + * + * @return {Function} Enhanced reducer function. + */ + + +var reducer_withReplaceInnerBlocks = function withReplaceInnerBlocks(reducer) { + return function (state, action) { + if (action.type !== 'REPLACE_INNER_BLOCKS') { + return reducer(state, action); + } + + var stateAfterBlocksRemoval = state; + + if (state.order[action.rootClientId]) { + stateAfterBlocksRemoval = reducer(stateAfterBlocksRemoval, { + type: 'REMOVE_BLOCKS', + clientIds: state.order[action.rootClientId] + }); + } + + var stateAfterInsert = stateAfterBlocksRemoval; + + if (action.blocks.length) { + stateAfterInsert = reducer(stateAfterInsert, Object(objectSpread["a" /* default */])({}, action, { + type: 'INSERT_BLOCKS', + index: 0 + })); + } + + return stateAfterInsert; + }; +}; +/** + * Higher-order reducer which targets the combined blocks reducer and handles + * the `SAVE_REUSABLE_BLOCK_SUCCESS` action. This action can't be handled by + * regular reducers and needs a higher-order reducer since it needs access to + * both `byClientId` and `attributes` simultaneously. + * + * @param {Function} reducer Original reducer function. + * + * @return {Function} Enhanced reducer function. + */ + + +var reducer_withSaveReusableBlock = function withSaveReusableBlock(reducer) { + return function (state, action) { + if (state && action.type === '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; + } + + state = Object(objectSpread["a" /* default */])({}, state); + state.attributes = Object(external_lodash_["mapValues"])(state.attributes, function (attributes, clientId) { + var name = state.byClientId[clientId].name; + + if (name === 'core/block' && attributes.ref === id) { + return Object(objectSpread["a" /* default */])({}, attributes, { + ref: updatedId + }); + } + + return attributes; + }); + } + + return reducer(state, action); + }; +}; +/** + * Reducer returning the blocks state. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + + +var reducer_blocks = Object(external_lodash_["flow"])(external_this_wp_data_["combineReducers"], reducer_withSaveReusableBlock, // needs to be before withBlockCache +reducer_withBlockCache, // needs to be before withInnerBlocksRemoveCascade +reducer_withInnerBlocksRemoveCascade, reducer_withReplaceInnerBlocks, // needs to be after withInnerBlocksRemoveCascade +reducer_withBlockReset, withPersistentBlockChange, withIgnoredBlockChange)({ + byClientId: function byClientId() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'RESET_BLOCKS': + return getFlattenedBlocksWithoutAttributes(action.blocks); + + case 'RECEIVE_BLOCKS': + case 'INSERT_BLOCKS': + return Object(objectSpread["a" /* default */])({}, state, getFlattenedBlocksWithoutAttributes(action.blocks)); + + case 'UPDATE_BLOCK': + // Ignore updates if block isn't known + if (!state[action.clientId]) { + return state; + } // Do nothing if only attributes change. + + + var changes = Object(external_lodash_["omit"])(action.updates, 'attributes'); + + if (Object(external_lodash_["isEmpty"])(changes)) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.clientId, Object(objectSpread["a" /* default */])({}, state[action.clientId], changes))); + + case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': + if (!action.blocks) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(state, action.replacedClientIds), getFlattenedBlocksWithoutAttributes(action.blocks)); + + case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': + return Object(external_lodash_["omit"])(state, action.removedClientIds); + } + + return state; + }, + attributes: function attributes() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'RESET_BLOCKS': + return getFlattenedBlockAttributes(action.blocks); + + case 'RECEIVE_BLOCKS': + case 'INSERT_BLOCKS': + return Object(objectSpread["a" /* default */])({}, state, getFlattenedBlockAttributes(action.blocks)); + + case 'UPDATE_BLOCK': + // Ignore updates if block isn't known or there are no attribute changes. + if (!state[action.clientId] || !action.updates.attributes) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.clientId, Object(objectSpread["a" /* default */])({}, state[action.clientId], action.updates.attributes))); + + case 'UPDATE_BLOCK_ATTRIBUTES': + // Ignore updates if block isn't known + if (!state[action.clientId]) { + return state; + } // Consider as updates only changed values + + + var nextAttributes = Object(external_lodash_["reduce"])(action.attributes, function (result, value, key) { + if (value !== result[key]) { + result = getMutateSafeObject(state[action.clientId], result); + result[key] = value; + } + + return result; + }, state[action.clientId]); // Skip update if nothing has been changed. The reference will + // match the original block if `reduce` had no changed values. + + if (nextAttributes === state[action.clientId]) { + return state; + } // Otherwise replace attributes in state + + + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.clientId, nextAttributes)); + + case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': + if (!action.blocks) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(state, action.replacedClientIds), getFlattenedBlockAttributes(action.blocks)); + + case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': + return Object(external_lodash_["omit"])(state, action.removedClientIds); + } + + return state; + }, + order: function order() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'RESET_BLOCKS': + return mapBlockOrder(action.blocks); + + case 'RECEIVE_BLOCKS': + return Object(objectSpread["a" /* default */])({}, state, Object(external_lodash_["omit"])(mapBlockOrder(action.blocks), '')); + + case 'INSERT_BLOCKS': + { + var _action$rootClientId = action.rootClientId, + rootClientId = _action$rootClientId === void 0 ? '' : _action$rootClientId; + var subState = state[rootClientId] || []; + var mappedBlocks = mapBlockOrder(action.blocks, rootClientId); + var _action$index = action.index, + index = _action$index === void 0 ? subState.length : _action$index; + return Object(objectSpread["a" /* default */])({}, state, mappedBlocks, Object(defineProperty["a" /* default */])({}, rootClientId, insertAt(subState, mappedBlocks[rootClientId], index))); + } + + case 'MOVE_BLOCK_TO_POSITION': + { + var _objectSpread7; + + var _action$fromRootClien = action.fromRootClientId, + fromRootClientId = _action$fromRootClien === void 0 ? '' : _action$fromRootClien, + _action$toRootClientI = action.toRootClientId, + toRootClientId = _action$toRootClientI === void 0 ? '' : _action$toRootClientI, + clientId = action.clientId; + + var _action$index2 = action.index, + _index = _action$index2 === void 0 ? state[toRootClientId].length : _action$index2; // Moving inside the same parent block + + + if (fromRootClientId === toRootClientId) { + var _subState = state[toRootClientId]; + + var fromIndex = _subState.indexOf(clientId); + + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, toRootClientId, moveTo(state[toRootClientId], fromIndex, _index))); + } // Moving from a parent block to another + + + return Object(objectSpread["a" /* default */])({}, state, (_objectSpread7 = {}, Object(defineProperty["a" /* default */])(_objectSpread7, fromRootClientId, Object(external_lodash_["without"])(state[fromRootClientId], clientId)), Object(defineProperty["a" /* default */])(_objectSpread7, toRootClientId, insertAt(state[toRootClientId], clientId, _index)), _objectSpread7)); + } + + case 'MOVE_BLOCKS_UP': + { + var clientIds = action.clientIds, + _action$rootClientId2 = action.rootClientId, + _rootClientId = _action$rootClientId2 === void 0 ? '' : _action$rootClientId2; + + var firstClientId = Object(external_lodash_["first"])(clientIds); + var _subState2 = state[_rootClientId]; + + if (!_subState2.length || firstClientId === Object(external_lodash_["first"])(_subState2)) { + return state; + } + + var firstIndex = _subState2.indexOf(firstClientId); + + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, _rootClientId, moveTo(_subState2, firstIndex, firstIndex - 1, clientIds.length))); + } + + case 'MOVE_BLOCKS_DOWN': + { + var _clientIds = action.clientIds, + _action$rootClientId3 = action.rootClientId, + _rootClientId2 = _action$rootClientId3 === void 0 ? '' : _action$rootClientId3; + + var _firstClientId = Object(external_lodash_["first"])(_clientIds); + + var lastClientId = Object(external_lodash_["last"])(_clientIds); + var _subState3 = state[_rootClientId2]; + + if (!_subState3.length || lastClientId === Object(external_lodash_["last"])(_subState3)) { + return state; + } + + var _firstIndex = _subState3.indexOf(_firstClientId); + + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, _rootClientId2, moveTo(_subState3, _firstIndex, _firstIndex + 1, _clientIds.length))); + } + + case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': + { + var _clientIds2 = action.clientIds; + + if (!action.blocks) { + return state; + } + + var _mappedBlocks = mapBlockOrder(action.blocks); + + return Object(external_lodash_["flow"])([function (nextState) { + return Object(external_lodash_["omit"])(nextState, action.replacedClientIds); + }, function (nextState) { + return Object(objectSpread["a" /* default */])({}, nextState, Object(external_lodash_["omit"])(_mappedBlocks, '')); + }, function (nextState) { + return Object(external_lodash_["mapValues"])(nextState, function (subState) { + return Object(external_lodash_["reduce"])(subState, function (result, clientId) { + if (clientId === _clientIds2[0]) { + return [].concat(Object(toConsumableArray["a" /* default */])(result), Object(toConsumableArray["a" /* default */])(_mappedBlocks[''])); + } + + if (_clientIds2.indexOf(clientId) === -1) { + result.push(clientId); + } + + return result; + }, []); + }); + }])(state); + } + + case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': + return Object(external_lodash_["flow"])([// Remove inner block ordering for removed blocks + function (nextState) { + return Object(external_lodash_["omit"])(nextState, action.removedClientIds); + }, // Remove deleted blocks from other blocks' orderings + function (nextState) { + return Object(external_lodash_["mapValues"])(nextState, function (subState) { + return external_lodash_["without"].apply(void 0, [subState].concat(Object(toConsumableArray["a" /* default */])(action.removedClientIds))); + }); + }])(state); + } + + return state; + }, + // While technically redundant data as the inverse of `order`, it serves as + // an optimization for the selectors which derive the ancestry of a block. + parents: function parents() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'RESET_BLOCKS': + return mapBlockParents(action.blocks); + + case 'RECEIVE_BLOCKS': + return Object(objectSpread["a" /* default */])({}, state, mapBlockParents(action.blocks)); + + case 'INSERT_BLOCKS': + return Object(objectSpread["a" /* default */])({}, state, mapBlockParents(action.blocks, action.rootClientId || '')); + + case 'MOVE_BLOCK_TO_POSITION': + { + return Object(objectSpread["a" /* default */])({}, state, Object(defineProperty["a" /* default */])({}, action.clientId, action.toRootClientId || '')); + } + + case 'REPLACE_BLOCKS_AUGMENTED_WITH_CHILDREN': + return Object(objectSpread["a" /* default */])({}, Object(external_lodash_["omit"])(state, action.replacedClientIds), mapBlockParents(action.blocks, state[action.clientIds[0]])); + + case 'REMOVE_BLOCKS_AUGMENTED_WITH_CHILDREN': + return Object(external_lodash_["omit"])(state, action.removedClientIds); + } + + return state; + } +}); +/** + * Reducer returning typing state. + * + * @param {boolean} state Current state. + * @param {Object} action Dispatched action. + * + * @return {boolean} Updated state. + */ + +function reducer_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 reducer_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; +} +var BLOCK_SELECTION_EMPTY_OBJECT = {}; +var BLOCK_SELECTION_INITIAL_STATE = { + start: BLOCK_SELECTION_EMPTY_OBJECT, + end: BLOCK_SELECTION_EMPTY_OBJECT, + isMultiSelecting: false, + isEnabled: true, + initialPosition: null +}; +/** + * 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] : BLOCK_SELECTION_INITIAL_STATE; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'CLEAR_SELECTED_BLOCK': + if (!state.start || !state.start.clientId) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + start: BLOCK_SELECTION_EMPTY_OBJECT, + end: BLOCK_SELECTION_EMPTY_OBJECT, + 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, { + isMultiSelecting: state.isMultiSelecting, + start: { + clientId: action.start + }, + end: { + clientId: action.end + } + }); + + case 'SELECT_BLOCK': + if (action.clientId === state.start.clientId && action.clientId === state.end.clientId) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + initialPosition: action.initialPosition, + start: { + clientId: action.clientId + }, + end: { + clientId: action.clientId + } + }); + + case 'REPLACE_INNER_BLOCKS': // REPLACE_INNER_BLOCKS and INSERT_BLOCKS should follow the same logic. + + case 'INSERT_BLOCKS': + { + if (action.updateSelection) { + return Object(objectSpread["a" /* default */])({}, state, { + start: { + clientId: action.blocks[0].clientId + }, + end: { + clientId: action.blocks[0].clientId + } + }); + } + + return state; + } + + case 'REMOVE_BLOCKS': + if (!action.clientIds || !action.clientIds.length || action.clientIds.indexOf(state.start.clientId) === -1) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + start: BLOCK_SELECTION_EMPTY_OBJECT, + end: BLOCK_SELECTION_EMPTY_OBJECT, + isMultiSelecting: false, + initialPosition: null + }); + + case 'REPLACE_BLOCKS': + { + if (action.clientIds.indexOf(state.start.clientId) === -1) { + return state; + } + + var indexToSelect = action.indexToSelect || action.blocks.length - 1; + var blockToSelect = action.blocks[indexToSelect]; + + if (!blockToSelect) { + return Object(objectSpread["a" /* default */])({}, state, { + start: BLOCK_SELECTION_EMPTY_OBJECT, + end: BLOCK_SELECTION_EMPTY_OBJECT, + isMultiSelecting: false, + initialPosition: null + }); + } + + if (blockToSelect.clientId === state.start.clientId && blockToSelect.clientId === state.end.clientId) { + return state; + } + + return Object(objectSpread["a" /* default */])({}, state, { + start: { + clientId: blockToSelect.clientId + }, + end: { + clientId: blockToSelect.clientId + } + }); + } + + case 'TOGGLE_SELECTION': + return Object(objectSpread["a" /* default */])({}, state, { + isEnabled: action.isSelectionEnabled + }); + + case 'SELECTION_CHANGE': + return Object(objectSpread["a" /* default */])({}, state, { + start: { + clientId: action.clientId, + attributeKey: action.attributeKey, + offset: action.startOffset + }, + end: { + clientId: action.clientId, + attributeKey: action.attributeKey, + offset: action.endOffset + } + }); + } + + 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 editor setting. + * + * @param {Object} state Current state. + * @param {Object} action Dispatched action. + * + * @return {Object} Updated state. + */ + +function reducer_settings() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SETTINGS_DEFAULTS; + var action = arguments.length > 1 ? arguments[1] : undefined; + + switch (action.type) { + case 'UPDATE_SETTINGS': + return Object(objectSpread["a" /* default */])({}, state, action.settings); + } + + 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 'INSERT_BLOCKS': + case 'REPLACE_BLOCKS': + return action.blocks.reduce(function (prevState, block) { + var id = block.name; + var insert = { + name: block.name + }; + + if (Object(external_this_wp_blocks_["isReusableBlock"])(block)) { + insert.ref = block.attributes.ref; + id += '/' + block.attributes.ref; + } + + return Object(objectSpread["a" /* default */])({}, prevState, { + insertUsage: Object(objectSpread["a" /* default */])({}, prevState.insertUsage, Object(defineProperty["a" /* default */])({}, id, { + time: action.time, + count: prevState.insertUsage[id] ? prevState.insertUsage[id].count + 1 : 1, + insert: insert + })) + }); + }, state); + } + + 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 whether the navigation mode is enabled or not. + * + * @param {string} state Current state. + * @param {Object} action Dispatched action. + * + * @return {string} Updated state. + */ + +function reducer_isNavigationMode() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + var action = arguments.length > 1 ? arguments[1] : undefined; + + if (action.type === 'SET_NAVIGATION_MODE') { + return action.isNavigationMode; + } + + return state; +} +/** + * Reducer return an updated state representing the most recent block attribute + * update. The state is structured as an object where the keys represent the + * client IDs of blocks, the values a subset of attributes from the most recent + * block update. The state is always reset to null if the last action is + * anything other than an attributes update. + * + * @param {Object<string,Object>} state Current state. + * @param {Object} action Action object. + * + * @return {[string,Object]} Updated state. + */ + +function lastBlockAttributesChange(state, action) { + switch (action.type) { + case 'UPDATE_BLOCK': + if (!action.updates.attributes) { + break; + } + + return Object(defineProperty["a" /* default */])({}, action.clientId, action.updates.attributes); + + case 'UPDATE_BLOCK_ATTRIBUTES': + return Object(defineProperty["a" /* default */])({}, action.clientId, action.attributes); + } + + return null; +} +/** + * Reducer returning automatic change state. + * + * @param {boolean} state Current state. + * @param {Object} action Dispatched action. + * + * @return {boolean} Updated state. + */ + +function reducer_didAutomaticChange(state, action) { + return action.type === 'MARK_AUTOMATIC_CHANGE'; +} +/* harmony default export */ var store_reducer = (Object(external_this_wp_data_["combineReducers"])({ + blocks: reducer_blocks, + isTyping: reducer_isTyping, + isCaretWithinFormattedText: reducer_isCaretWithinFormattedText, + blockSelection: blockSelection, + blocksMode: blocksMode, + blockListSettings: reducer_blockListSettings, + insertionPoint: insertionPoint, + template: reducer_template, + settings: reducer_settings, + preferences: preferences, + lastBlockAttributesChange: lastBlockAttributesChange, + isNavigationMode: reducer_isNavigationMode, + didAutomaticChange: reducer_didAutomaticChange +})); + +// EXTERNAL MODULE: ./node_modules/refx/refx.js +var refx = __webpack_require__(72); +var refx_default = /*#__PURE__*/__webpack_require__.n(refx); + +// EXTERNAL MODULE: ./node_modules/redux-multi/lib/index.js +var redux_multi_lib = __webpack_require__(218); +var redux_multi_lib_default = /*#__PURE__*/__webpack_require__.n(redux_multi_lib); + +// EXTERNAL MODULE: external {"this":["wp","a11y"]} +var external_this_wp_a11y_ = __webpack_require__(45); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/regenerator/index.js +var regenerator = __webpack_require__(20); +var regenerator_default = /*#__PURE__*/__webpack_require__.n(regenerator); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/controls.js + + +/** + * WordPress dependencies + */ + +/** + * Calls a selector using the current state. + * + * @param {string} storeName Store name. + * @param {string} selectorName Selector name. + * @param {Array} args Selector arguments. + * + * @return {Object} control descriptor. + */ + +function controls_select(storeName, 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', + storeName: storeName, + selectorName: selectorName, + args: args + }; +} +var controls_controls = { + SELECT: Object(external_this_wp_data_["createRegistryControl"])(function (registry) { + return function (_ref) { + var _registry$select; + + var storeName = _ref.storeName, + selectorName = _ref.selectorName, + args = _ref.args; + return (_registry$select = registry.select(storeName))[selectorName].apply(_registry$select, Object(toConsumableArray["a" /* default */])(args)); + }; + }) +}; +/* harmony default export */ var store_controls = (controls_controls); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/actions.js + + + +var _marked = +/*#__PURE__*/ +regenerator_default.a.mark(ensureDefaultBlock), + _marked2 = +/*#__PURE__*/ +regenerator_default.a.mark(selectPreviousBlock), + _marked3 = +/*#__PURE__*/ +regenerator_default.a.mark(selectNextBlock), + _marked4 = +/*#__PURE__*/ +regenerator_default.a.mark(actions_replaceBlocks), + _marked5 = +/*#__PURE__*/ +regenerator_default.a.mark(moveBlockToPosition), + _marked6 = +/*#__PURE__*/ +regenerator_default.a.mark(actions_insertBlocks), + _marked7 = +/*#__PURE__*/ +regenerator_default.a.mark(actions_removeBlocks); + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +/** + * Generator which will yield a default block insert action if there + * are no other blocks at the root of the editor. This generator should be used + * in actions which may result in no blocks remaining in the editor (removal, + * replacement, etc). + */ + +function ensureDefaultBlock() { + var count; + return regenerator_default.a.wrap(function ensureDefaultBlock$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + _context.next = 2; + return controls_select('core/block-editor', 'getBlockCount'); + + case 2: + count = _context.sent; + + if (!(count === 0)) { + _context.next = 6; + break; + } + + _context.next = 6; + return actions_insertDefaultBlock(); + + case 6: + case "end": + return _context.stop(); + } + } + }, _marked); +} +/** + * Returns an action object used in signalling that blocks state should be + * reset to the specified array of blocks, taking precedence over any other + * content reflected as an edit in state. + * + * @param {Array} blocks Array of blocks. + * + * @return {Object} Action object. + */ + + +function resetBlocks(blocks) { + return { + type: 'RESET_BLOCKS', + blocks: blocks + }; +} +/** + * Returns an action object used in signalling that blocks have been received. + * Unlike resetBlocks, these should be appended to the existing known set, not + * replacing. + * + * @param {Object[]} blocks Array of block objects. + * + * @return {Object} Action object. + */ + +function receiveBlocks(blocks) { + return { + type: 'RECEIVE_BLOCKS', + blocks: blocks + }; +} +/** + * Returns an action object used in signalling that the block attributes with + * the specified client ID has been updated. + * + * @param {string} clientId Block client ID. + * @param {Object} attributes Block attributes to be merged. + * + * @return {Object} Action object. + */ + +function actions_updateBlockAttributes(clientId, attributes) { + return { + type: 'UPDATE_BLOCK_ATTRIBUTES', + clientId: clientId, + attributes: attributes + }; +} +/** + * Returns an action object used in signalling that the block with the + * specified client ID has been updated. + * + * @param {string} clientId Block client ID. + * @param {Object} updates Block attributes to be merged. + * + * @return {Object} Action object. + */ + +function updateBlock(clientId, updates) { + return { + type: 'UPDATE_BLOCK', + clientId: clientId, + updates: updates + }; +} +/** + * Returns an action object used in signalling that the block with the + * specified client ID has been selected, optionally accepting a position + * value reflecting its selection directionality. An initialPosition of -1 + * reflects a reverse selection. + * + * @param {string} clientId Block client ID. + * @param {?number} initialPosition Optional initial position. Pass as -1 to + * reflect reverse selection. + * + * @return {Object} Action object. + */ + +function actions_selectBlock(clientId) { + var initialPosition = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + return { + type: 'SELECT_BLOCK', + initialPosition: initialPosition, + clientId: clientId + }; +} +/** + * Yields action objects used in signalling that the block preceding the given + * clientId should be selected. + * + * @param {string} clientId Block client ID. + */ + +function selectPreviousBlock(clientId) { + var previousBlockClientId; + return regenerator_default.a.wrap(function selectPreviousBlock$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + _context2.next = 2; + return controls_select('core/block-editor', 'getPreviousBlockClientId', clientId); + + case 2: + previousBlockClientId = _context2.sent; + + if (!previousBlockClientId) { + _context2.next = 6; + break; + } + + _context2.next = 6; + return actions_selectBlock(previousBlockClientId, -1); + + case 6: + case "end": + return _context2.stop(); + } + } + }, _marked2); +} +/** + * Yields action objects used in signalling that the block following the given + * clientId should be selected. + * + * @param {string} clientId Block client ID. + */ + +function selectNextBlock(clientId) { + var nextBlockClientId; + return regenerator_default.a.wrap(function selectNextBlock$(_context3) { + while (1) { + switch (_context3.prev = _context3.next) { + case 0: + _context3.next = 2; + return controls_select('core/block-editor', 'getNextBlockClientId', clientId); + + case 2: + nextBlockClientId = _context3.sent; + + if (!nextBlockClientId) { + _context3.next = 6; + break; + } + + _context3.next = 6; + return actions_selectBlock(nextBlockClientId); + + case 6: + case "end": + return _context3.stop(); + } + } + }, _marked3); +} +/** + * Returns an action object used in signalling that a block multi-selection has started. + * + * @return {Object} Action object. + */ + +function startMultiSelect() { + return { + type: 'START_MULTI_SELECT' + }; +} +/** + * Returns an action object used in signalling that block multi-selection stopped. + * + * @return {Object} Action object. + */ + +function stopMultiSelect() { + return { + type: 'STOP_MULTI_SELECT' + }; +} +/** + * Returns an action object used in signalling that block multi-selection changed. + * + * @param {string} start First block of the multi selection. + * @param {string} end Last block of the multiselection. + * + * @return {Object} Action object. + */ + +function actions_multiSelect(start, end) { + return { + type: 'MULTI_SELECT', + start: start, + end: end + }; +} +/** + * Returns an action object used in signalling that the block selection is cleared. + * + * @return {Object} Action object. + */ + +function clearSelectedBlock() { + return { + type: 'CLEAR_SELECTED_BLOCK' + }; +} +/** + * Returns an action object that enables or disables block selection. + * + * @param {boolean} [isSelectionEnabled=true] Whether block selection should + * be enabled. + * + * @return {Object} Action object. + */ + +function actions_toggleSelection() { + var isSelectionEnabled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + return { + type: 'TOGGLE_SELECTION', + isSelectionEnabled: isSelectionEnabled + }; +} + +function getBlocksWithDefaultStylesApplied(blocks, blockEditorSettings) { + var preferredStyleVariations = Object(external_lodash_["get"])(blockEditorSettings, ['__experimentalPreferredStyleVariations', 'value'], {}); + return blocks.map(function (block) { + var blockName = block.name; + + if (!preferredStyleVariations[blockName]) { + return block; + } + + var className = Object(external_lodash_["get"])(block, ['attributes', 'className']); + + if (Object(external_lodash_["includes"])(className, 'is-style-')) { + return block; + } + + var _block$attributes = block.attributes, + attributes = _block$attributes === void 0 ? {} : _block$attributes; + var blockStyle = preferredStyleVariations[blockName]; + return Object(objectSpread["a" /* default */])({}, block, { + attributes: Object(objectSpread["a" /* default */])({}, attributes, { + className: "".concat(className || '', " is-style-").concat(blockStyle).trim() + }) + }); + }); +} +/** + * Returns an action object signalling that a blocks should be replaced with + * one or more replacement blocks. + * + * @param {(string|string[])} clientIds Block client ID(s) to replace. + * @param {(Object|Object[])} blocks Replacement block(s). + * @param {number} indexToSelect Index of replacement block to + * select. + * + * @yield {Object} Action object. + */ + + +function actions_replaceBlocks(clientIds, blocks, indexToSelect) { + var rootClientId, index, block, canInsertBlock; + return regenerator_default.a.wrap(function replaceBlocks$(_context4) { + while (1) { + switch (_context4.prev = _context4.next) { + case 0: + clientIds = Object(external_lodash_["castArray"])(clientIds); + _context4.t0 = getBlocksWithDefaultStylesApplied; + _context4.t1 = Object(external_lodash_["castArray"])(blocks); + _context4.next = 5; + return controls_select('core/block-editor', 'getSettings'); + + case 5: + _context4.t2 = _context4.sent; + blocks = (0, _context4.t0)(_context4.t1, _context4.t2); + _context4.next = 9; + return controls_select('core/block-editor', 'getBlockRootClientId', Object(external_lodash_["first"])(clientIds)); + + case 9: + rootClientId = _context4.sent; + index = 0; + + case 11: + if (!(index < blocks.length)) { + _context4.next = 21; + break; + } + + block = blocks[index]; + _context4.next = 15; + return controls_select('core/block-editor', 'canInsertBlockType', block.name, rootClientId); + + case 15: + canInsertBlock = _context4.sent; + + if (canInsertBlock) { + _context4.next = 18; + break; + } + + return _context4.abrupt("return"); + + case 18: + index++; + _context4.next = 11; + break; + + case 21: + _context4.next = 23; + return { + type: 'REPLACE_BLOCKS', + clientIds: clientIds, + blocks: blocks, + time: Date.now(), + indexToSelect: indexToSelect + }; + + case 23: + return _context4.delegateYield(ensureDefaultBlock(), "t3", 24); + + case 24: + case "end": + return _context4.stop(); + } + } + }, _marked4); +} +/** + * Returns an action object signalling that a single block should be replaced + * with one or more replacement blocks. + * + * @param {(string|string[])} clientId Block client ID to replace. + * @param {(Object|Object[])} block Replacement block(s). + * + * @return {Object} Action object. + */ + +function replaceBlock(clientId, block) { + return actions_replaceBlocks(clientId, block); +} +/** + * Higher-order action creator which, given the action type to dispatch creates + * an action creator for managing block movement. + * + * @param {string} type Action type to dispatch. + * + * @return {Function} Action creator. + */ + +function createOnMove(type) { + return function (clientIds, rootClientId) { + return { + clientIds: Object(external_lodash_["castArray"])(clientIds), + type: type, + rootClientId: rootClientId + }; + }; +} + +var actions_moveBlocksDown = createOnMove('MOVE_BLOCKS_DOWN'); +var actions_moveBlocksUp = createOnMove('MOVE_BLOCKS_UP'); +/** + * Returns an action object signalling that an indexed block should be moved + * to a new index. + * + * @param {?string} clientId The client ID of the block. + * @param {?string} fromRootClientId Root client ID source. + * @param {?string} toRootClientId Root client ID destination. + * @param {number} index The index to move the block into. + * + * @yield {Object} Action object. + */ + +function moveBlockToPosition(clientId) { + var fromRootClientId, + toRootClientId, + index, + templateLock, + action, + blockName, + canInsertBlock, + _args5 = arguments; + return regenerator_default.a.wrap(function moveBlockToPosition$(_context5) { + while (1) { + switch (_context5.prev = _context5.next) { + case 0: + fromRootClientId = _args5.length > 1 && _args5[1] !== undefined ? _args5[1] : ''; + toRootClientId = _args5.length > 2 && _args5[2] !== undefined ? _args5[2] : ''; + index = _args5.length > 3 ? _args5[3] : undefined; + _context5.next = 5; + return controls_select('core/block-editor', 'getTemplateLock', fromRootClientId); + + case 5: + templateLock = _context5.sent; + + if (!(templateLock === 'all')) { + _context5.next = 8; + break; + } + + return _context5.abrupt("return"); + + case 8: + action = { + type: 'MOVE_BLOCK_TO_POSITION', + fromRootClientId: fromRootClientId, + toRootClientId: toRootClientId, + clientId: clientId, + index: index + }; // If moving inside the same root block the move is always possible. + + if (!(fromRootClientId === toRootClientId)) { + _context5.next = 13; + break; + } + + _context5.next = 12; + return action; + + case 12: + return _context5.abrupt("return"); + + case 13: + if (!(templateLock === 'insert')) { + _context5.next = 15; + break; + } + + return _context5.abrupt("return"); + + case 15: + _context5.next = 17; + return controls_select('core/block-editor', 'getBlockName', clientId); + + case 17: + blockName = _context5.sent; + _context5.next = 20; + return controls_select('core/block-editor', 'canInsertBlockType', blockName, toRootClientId); + + case 20: + canInsertBlock = _context5.sent; + + if (!canInsertBlock) { + _context5.next = 24; + break; + } + + _context5.next = 24; + return action; + + case 24: + case "end": + return _context5.stop(); + } + } + }, _marked5); +} +/** + * Returns an action object used in signalling that a single block should be + * inserted, optionally at a specific index respective a root block list. + * + * @param {Object} block Block object to insert. + * @param {?number} index Index at which block should be inserted. + * @param {?string} rootClientId Optional root client ID of block list on which to insert. + * @param {?boolean} updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to true. + * + * @return {Object} Action object. + */ + +function actions_insertBlock(block, index, rootClientId) { + var updateSelection = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + return actions_insertBlocks([block], index, rootClientId, updateSelection); +} +/** + * Returns an action object used in signalling that an array of blocks should + * be inserted, optionally at a specific index respective a root block list. + * + * @param {Object[]} blocks Block objects to insert. + * @param {?number} index Index at which block should be inserted. + * @param {?string} rootClientId Optional root client ID of block list on which to insert. + * @param {?boolean} updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to true. + * + * @return {Object} Action object. + */ + +function actions_insertBlocks(blocks, index, rootClientId) { + var updateSelection, + allowedBlocks, + _iteratorNormalCompletion, + _didIteratorError, + _iteratorError, + _iterator, + _step, + block, + isValid, + _args6 = arguments; + + return regenerator_default.a.wrap(function insertBlocks$(_context6) { + while (1) { + switch (_context6.prev = _context6.next) { + case 0: + updateSelection = _args6.length > 3 && _args6[3] !== undefined ? _args6[3] : true; + _context6.t0 = getBlocksWithDefaultStylesApplied; + _context6.t1 = Object(external_lodash_["castArray"])(blocks); + _context6.next = 5; + return controls_select('core/block-editor', 'getSettings'); + + case 5: + _context6.t2 = _context6.sent; + blocks = (0, _context6.t0)(_context6.t1, _context6.t2); + allowedBlocks = []; + _iteratorNormalCompletion = true; + _didIteratorError = false; + _iteratorError = undefined; + _context6.prev = 11; + _iterator = blocks[Symbol.iterator](); + + case 13: + if (_iteratorNormalCompletion = (_step = _iterator.next()).done) { + _context6.next = 22; + break; + } + + block = _step.value; + _context6.next = 17; + return controls_select('core/block-editor', 'canInsertBlockType', block.name, rootClientId); + + case 17: + isValid = _context6.sent; + + if (isValid) { + allowedBlocks.push(block); + } + + case 19: + _iteratorNormalCompletion = true; + _context6.next = 13; + break; + + case 22: + _context6.next = 28; + break; + + case 24: + _context6.prev = 24; + _context6.t3 = _context6["catch"](11); + _didIteratorError = true; + _iteratorError = _context6.t3; + + case 28: + _context6.prev = 28; + _context6.prev = 29; + + if (!_iteratorNormalCompletion && _iterator.return != null) { + _iterator.return(); + } + + case 31: + _context6.prev = 31; + + if (!_didIteratorError) { + _context6.next = 34; + break; + } + + throw _iteratorError; + + case 34: + return _context6.finish(31); + + case 35: + return _context6.finish(28); + + case 36: + if (!allowedBlocks.length) { + _context6.next = 38; + break; + } + + return _context6.abrupt("return", { + type: 'INSERT_BLOCKS', + blocks: allowedBlocks, + index: index, + rootClientId: rootClientId, + time: Date.now(), + updateSelection: updateSelection + }); + + case 38: + case "end": + return _context6.stop(); + } + } + }, _marked6, null, [[11, 24, 28, 36], [29,, 31, 35]]); +} +/** + * Returns an action object used in signalling that the insertion point should + * be shown. + * + * @param {?string} rootClientId Optional root client ID of block list on + * which to insert. + * @param {?number} index Index at which block should be inserted. + * + * @return {Object} Action object. + */ + +function actions_showInsertionPoint(rootClientId, index) { + return { + type: 'SHOW_INSERTION_POINT', + rootClientId: rootClientId, + index: index + }; +} +/** + * Returns an action object hiding the insertion point. + * + * @return {Object} Action object. + */ + +function actions_hideInsertionPoint() { + return { + type: 'HIDE_INSERTION_POINT' + }; +} +/** + * Returns an action object resetting the template validity. + * + * @param {boolean} isValid template validity flag. + * + * @return {Object} Action object. + */ + +function setTemplateValidity(isValid) { + return { + type: 'SET_TEMPLATE_VALIDITY', + isValid: isValid + }; +} +/** + * Returns an action object synchronize the template with the list of blocks + * + * @return {Object} Action object. + */ + +function synchronizeTemplate() { + return { + type: 'SYNCHRONIZE_TEMPLATE' + }; +} +/** + * Returns an action object used in signalling that two blocks should be merged + * + * @param {string} firstBlockClientId Client ID of the first block to merge. + * @param {string} secondBlockClientId Client ID of the second block to merge. + * + * @return {Object} Action object. + */ + +function actions_mergeBlocks(firstBlockClientId, secondBlockClientId) { + return { + type: 'MERGE_BLOCKS', + blocks: [firstBlockClientId, secondBlockClientId] + }; +} +/** + * Yields action objects used in signalling that the blocks corresponding to + * the set of specified client IDs are to be removed. + * + * @param {string|string[]} clientIds Client IDs of blocks to remove. + * @param {boolean} selectPrevious True if the previous block should be + * selected when a block is removed. + */ + +function actions_removeBlocks(clientIds) { + var selectPrevious, + _args7 = arguments; + return regenerator_default.a.wrap(function removeBlocks$(_context7) { + while (1) { + switch (_context7.prev = _context7.next) { + case 0: + selectPrevious = _args7.length > 1 && _args7[1] !== undefined ? _args7[1] : true; + clientIds = Object(external_lodash_["castArray"])(clientIds); + + if (!selectPrevious) { + _context7.next = 5; + break; + } + + _context7.next = 5; + return selectPreviousBlock(clientIds[0]); + + case 5: + _context7.next = 7; + return { + type: 'REMOVE_BLOCKS', + clientIds: clientIds + }; + + case 7: + return _context7.delegateYield(ensureDefaultBlock(), "t0", 8); + + case 8: + case "end": + return _context7.stop(); + } + } + }, _marked7); +} +/** + * Returns an action object used in signalling that the block with the + * specified client ID is to be removed. + * + * @param {string} clientId Client ID of block to remove. + * @param {boolean} selectPrevious True if the previous block should be + * selected when a block is removed. + * + * @return {Object} Action object. + */ + +function actions_removeBlock(clientId, selectPrevious) { + return actions_removeBlocks([clientId], selectPrevious); +} +/** + * Returns an action object used in signalling that the inner blocks with the + * specified client ID should be replaced. + * + * @param {string} rootClientId Client ID of the block whose InnerBlocks will re replaced. + * @param {Object[]} blocks Block objects to insert as new InnerBlocks + * @param {?boolean} updateSelection If true block selection will be updated. If false, block selection will not change. Defaults to true. + * + * @return {Object} Action object. + */ + +function actions_replaceInnerBlocks(rootClientId, blocks) { + var updateSelection = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + return { + type: 'REPLACE_INNER_BLOCKS', + rootClientId: rootClientId, + blocks: blocks, + updateSelection: updateSelection, + time: Date.now() + }; +} +/** + * Returns an action object used to toggle the block editing mode between + * visual and HTML modes. + * + * @param {string} clientId Block client ID. + * + * @return {Object} Action object. + */ + +function toggleBlockMode(clientId) { + return { + type: 'TOGGLE_BLOCK_MODE', + clientId: clientId + }; +} +/** + * Returns an action object used in signalling that the user has begun to type. + * + * @return {Object} Action object. + */ + +function startTyping() { + return { + type: 'START_TYPING' + }; +} +/** + * Returns an action object used in signalling that the user has stopped typing. + * + * @return {Object} Action object. + */ + +function stopTyping() { + return { + type: 'STOP_TYPING' + }; +} +/** + * Returns an action object used in signalling that the caret has entered formatted text. + * + * @return {Object} Action object. + */ + +function enterFormattedText() { + return { + type: 'ENTER_FORMATTED_TEXT' + }; +} +/** + * Returns an action object used in signalling that the user caret has exited formatted text. + * + * @return {Object} Action object. + */ + +function exitFormattedText() { + return { + type: 'EXIT_FORMATTED_TEXT' + }; +} +/** + * Returns an action object used in signalling that the user caret has changed + * position. + * + * @param {string} clientId The selected block client ID. + * @param {string} attributeKey The selected block attribute key. + * @param {number} startOffset The start offset. + * @param {number} endOffset The end offset. + * + * @return {Object} Action object. + */ + +function selectionChange(clientId, attributeKey, startOffset, endOffset) { + return { + type: 'SELECTION_CHANGE', + clientId: clientId, + attributeKey: attributeKey, + startOffset: startOffset, + endOffset: endOffset + }; +} +/** + * Returns an action object used in signalling that a new block of the default + * type should be added to the block list. + * + * @param {?Object} attributes Optional attributes of the block to assign. + * @param {?string} rootClientId Optional root client ID of block list on which + * to append. + * @param {?number} index Optional index where to insert the default block + * + * @return {Object} Action object + */ + +function actions_insertDefaultBlock(attributes, rootClientId, index) { + // Abort if there is no default block type (if it has been unregistered). + var defaultBlockName = Object(external_this_wp_blocks_["getDefaultBlockName"])(); + + if (!defaultBlockName) { + return; + } + + var block = Object(external_this_wp_blocks_["createBlock"])(defaultBlockName, attributes); + return actions_insertBlock(block, index, rootClientId); +} +/** + * Returns an action object that changes the nested settings of a given block. + * + * @param {string} clientId Client ID of the block whose nested setting are + * being received. + * @param {Object} settings Object with the new settings for the nested block. + * + * @return {Object} Action object + */ + +function updateBlockListSettings(clientId, settings) { + return { + type: 'UPDATE_BLOCK_LIST_SETTINGS', + clientId: clientId, + settings: settings + }; +} +/* + * Returns an action object used in signalling that the block editor settings have been updated. + * + * @param {Object} settings Updated settings + * + * @return {Object} Action object + */ + +function updateSettings(settings) { + return { + type: 'UPDATE_SETTINGS', + settings: settings + }; +} +/** + * Returns an action object used in signalling that a temporary reusable blocks have been saved + * in order to switch its temporary id with the real id. + * + * @param {string} id Reusable block's id. + * @param {string} updatedId Updated block's id. + * + * @return {Object} Action object. + */ + +function __unstableSaveReusableBlock(id, updatedId) { + return { + type: 'SAVE_REUSABLE_BLOCK_SUCCESS', + id: id, + updatedId: updatedId + }; +} +/** + * Returns an action object used in signalling that the last block change should be marked explicitely as persistent. + * + * @return {Object} Action object. + */ + +function actions_unstableMarkLastChangeAsPersistent() { + return { + type: 'MARK_LAST_CHANGE_AS_PERSISTENT' + }; +} +/** + * Returns an action object used in signalling that the last block change is + * an automatic change, meaning it was not performed by the user, and can be + * undone using the `Escape` and `Backspace` keys. This action must be called + * after the change was made, and any actions that are a consequence of it, so + * it is recommended to be called at the next idle period to ensure all + * selection changes have been recorded. + * + * @return {Object} Action object. + */ + +function __unstableMarkAutomaticChange() { + return { + type: 'MARK_AUTOMATIC_CHANGE' + }; +} +/** + * Returns an action object used to enable or disable the navigation mode. + * + * @param {string} isNavigationMode Enable/Disable navigation mode. + * + * @return {Object} Action object + */ + +function actions_setNavigationMode() { + var isNavigationMode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; + return { + type: 'SET_NAVIGATION_MODE', + isNavigationMode: isNavigationMode + }; +} + +// EXTERNAL MODULE: ./node_modules/rememo/es/rememo.js +var rememo = __webpack_require__(36); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/selectors.js + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + // Module constants + +/** + * @private + */ + +var INSERTER_UTILITY_HIGH = 3; +/** + * @private + */ + +var INSERTER_UTILITY_MEDIUM = 2; +/** + * @private + */ + +var INSERTER_UTILITY_LOW = 1; +/** + * @private + */ + +var INSERTER_UTILITY_NONE = 0; +var MILLISECONDS_PER_HOUR = 3600 * 1000; +var MILLISECONDS_PER_DAY = 24 * 3600 * 1000; +var MILLISECONDS_PER_WEEK = 7 * 24 * 3600 * 1000; +var templateIcon = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 24 24" +}, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Rect"], { + x: "0", + fill: "none", + width: "24", + height: "24" +}), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["G"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + d: "M19 3H5c-1.105 0-2 .895-2 2v14c0 1.105.895 2 2 2h14c1.105 0 2-.895 2-2V5c0-1.105-.895-2-2-2zM6 6h5v5H6V6zm4.5 13C9.12 19 8 17.88 8 16.5S9.12 14 10.5 14s2.5 1.12 2.5 2.5-1.12 2.5-2.5 2.5zm3-6l3-5 3 5h-6z" +}))); +/** + * Shared reference to an empty array for cases where it is important to avoid + * returning a new array 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. + * + * @type {Array} + */ + +var EMPTY_ARRAY = []; +/** + * Returns a block's name given its client ID, or null if no block exists with + * the client ID. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {string} Block name. + */ + +function selectors_getBlockName(state, clientId) { + var block = state.blocks.byClientId[clientId]; + return block ? block.name : null; +} +/** + * Returns whether a block is valid or not. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {boolean} Is Valid. + */ + +function selectors_isBlockValid(state, clientId) { + var block = state.blocks.byClientId[clientId]; + return !!block && block.isValid; +} +/** + * Returns a block's attributes given its client ID, or null if no block exists with + * the client ID. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {Object?} Block attributes. + */ + +function getBlockAttributes(state, clientId) { + var block = state.blocks.byClientId[clientId]; + + if (!block) { + return null; + } + + return state.blocks.attributes[clientId]; +} +/** + * Returns a block given its client ID. This is a parsed copy of the block, + * containing its `blockName`, `clientId`, and current `attributes` state. This + * is not the block's registration settings, which must be retrieved from the + * blocks module registration store. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {Object} Parsed block object. + */ + +var selectors_getBlock = Object(rememo["a" /* default */])(function (state, clientId) { + var block = state.blocks.byClientId[clientId]; + + if (!block) { + return null; + } + + return Object(objectSpread["a" /* default */])({}, block, { + attributes: getBlockAttributes(state, clientId), + innerBlocks: selectors_getBlocks(state, clientId) + }); +}, function (state, clientId) { + return [// Normally, we'd have both `getBlockAttributes` dependancies and + // `getBlocks` (children) dependancies here but for performance reasons + // we use a denormalized cache key computed in the reducer that takes both + // the attributes and inner blocks into account. The value of the cache key + // is being changed whenever one of these dependencies is out of date. + state.blocks.cache[clientId]]; +}); +var selectors_unstableGetBlockWithoutInnerBlocks = Object(rememo["a" /* default */])(function (state, clientId) { + var block = state.blocks.byClientId[clientId]; + + if (!block) { + return null; + } + + return Object(objectSpread["a" /* default */])({}, block, { + attributes: getBlockAttributes(state, clientId) + }); +}, function (state, clientId) { + return [state.blocks.byClientId[clientId], state.blocks.attributes[clientId]]; +}); +/** + * Returns all block objects for the current post being edited as an array in + * the order they appear in the post. + * + * Note: It's important to memoize this selector to avoid return a new instance + * on each call + * + * @param {Object} state Editor state. + * @param {?string} rootClientId Optional root client ID of block list. + * + * @return {Object[]} Post blocks. + */ + +var selectors_getBlocks = Object(rememo["a" /* default */])(function (state, rootClientId) { + return Object(external_lodash_["map"])(selectors_getBlockOrder(state, rootClientId), function (clientId) { + return selectors_getBlock(state, clientId); + }); +}, function (state) { + return [state.blocks.byClientId, state.blocks.order, state.blocks.attributes]; +}); +/** + * Returns an array containing the clientIds of all descendants + * of the blocks given. + * + * @param {Object} state Global application state. + * @param {Array} clientIds Array of blocks to inspect. + * + * @return {Array} ids of descendants. + */ + +var selectors_getClientIdsOfDescendants = function getClientIdsOfDescendants(state, clientIds) { + return Object(external_lodash_["flatMap"])(clientIds, function (clientId) { + var descendants = selectors_getBlockOrder(state, clientId); + return [].concat(Object(toConsumableArray["a" /* default */])(descendants), Object(toConsumableArray["a" /* default */])(getClientIdsOfDescendants(state, descendants))); + }); +}; +/** + * Returns an array containing the clientIds of the top-level blocks + * and their descendants of any depth (for nested blocks). + * + * @param {Object} state Global application state. + * + * @return {Array} ids of top-level and descendant blocks. + */ + +var getClientIdsWithDescendants = Object(rememo["a" /* default */])(function (state) { + var topLevelIds = selectors_getBlockOrder(state); + return [].concat(Object(toConsumableArray["a" /* default */])(topLevelIds), Object(toConsumableArray["a" /* default */])(selectors_getClientIdsOfDescendants(state, topLevelIds))); +}, function (state) { + return [state.blocks.order]; +}); +/** + * Returns the total number of blocks, or the total number of blocks with a specific name in a post. + * The number returned includes nested blocks. + * + * @param {Object} state Global application state. + * @param {?string} blockName Optional block name, if specified only blocks of that type will be counted. + * + * @return {number} Number of blocks in the post, or number of blocks with name equal to blockName. + */ + +var getGlobalBlockCount = Object(rememo["a" /* default */])(function (state, blockName) { + var clientIds = getClientIdsWithDescendants(state); + + if (!blockName) { + return clientIds.length; + } + + return Object(external_lodash_["reduce"])(clientIds, function (count, clientId) { + var block = state.blocks.byClientId[clientId]; + return block.name === blockName ? count + 1 : count; + }, 0); +}, function (state) { + return [state.blocks.order, state.blocks.byClientId]; +}); +/** + * Given an array of block client IDs, returns the corresponding array of block + * objects. + * + * @param {Object} state Editor state. + * @param {string[]} clientIds Client IDs for which blocks are to be returned. + * + * @return {WPBlock[]} Block objects. + */ + +var selectors_getBlocksByClientId = Object(rememo["a" /* default */])(function (state, clientIds) { + return Object(external_lodash_["map"])(Object(external_lodash_["castArray"])(clientIds), function (clientId) { + return selectors_getBlock(state, clientId); + }); +}, function (state) { + return [state.blocks.byClientId, state.blocks.order, state.blocks.attributes]; +}); +/** + * Returns the number of blocks currently present in the post. + * + * @param {Object} state Editor state. + * @param {?string} rootClientId Optional root client ID of block list. + * + * @return {number} Number of blocks in the post. + */ + +function selectors_getBlockCount(state, rootClientId) { + return selectors_getBlockOrder(state, rootClientId).length; +} +/** + * @typedef {WPBlockSelection} A block selection object. + * + * @property {string} clientId The selected block client ID. + * @property {string} attributeKey The selected block attribute key. + * @property {number} offset The selected block attribute offset. + */ + +/** + * Returns the current selection start block client ID, attribute key and text + * offset. + * + * @param {Object} state Block editor state. + * + * @return {WPBlockSelection} Selection start information. + */ + +function getSelectionStart(state) { + return state.blockSelection.start; +} +/** + * Returns the current selection end block client ID, attribute key and text + * offset. + * + * @param {Object} state Block editor state. + * + * @return {WPBlockSelection} Selection end information. + */ + +function getSelectionEnd(state) { + return state.blockSelection.end; +} +/** + * Returns the current block selection start. This value may be null, and it + * may represent either a singular block selection or multi-selection start. + * A selection is singular if its start and end match. + * + * @param {Object} state Global application state. + * + * @return {?string} Client ID of block selection start. + */ + +function getBlockSelectionStart(state) { + return state.blockSelection.start.clientId; +} +/** + * Returns the current block selection end. This value may be null, and it + * may represent either a singular block selection or multi-selection end. + * A selection is singular if its start and end match. + * + * @param {Object} state Global application state. + * + * @return {?string} Client ID of block selection end. + */ + +function getBlockSelectionEnd(state) { + return state.blockSelection.end.clientId; +} +/** + * Returns the number of blocks currently selected in the post. + * + * @param {Object} state Global application state. + * + * @return {number} Number of blocks selected in the post. + */ + +function selectors_getSelectedBlockCount(state) { + var multiSelectedBlockCount = getMultiSelectedBlockClientIds(state).length; + + if (multiSelectedBlockCount) { + return multiSelectedBlockCount; + } + + return state.blockSelection.start.clientId ? 1 : 0; +} +/** + * Returns true if there is a single selected block, or false otherwise. + * + * @param {Object} state Editor state. + * + * @return {boolean} Whether a single block is selected. + */ + +function hasSelectedBlock(state) { + var _state$blockSelection = state.blockSelection, + start = _state$blockSelection.start, + end = _state$blockSelection.end; + return !!start.clientId && start.clientId === end.clientId; +} +/** + * Returns the currently selected block client ID, or null if there is no + * selected block. + * + * @param {Object} state Editor state. + * + * @return {?string} Selected block client ID. + */ + +function selectors_getSelectedBlockClientId(state) { + var _state$blockSelection2 = state.blockSelection, + start = _state$blockSelection2.start, + end = _state$blockSelection2.end; // We need to check the block exists because the current blockSelection + // reducer doesn't take into account when blocks are reset via undo. To be + // removed when that's fixed. + + return start.clientId && start.clientId === end.clientId && !!state.blocks.byClientId[start.clientId] ? start.clientId : null; +} +/** + * Returns the currently selected block, or null if there is no selected block. + * + * @param {Object} state Global application state. + * + * @return {?Object} Selected block. + */ + +function selectors_getSelectedBlock(state) { + var clientId = selectors_getSelectedBlockClientId(state); + return clientId ? selectors_getBlock(state, clientId) : null; +} +/** + * Given a block client ID, returns the root block from which the block is + * nested, an empty string for top-level blocks, or null if the block does not + * exist. + * + * @param {Object} state Editor state. + * @param {string} clientId Block from which to find root client ID. + * + * @return {?string} Root client ID, if exists + */ + +function selectors_getBlockRootClientId(state, clientId) { + return state.blocks.parents[clientId] !== undefined ? state.blocks.parents[clientId] : null; +} +/** + * Given a block client ID, returns the root of the hierarchy from which the block is nested, return the block itself for root level blocks. + * + * @param {Object} state Editor state. + * @param {string} clientId Block from which to find root client ID. + * + * @return {string} Root client ID + */ + +function getBlockHierarchyRootClientId(state, clientId) { + var current = clientId; + var parent; + + do { + parent = current; + current = state.blocks.parents[current]; + } while (current); + + return parent; +} +/** + * Returns the client ID of the block adjacent one at the given reference + * startClientId and modifier directionality. Defaults start startClientId to + * the selected block, and direction as next block. Returns null if there is no + * adjacent block. + * + * @param {Object} state Editor state. + * @param {?string} startClientId Optional client ID of block from which to + * search. + * @param {?number} modifier Directionality multiplier (1 next, -1 + * previous). + * + * @return {?string} Return the client ID of the block, or null if none exists. + */ + +function getAdjacentBlockClientId(state, startClientId) { + var modifier = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1; + + // Default to selected block. + if (startClientId === undefined) { + startClientId = selectors_getSelectedBlockClientId(state); + } // Try multi-selection starting at extent based on modifier. + + + if (startClientId === undefined) { + if (modifier < 0) { + startClientId = getFirstMultiSelectedBlockClientId(state); + } else { + startClientId = getLastMultiSelectedBlockClientId(state); + } + } // Validate working start client ID. + + + if (!startClientId) { + return null; + } // Retrieve start block root client ID, being careful to allow the falsey + // empty string top-level root by explicitly testing against null. + + + var rootClientId = selectors_getBlockRootClientId(state, startClientId); + + if (rootClientId === null) { + return null; + } + + var order = state.blocks.order; + var orderSet = order[rootClientId]; + var index = orderSet.indexOf(startClientId); + var nextIndex = index + 1 * modifier; // Block was first in set and we're attempting to get previous. + + if (nextIndex < 0) { + return null; + } // Block was last in set and we're attempting to get next. + + + if (nextIndex === orderSet.length) { + return null; + } // Assume incremented index is within the set. + + + return orderSet[nextIndex]; +} +/** + * Returns the previous block's client ID from the given reference start ID. + * Defaults start to the selected block. Returns null if there is no previous + * block. + * + * @param {Object} state Editor state. + * @param {?string} startClientId Optional client ID of block from which to + * search. + * + * @return {?string} Adjacent block's client ID, or null if none exists. + */ + +function getPreviousBlockClientId(state, startClientId) { + return getAdjacentBlockClientId(state, startClientId, -1); +} +/** + * Returns the next block's client ID from the given reference start ID. + * Defaults start to the selected block. Returns null if there is no next + * block. + * + * @param {Object} state Editor state. + * @param {?string} startClientId Optional client ID of block from which to + * search. + * + * @return {?string} Adjacent block's client ID, or null if none exists. + */ + +function getNextBlockClientId(state, startClientId) { + return getAdjacentBlockClientId(state, startClientId, 1); +} +/** + * Returns the initial caret position for the selected block. + * This position is to used to position the caret properly when the selected block changes. + * + * @param {Object} state Global application state. + * + * @return {?Object} Selected block. + */ + +function selectors_getSelectedBlocksInitialCaretPosition(state) { + var _state$blockSelection3 = state.blockSelection, + start = _state$blockSelection3.start, + end = _state$blockSelection3.end; + + if (start.clientId !== end.clientId || !start.clientId) { + return null; + } + + return state.blockSelection.initialPosition; +} +/** + * Returns the current selection set of block client IDs (multiselection or single selection). + * + * @param {Object} state Editor state. + * + * @return {Array} Multi-selected block client IDs. + */ + +var selectors_getSelectedBlockClientIds = Object(rememo["a" /* default */])(function (state) { + var _state$blockSelection4 = state.blockSelection, + start = _state$blockSelection4.start, + end = _state$blockSelection4.end; + + if (start.clientId === undefined || end.clientId === undefined) { + return EMPTY_ARRAY; + } + + if (start.clientId === end.clientId) { + return [start.clientId]; + } // Retrieve root client ID to aid in retrieving relevant nested block + // order, being careful to allow the falsey empty string top-level root + // by explicitly testing against null. + + + var rootClientId = selectors_getBlockRootClientId(state, start.clientId); + + if (rootClientId === null) { + return EMPTY_ARRAY; + } + + var blockOrder = selectors_getBlockOrder(state, rootClientId); + var startIndex = blockOrder.indexOf(start.clientId); + var endIndex = blockOrder.indexOf(end.clientId); + + if (startIndex > endIndex) { + return blockOrder.slice(endIndex, startIndex + 1); + } + + return blockOrder.slice(startIndex, endIndex + 1); +}, function (state) { + return [state.blocks.order, state.blockSelection.start.clientId, state.blockSelection.end.clientId]; +}); +/** + * Returns the current multi-selection set of block client IDs, or an empty + * array if there is no multi-selection. + * + * @param {Object} state Editor state. + * + * @return {Array} Multi-selected block client IDs. + */ + +function getMultiSelectedBlockClientIds(state) { + var _state$blockSelection5 = state.blockSelection, + start = _state$blockSelection5.start, + end = _state$blockSelection5.end; + + if (start.clientId === end.clientId) { + return EMPTY_ARRAY; + } + + return selectors_getSelectedBlockClientIds(state); +} +/** + * Returns the current multi-selection set of blocks, or an empty array if + * there is no multi-selection. + * + * @param {Object} state Editor state. + * + * @return {Array} Multi-selected block objects. + */ + +var getMultiSelectedBlocks = Object(rememo["a" /* default */])(function (state) { + var multiSelectedBlockClientIds = getMultiSelectedBlockClientIds(state); + + if (!multiSelectedBlockClientIds.length) { + return EMPTY_ARRAY; + } + + return multiSelectedBlockClientIds.map(function (clientId) { + return selectors_getBlock(state, clientId); + }); +}, function (state) { + return [].concat(Object(toConsumableArray["a" /* default */])(selectors_getSelectedBlockClientIds.getDependants(state)), [state.blocks.byClientId, state.blocks.order, state.blocks.attributes]); +}); +/** + * Returns the client ID of the first block in the multi-selection set, or null + * if there is no multi-selection. + * + * @param {Object} state Editor state. + * + * @return {?string} First block client ID in the multi-selection set. + */ + +function getFirstMultiSelectedBlockClientId(state) { + return Object(external_lodash_["first"])(getMultiSelectedBlockClientIds(state)) || null; +} +/** + * Returns the client ID of the last block in the multi-selection set, or null + * if there is no multi-selection. + * + * @param {Object} state Editor state. + * + * @return {?string} Last block client ID in the multi-selection set. + */ + +function getLastMultiSelectedBlockClientId(state) { + return Object(external_lodash_["last"])(getMultiSelectedBlockClientIds(state)) || null; +} +/** + * Returns true if a multi-selection exists, and the block corresponding to the + * specified client ID is the first block of the multi-selection set, or false + * otherwise. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {boolean} Whether block is first in multi-selection. + */ + +function selectors_isFirstMultiSelectedBlock(state, clientId) { + return getFirstMultiSelectedBlockClientId(state) === clientId; +} +/** + * Returns true if the client ID occurs within the block multi-selection, or + * false otherwise. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {boolean} Whether block is in multi-selection set. + */ + +function selectors_isBlockMultiSelected(state, clientId) { + return getMultiSelectedBlockClientIds(state).indexOf(clientId) !== -1; +} +/** + * Returns true if an ancestor of the block is multi-selected, or false + * otherwise. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {boolean} Whether an ancestor of the block is in multi-selection + * set. + */ + +var selectors_isAncestorMultiSelected = Object(rememo["a" /* default */])(function (state, clientId) { + var ancestorClientId = clientId; + var isMultiSelected = false; + + while (ancestorClientId && !isMultiSelected) { + ancestorClientId = selectors_getBlockRootClientId(state, ancestorClientId); + isMultiSelected = selectors_isBlockMultiSelected(state, ancestorClientId); + } + + return isMultiSelected; +}, function (state) { + return [state.blocks.order, state.blockSelection.start.clientId, state.blockSelection.end.clientId]; +}); +/** + * Returns the client ID of the block which begins the multi-selection set, or + * null if there is no multi-selection. + * + * This is not necessarily the first client ID in the selection. + * + * @see getFirstMultiSelectedBlockClientId + * + * @param {Object} state Editor state. + * + * @return {?string} Client ID of block beginning multi-selection. + */ + +function getMultiSelectedBlocksStartClientId(state) { + var _state$blockSelection6 = state.blockSelection, + start = _state$blockSelection6.start, + end = _state$blockSelection6.end; + + if (start.clientId === end.clientId) { + return null; + } + + return start.clientId || null; +} +/** + * Returns the client ID of the block which ends the multi-selection set, or + * null if there is no multi-selection. + * + * This is not necessarily the last client ID in the selection. + * + * @see getLastMultiSelectedBlockClientId + * + * @param {Object} state Editor state. + * + * @return {?string} Client ID of block ending multi-selection. + */ + +function getMultiSelectedBlocksEndClientId(state) { + var _state$blockSelection7 = state.blockSelection, + start = _state$blockSelection7.start, + end = _state$blockSelection7.end; + + if (start.clientId === end.clientId) { + return null; + } + + return end.clientId || null; +} +/** + * Returns an array containing all block client IDs in the editor in the order + * they appear. Optionally accepts a root client ID of the block list for which + * the order should be returned, defaulting to the top-level block order. + * + * @param {Object} state Editor state. + * @param {?string} rootClientId Optional root client ID of block list. + * + * @return {Array} Ordered client IDs of editor blocks. + */ + +function selectors_getBlockOrder(state, rootClientId) { + return state.blocks.order[rootClientId || ''] || EMPTY_ARRAY; +} +/** + * Returns the index at which the block corresponding to the specified client + * ID occurs within the block order, or `-1` if the block does not exist. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * @param {?string} rootClientId Optional root client ID of block list. + * + * @return {number} Index at which block exists in order. + */ + +function selectors_getBlockIndex(state, clientId, rootClientId) { + return selectors_getBlockOrder(state, rootClientId).indexOf(clientId); +} +/** + * Returns true if the block corresponding to the specified client ID is + * currently selected and no multi-selection exists, or false otherwise. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {boolean} Whether block is selected and multi-selection exists. + */ + +function selectors_isBlockSelected(state, clientId) { + var _state$blockSelection8 = state.blockSelection, + start = _state$blockSelection8.start, + end = _state$blockSelection8.end; + + if (start.clientId !== end.clientId) { + return false; + } + + return start.clientId === clientId; +} +/** + * Returns true if one of the block's inner blocks is selected. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * @param {boolean} deep Perform a deep check. + * + * @return {boolean} Whether the block as an inner block selected + */ + +function selectors_hasSelectedInnerBlock(state, clientId) { + var deep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; + return Object(external_lodash_["some"])(selectors_getBlockOrder(state, clientId), function (innerClientId) { + return selectors_isBlockSelected(state, innerClientId) || selectors_isBlockMultiSelected(state, innerClientId) || deep && selectors_hasSelectedInnerBlock(state, innerClientId, deep); + }); +} +/** + * Returns true if the block corresponding to the specified client ID is + * currently selected but isn't the last of the selected blocks. Here "last" + * refers to the block sequence in the document, _not_ the sequence of + * multi-selection, which is why `state.blockSelection.end` isn't used. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {boolean} Whether block is selected and not the last in the + * selection. + */ + +function isBlockWithinSelection(state, clientId) { + if (!clientId) { + return false; + } + + var clientIds = getMultiSelectedBlockClientIds(state); + var index = clientIds.indexOf(clientId); + return index > -1 && index < clientIds.length - 1; +} +/** + * Returns true if a multi-selection has been made, or false otherwise. + * + * @param {Object} state Editor state. + * + * @return {boolean} Whether multi-selection has been made. + */ + +function selectors_hasMultiSelection(state) { + var _state$blockSelection9 = state.blockSelection, + start = _state$blockSelection9.start, + end = _state$blockSelection9.end; + return start.clientId !== end.clientId; +} +/** + * Whether in the process of multi-selecting or not. This flag is only true + * while the multi-selection is being selected (by mouse move), and is false + * once the multi-selection has been settled. + * + * @see hasMultiSelection + * + * @param {Object} state Global application state. + * + * @return {boolean} True if multi-selecting, false if not. + */ + +function isMultiSelecting(state) { + return state.blockSelection.isMultiSelecting; +} +/** + * Selector that returns if multi-selection is enabled or not. + * + * @param {Object} state Global application state. + * + * @return {boolean} True if it should be possible to multi-select blocks, false if multi-selection is disabled. + */ + +function selectors_isSelectionEnabled(state) { + return state.blockSelection.isEnabled; +} +/** + * Returns the block's editing mode, defaulting to "visual" if not explicitly + * assigned. + * + * @param {Object} state Editor state. + * @param {string} clientId Block client ID. + * + * @return {Object} Block editing mode. + */ + +function selectors_getBlockMode(state, clientId) { + return state.blocksMode[clientId] || 'visual'; +} +/** + * Returns true if the user is typing, or false otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether user is typing. + */ + +function selectors_isTyping(state) { + return state.isTyping; +} +/** + * Returns true if the caret is within formatted text, or false otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the caret is within formatted text. + */ + +function selectors_isCaretWithinFormattedText(state) { + return state.isCaretWithinFormattedText; +} +/** + * Returns the insertion point, the index at which the new inserted block would + * be placed. Defaults to the last index. + * + * @param {Object} state Editor state. + * + * @return {Object} Insertion point object with `rootClientId`, `index`. + */ + +function getBlockInsertionPoint(state) { + var rootClientId, index; + var insertionPoint = state.insertionPoint, + blockSelection = state.blockSelection; + + if (insertionPoint !== null) { + return insertionPoint; + } + + var end = blockSelection.end; + + if (end.clientId) { + rootClientId = selectors_getBlockRootClientId(state, end.clientId) || undefined; + index = selectors_getBlockIndex(state, end.clientId, rootClientId) + 1; + } else { + index = selectors_getBlockOrder(state).length; + } + + return { + rootClientId: rootClientId, + index: index + }; +} +/** + * Returns true if we should show the block insertion point. + * + * @param {Object} state Global application state. + * + * @return {?boolean} Whether the insertion point is visible or not. + */ + +function isBlockInsertionPointVisible(state) { + return state.insertionPoint !== null; +} +/** + * Returns whether the blocks matches the template or not. + * + * @param {boolean} state + * @return {?boolean} Whether the template is valid or not. + */ + +function isValidTemplate(state) { + return state.template.isValid; +} +/** + * Returns the defined block template + * + * @param {boolean} state + * @return {?Array} Block Template + */ + +function getTemplate(state) { + return state.settings.template; +} +/** + * Returns the defined block template lock. Optionally accepts a root block + * client ID as context, otherwise defaulting to the global context. + * + * @param {Object} state Editor state. + * @param {?string} rootClientId Optional block root client ID. + * + * @return {?string} Block Template Lock + */ + +function selectors_getTemplateLock(state, rootClientId) { + if (!rootClientId) { + return state.settings.templateLock; + } + + var blockListSettings = getBlockListSettings(state, rootClientId); + + if (!blockListSettings) { + return null; + } + + return blockListSettings.templateLock; +} +/** + * Determines if the given block type is allowed to be inserted into the block list. + * This function is not exported and not memoized because using a memoized selector + * inside another memoized selector is just a waste of time. + * + * @param {Object} state Editor state. + * @param {string} blockName The name of the block type, e.g.' core/paragraph'. + * @param {?string} rootClientId Optional root client ID of block list. + * + * @return {boolean} Whether the given block type is allowed to be inserted. + */ + +var selectors_canInsertBlockTypeUnmemoized = function canInsertBlockTypeUnmemoized(state, blockName) { + var rootClientId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; + + var checkAllowList = function checkAllowList(list, item) { + var defaultResult = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null; + + if (Object(external_lodash_["isBoolean"])(list)) { + return list; + } + + if (Object(external_lodash_["isArray"])(list)) { + return Object(external_lodash_["includes"])(list, item); + } + + return defaultResult; + }; + + var blockType = Object(external_this_wp_blocks_["getBlockType"])(blockName); + + if (!blockType) { + return false; + } + + var _getSettings = selectors_getSettings(state), + allowedBlockTypes = _getSettings.allowedBlockTypes; + + var isBlockAllowedInEditor = checkAllowList(allowedBlockTypes, blockName, true); + + if (!isBlockAllowedInEditor) { + return false; + } + + var isLocked = !!selectors_getTemplateLock(state, rootClientId); + + if (isLocked) { + return false; + } + + var parentBlockListSettings = getBlockListSettings(state, rootClientId); + var parentAllowedBlocks = Object(external_lodash_["get"])(parentBlockListSettings, ['allowedBlocks']); + var hasParentAllowedBlock = checkAllowList(parentAllowedBlocks, blockName); + var blockAllowedParentBlocks = blockType.parent; + var parentName = selectors_getBlockName(state, rootClientId); + var hasBlockAllowedParent = checkAllowList(blockAllowedParentBlocks, parentName); + + if (hasParentAllowedBlock !== null && hasBlockAllowedParent !== null) { + return hasParentAllowedBlock || hasBlockAllowedParent; + } else if (hasParentAllowedBlock !== null) { + return hasParentAllowedBlock; + } else if (hasBlockAllowedParent !== null) { + return hasBlockAllowedParent; + } + + return true; +}; +/** + * Determines if the given block type is allowed to be inserted into the block list. + * + * @param {Object} state Editor state. + * @param {string} blockName The name of the block type, e.g.' core/paragraph'. + * @param {?string} rootClientId Optional root client ID of block list. + * + * @return {boolean} Whether the given block type is allowed to be inserted. + */ + + +var selectors_canInsertBlockType = Object(rememo["a" /* default */])(selectors_canInsertBlockTypeUnmemoized, function (state, blockName, rootClientId) { + return [state.blockListSettings[rootClientId], state.blocks.byClientId[rootClientId], state.settings.allowedBlockTypes, state.settings.templateLock]; +}); +/** + * Returns information about how recently and frequently a block has been inserted. + * + * @param {Object} state Global application state. + * @param {string} id A string which identifies the insert, e.g. 'core/block/12' + * + * @return {?{ time: number, count: number }} An object containing `time` which is when the last + * insert occurred as a UNIX epoch, and `count` which is + * the number of inserts that have occurred. + */ + +function getInsertUsage(state, id) { + return Object(external_lodash_["get"])(state.preferences.insertUsage, [id], null); +} +/** + * Returns whether we can show a block type in the inserter + * + * @param {Object} state Global State + * @param {Object} blockType BlockType + * @param {?string} rootClientId Optional root client ID of block list. + * + * @return {boolean} Whether the given block type is allowed to be shown in the inserter. + */ + + +var selectors_canIncludeBlockTypeInInserter = function canIncludeBlockTypeInInserter(state, blockType, rootClientId) { + if (!Object(external_this_wp_blocks_["hasBlockSupport"])(blockType, 'inserter', true)) { + return false; + } + + return selectors_canInsertBlockTypeUnmemoized(state, blockType.name, rootClientId); +}; +/** + * Determines the items that appear in the inserter. Includes both static + * items (e.g. a regular block type) and dynamic items (e.g. a reusable block). + * + * Each item object contains what's necessary to display a button in the + * inserter and handle its selection. + * + * The 'utility' property indicates how useful we think an item will be to the + * user. There are 4 levels of utility: + * + * 1. Blocks that are contextually useful (utility = 3) + * 2. Blocks that have been previously inserted (utility = 2) + * 3. Blocks that are in the common category (utility = 1) + * 4. All other blocks (utility = 0) + * + * The 'frecency' property is a heuristic (https://en.wikipedia.org/wiki/Frecency) + * that combines block usage frequenty and recency. + * + * Items are returned ordered descendingly by their 'utility' and 'frecency'. + * + * @param {Object} state Editor state. + * @param {?string} rootClientId Optional root client ID of block list. + * + * @return {Editor.InserterItem[]} Items that appear in inserter. + * + * @typedef {Object} Editor.InserterItem + * @property {string} id Unique identifier for the item. + * @property {string} name The type of block to create. + * @property {Object} initialAttributes Attributes to pass to the newly created block. + * @property {string} title Title of the item, as it appears in the inserter. + * @property {string} icon Dashicon for the item, as it appears in the inserter. + * @property {string} category Block category that the item is associated with. + * @property {string[]} keywords Keywords that can be searched to find this item. + * @property {boolean} isDisabled Whether or not the user should be prevented from inserting + * this item. + * @property {number} utility How useful we think this item is, between 0 and 3. + * @property {number} frecency Hueristic that combines frequency and recency. + */ + + +var selectors_getInserterItems = Object(rememo["a" /* default */])(function (state) { + var rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + var calculateUtility = function calculateUtility(category, count, isContextual) { + if (isContextual) { + return INSERTER_UTILITY_HIGH; + } else if (count > 0) { + return INSERTER_UTILITY_MEDIUM; + } else if (category === 'common') { + return INSERTER_UTILITY_LOW; + } + + return INSERTER_UTILITY_NONE; + }; + + var calculateFrecency = function calculateFrecency(time, count) { + if (!time) { + return count; + } // The selector is cached, which means Date.now() is the last time that the + // relevant state changed. This suits our needs. + + + var duration = Date.now() - time; + + switch (true) { + case duration < MILLISECONDS_PER_HOUR: + return count * 4; + + case duration < MILLISECONDS_PER_DAY: + return count * 2; + + case duration < MILLISECONDS_PER_WEEK: + return count / 2; + + default: + return count / 4; + } + }; + + var buildBlockTypeInserterItem = function buildBlockTypeInserterItem(blockType) { + var id = blockType.name; + var isDisabled = false; + + if (!Object(external_this_wp_blocks_["hasBlockSupport"])(blockType.name, 'multiple', true)) { + isDisabled = Object(external_lodash_["some"])(selectors_getBlocksByClientId(state, getClientIdsWithDescendants(state)), { + name: blockType.name + }); + } + + var isContextual = Object(external_lodash_["isArray"])(blockType.parent); + + var _ref = getInsertUsage(state, id) || {}, + time = _ref.time, + _ref$count = _ref.count, + count = _ref$count === void 0 ? 0 : _ref$count; + + return { + id: id, + name: blockType.name, + initialAttributes: {}, + title: blockType.title, + icon: blockType.icon, + category: blockType.category, + keywords: blockType.keywords, + isDisabled: isDisabled, + utility: calculateUtility(blockType.category, count, isContextual), + frecency: calculateFrecency(time, count) + }; + }; + + var buildReusableBlockInserterItem = function buildReusableBlockInserterItem(reusableBlock) { + var id = "core/block/".concat(reusableBlock.id); + + var referencedBlocks = __experimentalGetParsedReusableBlock(state, reusableBlock.id); + + var referencedBlockType; + + if (referencedBlocks.length === 1) { + referencedBlockType = Object(external_this_wp_blocks_["getBlockType"])(referencedBlocks[0].name); + } + + var _ref2 = getInsertUsage(state, id) || {}, + time = _ref2.time, + _ref2$count = _ref2.count, + count = _ref2$count === void 0 ? 0 : _ref2$count; + + var utility = calculateUtility('reusable', count, false); + var frecency = calculateFrecency(time, count); + return { + id: id, + name: 'core/block', + initialAttributes: { + ref: reusableBlock.id + }, + title: reusableBlock.title, + icon: referencedBlockType ? referencedBlockType.icon : templateIcon, + category: 'reusable', + keywords: [], + isDisabled: false, + utility: utility, + frecency: frecency + }; + }; + + var blockTypeInserterItems = Object(external_this_wp_blocks_["getBlockTypes"])().filter(function (blockType) { + return selectors_canIncludeBlockTypeInInserter(state, blockType, rootClientId); + }).map(buildBlockTypeInserterItem); + var reusableBlockInserterItems = selectors_canInsertBlockTypeUnmemoized(state, 'core/block', rootClientId) ? getReusableBlocks(state).map(buildReusableBlockInserterItem) : []; + return Object(external_lodash_["orderBy"])([].concat(Object(toConsumableArray["a" /* default */])(blockTypeInserterItems), Object(toConsumableArray["a" /* default */])(reusableBlockInserterItems)), ['utility', 'frecency'], ['desc', 'desc']); +}, function (state, rootClientId) { + return [state.blockListSettings[rootClientId], state.blocks.byClientId, state.blocks.order, state.preferences.insertUsage, state.settings.allowedBlockTypes, state.settings.templateLock, getReusableBlocks(state), Object(external_this_wp_blocks_["getBlockTypes"])()]; +}); +/** + * Determines whether there are items to show in the inserter. + * + * @param {Object} state Editor state. + * @param {?string} rootClientId Optional root client ID of block list. + * + * @return {boolean} Items that appear in inserter. + */ + +var hasInserterItems = Object(rememo["a" /* default */])(function (state) { + var rootClientId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + var hasBlockType = Object(external_lodash_["some"])(Object(external_this_wp_blocks_["getBlockTypes"])(), function (blockType) { + return selectors_canIncludeBlockTypeInInserter(state, blockType, rootClientId); + }); + + if (hasBlockType) { + return true; + } + + var hasReusableBlock = selectors_canInsertBlockTypeUnmemoized(state, 'core/block', rootClientId) && getReusableBlocks(state).length > 0; + return hasReusableBlock; +}, function (state, rootClientId) { + return [state.blockListSettings[rootClientId], state.blocks.byClientId, state.settings.allowedBlockTypes, state.settings.templateLock, getReusableBlocks(state), Object(external_this_wp_blocks_["getBlockTypes"])()]; +}); +/** + * Returns the Block List settings of a block, if any exist. + * + * @param {Object} state Editor state. + * @param {?string} clientId Block client ID. + * + * @return {?Object} Block settings of the block if set. + */ + +function getBlockListSettings(state, clientId) { + return state.blockListSettings[clientId]; +} +/** + * Returns the editor settings. + * + * @param {Object} state Editor state. + * + * @return {Object} The editor settings object. + */ + +function selectors_getSettings(state) { + return state.settings; +} +/** + * Returns true if the most recent block change is be considered persistent, or + * false otherwise. A persistent change is one committed by BlockEditorProvider + * via its `onChange` callback, in addition to `onInput`. + * + * @param {Object} state Block editor state. + * + * @return {boolean} Whether the most recent block change was persistent. + */ + +function selectors_isLastBlockChangePersistent(state) { + return state.blocks.isPersistentChange; +} +/** + * Returns the parsed block saved as shared block with the given ID. + * + * @param {Object} state Global application state. + * @param {number|string} ref The shared block's ID. + * + * @return {Object} The parsed block. + */ + +var __experimentalGetParsedReusableBlock = Object(rememo["a" /* default */])(function (state, ref) { + var reusableBlock = Object(external_lodash_["find"])(getReusableBlocks(state), function (block) { + return block.id === ref; + }); + + if (!reusableBlock) { + return null; + } + + return Object(external_this_wp_blocks_["parse"])(reusableBlock.content); +}, function (state) { + return [getReusableBlocks(state)]; +}); +/** + * Returns true if the most recent block change is be considered ignored, or + * false otherwise. An ignored change is one not to be committed by + * BlockEditorProvider, neither via `onChange` nor `onInput`. + * + * @param {Object} state Block editor state. + * + * @return {boolean} Whether the most recent block change was ignored. + */ + +function selectors_unstableIsLastBlockChangeIgnored(state) { + // TODO: Removal Plan: Changes incurred by RECEIVE_BLOCKS should not be + // ignored if in-fact they result in a change in blocks state. The current + // need to ignore changes not a result of user interaction should be + // accounted for in the refactoring of reusable blocks as occurring within + // their own separate block editor / state (#7119). + return state.blocks.isIgnoredChange; +} +/** + * Returns the block attributes changed as a result of the last dispatched + * action. + * + * @param {Object} state Block editor state. + * + * @return {Object<string,Object>} Subsets of block attributes changed, keyed + * by block client ID. + */ + +function __experimentalGetLastBlockAttributeChanges(state) { + return state.lastBlockAttributesChange; +} +/** + * Returns the available reusable blocks + * + * @param {Object} state Global application state. + * + * @return {Array} Reusable blocks + */ + +function getReusableBlocks(state) { + return Object(external_lodash_["get"])(state, ['settings', '__experimentalReusableBlocks'], EMPTY_ARRAY); +} +/** + * Returns whether the navigation mode is enabled. + * + * @param {Object} state Editor state. + * + * @return {boolean} Is navigation mode enabled. + */ + + +function selectors_isNavigationMode(state) { + return state.isNavigationMode; +} +/** + * Returns true if the last change was an automatic change, false otherwise. + * + * @param {Object} state Global application state. + * + * @return {boolean} Whether the last change was automatic. + */ + +function selectors_didAutomaticChange(state) { + return state.didAutomaticChange; +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/store/effects.js + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + + +/** + * Block validity is a function of blocks state (at the point of a + * reset) and the template setting. As a compromise to its placement + * across distinct parts of state, it is implemented here as a side- + * effect of the block reset action. + * + * @param {Object} action RESET_BLOCKS action. + * @param {Object} store Store instance. + * + * @return {?Object} New validity set action if validity has changed. + */ + +function validateBlocksToTemplate(action, store) { + var state = store.getState(); + var template = getTemplate(state); + var templateLock = selectors_getTemplateLock(state); // Unlocked templates are considered always valid because they act + // as default values only. + + var isBlocksValidToTemplate = !template || templateLock !== 'all' || Object(external_this_wp_blocks_["doBlocksMatchTemplate"])(action.blocks, template); // Update if validity has changed. + + if (isBlocksValidToTemplate !== isValidTemplate(state)) { + return setTemplateValidity(isBlocksValidToTemplate); + } +} +/* harmony default export */ var effects = ({ + MERGE_BLOCKS: function MERGE_BLOCKS(action, store) { + var dispatch = store.dispatch; + var state = store.getState(); + + var _action$blocks = Object(slicedToArray["a" /* default */])(action.blocks, 2), + clientIdA = _action$blocks[0], + clientIdB = _action$blocks[1]; + + var blockA = selectors_getBlock(state, clientIdA); + var blockAType = Object(external_this_wp_blocks_["getBlockType"])(blockA.name); // Only focus the previous block if it's not mergeable + + if (!blockAType.merge) { + dispatch(actions_selectBlock(blockA.clientId)); + return; + } + + var blockB = selectors_getBlock(state, clientIdB); + var blockBType = Object(external_this_wp_blocks_["getBlockType"])(blockB.name); + + var _getSelectionStart = getSelectionStart(state), + clientId = _getSelectionStart.clientId, + attributeKey = _getSelectionStart.attributeKey, + offset = _getSelectionStart.offset; + + var hasTextSelection = (clientId === clientIdA || clientId === clientIdB) && attributeKey !== undefined && offset !== undefined; // A robust way to retain selection position through various transforms + // is to insert a special character at the position and then recover it. + + var START_OF_SELECTED_AREA = "\x86"; // Clone the blocks so we don't insert the character in a "live" block. + + var cloneA = Object(external_this_wp_blocks_["cloneBlock"])(blockA); + var cloneB = Object(external_this_wp_blocks_["cloneBlock"])(blockB); + + if (hasTextSelection) { + var selectedBlock = clientId === clientIdA ? cloneA : cloneB; + var html = selectedBlock.attributes[attributeKey]; + var selectedBlockType = clientId === clientIdA ? blockAType : blockBType; + var _selectedBlockType$at = selectedBlockType.attributes[attributeKey], + multilineTag = _selectedBlockType$at.multiline, + multilineWrapperTags = _selectedBlockType$at.__unstableMultilineWrapperTags; + var value = Object(external_this_wp_richText_["insert"])(Object(external_this_wp_richText_["create"])({ + html: html, + multilineTag: multilineTag, + multilineWrapperTags: multilineWrapperTags + }), START_OF_SELECTED_AREA, offset, offset); + selectedBlock.attributes[attributeKey] = Object(external_this_wp_richText_["toHTMLString"])({ + value: value, + multilineTag: multilineTag + }); + } // We can only merge blocks with similar types + // thus, we transform the block to merge first + + + var blocksWithTheSameType = blockA.name === blockB.name ? [cloneB] : Object(external_this_wp_blocks_["switchToBlockType"])(cloneB, blockA.name); // If the block types can not match, do nothing + + if (!blocksWithTheSameType || !blocksWithTheSameType.length) { + return; + } // Calling the merge to update the attributes and remove the block to be merged + + + var updatedAttributes = blockAType.merge(cloneA.attributes, blocksWithTheSameType[0].attributes); + + if (hasTextSelection) { + var newAttributeKey = Object(external_lodash_["findKey"])(updatedAttributes, function (v) { + return typeof v === 'string' && v.indexOf(START_OF_SELECTED_AREA) !== -1; + }); + var convertedHtml = updatedAttributes[newAttributeKey]; + var _blockAType$attribute = blockAType.attributes[newAttributeKey], + _multilineTag = _blockAType$attribute.multiline, + _multilineWrapperTags = _blockAType$attribute.__unstableMultilineWrapperTags; + var convertedValue = Object(external_this_wp_richText_["create"])({ + html: convertedHtml, + multilineTag: _multilineTag, + multilineWrapperTags: _multilineWrapperTags + }); + var newOffset = convertedValue.text.indexOf(START_OF_SELECTED_AREA); + var newValue = Object(external_this_wp_richText_["remove"])(convertedValue, newOffset, newOffset + 1); + var newHtml = Object(external_this_wp_richText_["toHTMLString"])({ + value: newValue, + multilineTag: _multilineTag + }); + updatedAttributes[newAttributeKey] = newHtml; + dispatch(selectionChange(blockA.clientId, newAttributeKey, newOffset, newOffset)); + } + + dispatch(actions_replaceBlocks([blockA.clientId, blockB.clientId], [Object(objectSpread["a" /* default */])({}, blockA, { + attributes: Object(objectSpread["a" /* default */])({}, blockA.attributes, updatedAttributes) + })].concat(Object(toConsumableArray["a" /* default */])(blocksWithTheSameType.slice(1))))); + }, + RESET_BLOCKS: [validateBlocksToTemplate], + MULTI_SELECT: function MULTI_SELECT(action, _ref) { + var getState = _ref.getState; + var blockCount = selectors_getSelectedBlockCount(getState()); + /* translators: %s: number of selected blocks */ + + Object(external_this_wp_a11y_["speak"])(Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('%s block selected.', '%s blocks selected.', blockCount), blockCount), 'assertive'); + }, + SYNCHRONIZE_TEMPLATE: function SYNCHRONIZE_TEMPLATE(action, _ref2) { + var getState = _ref2.getState; + var state = getState(); + var blocks = selectors_getBlocks(state); + var template = getTemplate(state); + var updatedBlockList = Object(external_this_wp_blocks_["synchronizeBlocksWithTemplate"])(blocks, template); + return resetBlocks(updatedBlockList); + } +}); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-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), redux_multi_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/block-editor/build-module/store/index.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + + + + +/** + * Module Constants + */ + +var MODULE_KEY = 'core/block-editor'; +/** + * Block editor data store configuration. + * + * @see https://github.com/WordPress/gutenberg/blob/master/packages/data/README.md#registerStore + * + * @type {Object} + */ + +var storeConfig = { + reducer: store_reducer, + selectors: selectors_namespaceObject, + actions: actions_namespaceObject, + controls: store_controls +}; +var store_store = Object(external_this_wp_data_["registerStore"])(MODULE_KEY, Object(objectSpread["a" /* default */])({}, storeConfig, { + persist: ['preferences'] +})); +store_middlewares(store_store); +/* harmony default export */ var build_module_store = (store_store); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/provider/with-registry-provider.js + + + + + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + +var withRegistryProvider = Object(external_this_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { + return Object(external_this_wp_data_["withRegistry"])(function (_ref) { + var _ref$useSubRegistry = _ref.useSubRegistry, + useSubRegistry = _ref$useSubRegistry === void 0 ? true : _ref$useSubRegistry, + registry = _ref.registry, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["useSubRegistry", "registry"]); + + if (!useSubRegistry) { + return Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({ + registry: registry + }, props)); + } + + var _useState = Object(external_this_wp_element_["useState"])(null), + _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), + subRegistry = _useState2[0], + setSubRegistry = _useState2[1]; + + Object(external_this_wp_element_["useEffect"])(function () { + var newRegistry = Object(external_this_wp_data_["createRegistry"])({}, registry); + var store = newRegistry.registerStore('core/block-editor', storeConfig); // This should be removed after the refactoring of the effects to controls. + + store_middlewares(store); + setSubRegistry(newRegistry); + }, [registry]); + + if (!subRegistry) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_data_["RegistryProvider"], { + value: subRegistry + }, Object(external_this_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({ + registry: subRegistry + }, props))); + }); +}, 'withRegistryProvider'); +/* harmony default export */ var with_registry_provider = (withRegistryProvider); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/provider/index.js + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + + +var provider_BlockEditorProvider = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockEditorProvider, _Component); + + function BlockEditorProvider() { + Object(classCallCheck["a" /* default */])(this, BlockEditorProvider); + + return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockEditorProvider).apply(this, arguments)); + } + + Object(createClass["a" /* default */])(BlockEditorProvider, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.props.updateSettings(this.props.settings); + this.props.resetBlocks(this.props.value); + this.attachChangeObserver(this.props.registry); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var _this$props = this.props, + settings = _this$props.settings, + updateSettings = _this$props.updateSettings, + value = _this$props.value, + resetBlocks = _this$props.resetBlocks, + registry = _this$props.registry; + + if (settings !== prevProps.settings) { + updateSettings(settings); + } + + if (registry !== prevProps.registry) { + this.attachChangeObserver(registry); + } + + if (this.isSyncingOutcomingValue !== null && this.isSyncingOutcomingValue === value) { + // Skip block reset if the value matches expected outbound sync + // triggered by this component by a preceding change detection. + // Only skip if the value matches expectation, since a reset should + // still occur if the value is modified (not equal by reference), + // to allow that the consumer may apply modifications to reflect + // back on the editor. + this.isSyncingOutcomingValue = null; + } else if (value !== prevProps.value) { + // Reset changing value in all other cases than the sync described + // above. Since this can be reached in an update following an out- + // bound sync, unset the outbound value to avoid considering it in + // subsequent renders. + this.isSyncingOutcomingValue = null; + this.isSyncingIncomingValue = value; + resetBlocks(value); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + if (this.unsubscribe) { + this.unsubscribe(); + } + } + /** + * Given a registry object, overrides the default dispatch behavior for the + * `core/block-editor` store to interpret a state change and decide whether + * we should call `onChange` or `onInput` depending on whether the change + * is persistent or not. + * + * This needs to be done synchronously after state changes (instead of using + * `componentDidUpdate`) in order to avoid batching these changes. + * + * @param {WPDataRegistry} registry Registry from which block editor + * dispatch is to be overriden. + */ + + }, { + key: "attachChangeObserver", + value: function attachChangeObserver(registry) { + var _this = this; + + if (this.unsubscribe) { + this.unsubscribe(); + } + + var _registry$select = registry.select('core/block-editor'), + getBlocks = _registry$select.getBlocks, + isLastBlockChangePersistent = _registry$select.isLastBlockChangePersistent, + __unstableIsLastBlockChangeIgnored = _registry$select.__unstableIsLastBlockChangeIgnored; + + var blocks = getBlocks(); + var isPersistent = isLastBlockChangePersistent(); + this.unsubscribe = registry.subscribe(function () { + var _this$props2 = _this.props, + _this$props2$onChange = _this$props2.onChange, + onChange = _this$props2$onChange === void 0 ? external_lodash_["noop"] : _this$props2$onChange, + _this$props2$onInput = _this$props2.onInput, + onInput = _this$props2$onInput === void 0 ? external_lodash_["noop"] : _this$props2$onInput; + var newBlocks = getBlocks(); + var newIsPersistent = isLastBlockChangePersistent(); + + if (newBlocks !== blocks && (_this.isSyncingIncomingValue || __unstableIsLastBlockChangeIgnored())) { + _this.isSyncingIncomingValue = null; + blocks = newBlocks; + isPersistent = newIsPersistent; + return; + } + + if (newBlocks !== blocks || // This happens when a previous input is explicitely marked as persistent. + newIsPersistent && !isPersistent) { + // When knowing the blocks value is changing, assign instance + // value to skip reset in subsequent `componentDidUpdate`. + if (newBlocks !== blocks) { + _this.isSyncingOutcomingValue = newBlocks; + } + + blocks = newBlocks; + isPersistent = newIsPersistent; + + if (isPersistent) { + onChange(blocks); + } else { + onInput(blocks); + } + } + }); + } + }, { + key: "render", + value: function render() { + var children = this.props.children; + return children; + } + }]); + + return BlockEditorProvider; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var provider = (Object(external_this_wp_compose_["compose"])([with_registry_provider, Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/block-editor'), + updateSettings = _dispatch.updateSettings, + resetBlocks = _dispatch.resetBlocks; + + return { + updateSettings: updateSettings, + resetBlocks: resetBlocks + }; +})])(provider_BlockEditorProvider)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-async-mode-provider.js + + +/** + * WordPress dependencies + */ + + +var block_async_mode_provider_BlockAsyncModeProvider = function BlockAsyncModeProvider(_ref) { + var children = _ref.children, + clientId = _ref.clientId, + isBlockInSelection = _ref.isBlockInSelection; + var isParentOfSelectedBlock = Object(external_this_wp_data_["useSelect"])(function (select) { + return select('core/block-editor').hasSelectedInnerBlock(clientId, true); + }); + var isSyncModeForced = isBlockInSelection || isParentOfSelectedBlock; + return Object(external_this_wp_element_["createElement"])(external_this_wp_data_["__experimentalAsyncModeProvider"], { + value: !isSyncModeForced + }, children); +}; + +/* harmony default export */ var block_async_mode_provider = (block_async_mode_provider_BlockAsyncModeProvider); + +// EXTERNAL MODULE: ./node_modules/react-spring/web.cjs.js +var web_cjs = __webpack_require__(64); + +// EXTERNAL MODULE: external {"this":["wp","dom"]} +var external_this_wp_dom_ = __webpack_require__(25); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-mover/mover-description.js +/** + * WordPress dependencies + */ + +/** + * Return a label for the block movement controls depending on block position. + * + * @param {number} selectedCount Number of blocks selected. + * @param {string} type Block type - in the case of a single block, should + * define its 'type'. I.e. 'Text', 'Heading', 'Image' etc. + * @param {number} firstIndex The index (position - 1) of the first block selected. + * @param {boolean} isFirst This is the first block. + * @param {boolean} isLast This is the last block. + * @param {number} dir Direction of movement (> 0 is considered to be going + * down, < 0 is up). + * + * @return {string} Label for the block movement controls. + */ + +function getBlockMoverDescription(selectedCount, type, firstIndex, isFirst, isLast, dir) { + var position = firstIndex + 1; + + if (selectedCount > 1) { + return getMultiBlockMoverDescription(selectedCount, firstIndex, isFirst, isLast, dir); + } + + if (isFirst && isLast) { + // translators: %s: Type of block (i.e. Text, Image etc) + return Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["__"])('Block %s is the only block, and cannot be moved'), type); + } + + if (dir > 0 && !isLast) { + // moving down + return Object(external_this_wp_i18n_["sprintf"])( // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position + Object(external_this_wp_i18n_["__"])('Move %1$s block from position %2$d down to position %3$d'), type, position, position + 1); + } + + if (dir > 0 && isLast) { + // moving down, and is the last item + // translators: %s: Type of block (i.e. Text, Image etc) + return Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["__"])('Block %s is at the end of the content and can’t be moved down'), type); + } + + if (dir < 0 && !isFirst) { + // moving up + return Object(external_this_wp_i18n_["sprintf"])( // translators: 1: Type of block (i.e. Text, Image etc), 2: Position of selected block, 3: New position + Object(external_this_wp_i18n_["__"])('Move %1$s block from position %2$d up to position %3$d'), type, position, position - 1); + } + + if (dir < 0 && isFirst) { + // moving up, and is the first item + // translators: %s: Type of block (i.e. Text, Image etc) + return Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["__"])('Block %s is at the beginning of the content and can’t be moved up'), type); + } +} +/** + * Return a label for the block movement controls depending on block position. + * + * @param {number} selectedCount Number of blocks selected. + * @param {number} firstIndex The index (position - 1) of the first block selected. + * @param {boolean} isFirst This is the first block. + * @param {boolean} isLast This is the last block. + * @param {number} dir Direction of movement (> 0 is considered to be going + * down, < 0 is up). + * + * @return {string} Label for the block movement controls. + */ + +function getMultiBlockMoverDescription(selectedCount, firstIndex, isFirst, isLast, dir) { + var position = firstIndex + 1; + + if (dir < 0 && isFirst) { + return Object(external_this_wp_i18n_["__"])('Blocks cannot be moved up as they are already at the top'); + } + + if (dir > 0 && isLast) { + return Object(external_this_wp_i18n_["__"])('Blocks cannot be moved down as they are already at the bottom'); + } + + if (dir < 0 && !isFirst) { + return Object(external_this_wp_i18n_["sprintf"])( // translators: 1: Number of selected blocks, 2: Position of selected blocks + Object(external_this_wp_i18n_["_n"])('Move %1$d block from position %2$d up by one place', 'Move %1$d blocks from position %2$d up by one place', selectedCount), selectedCount, position); + } + + if (dir > 0 && !isLast) { + return Object(external_this_wp_i18n_["sprintf"])( // translators: 1: Number of selected blocks, 2: Position of selected blocks + Object(external_this_wp_i18n_["_n"])('Move %1$d block from position %2$d down by one place', 'Move %1$d blocks from position %2$d down by one place', selectedCount), selectedCount, position); + } +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-mover/icons.js + + +/** + * WordPress dependencies + */ + +var upArrow = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + width: "18", + height: "18", + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 18 18" +}, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Polygon"], { + points: "9,4.5 3.3,10.1 4.8,11.5 9,7.3 13.2,11.5 14.7,10.1 " +})); +var downArrow = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + width: "18", + height: "18", + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 18 18" +}, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Polygon"], { + points: "9,13.5 14.7,7.9 13.2,6.5 9,10.7 4.8,6.5 3.3,7.9 " +})); +var dragHandle = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + width: "18", + height: "18", + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 18 18" +}, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + d: "M13,8c0.6,0,1-0.4,1-1s-0.4-1-1-1s-1,0.4-1,1S12.4,8,13,8z M5,6C4.4,6,4,6.4,4,7s0.4,1,1,1s1-0.4,1-1S5.6,6,5,6z M5,10 c-0.6,0-1,0.4-1,1s0.4,1,1,1s1-0.4,1-1S5.6,10,5,10z M13,10c-0.6,0-1,0.4-1,1s0.4,1,1,1s1-0.4,1-1S13.6,10,13,10z M9,6 C8.4,6,8,6.4,8,7s0.4,1,1,1s1-0.4,1-1S9.6,6,9,6z M9,10c-0.6,0-1,0.4-1,1s0.4,1,1,1s1-0.4,1-1S9.6,10,9,10z" +})); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-draggable/index.js + + +/** + * WordPress dependencies + */ + + + +var block_draggable_BlockDraggable = function BlockDraggable(_ref) { + var children = _ref.children, + clientId = _ref.clientId, + rootClientId = _ref.rootClientId, + blockElementId = _ref.blockElementId, + index = _ref.index, + onDragStart = _ref.onDragStart, + onDragEnd = _ref.onDragEnd; + var transferData = { + type: 'block', + srcIndex: index, + srcRootClientId: rootClientId, + srcClientId: clientId + }; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Draggable"], { + elementId: blockElementId, + transferData: transferData, + onDragStart: onDragStart, + onDragEnd: onDragEnd + }, function (_ref2) { + var onDraggableStart = _ref2.onDraggableStart, + onDraggableEnd = _ref2.onDraggableEnd; + return children({ + onDraggableStart: onDraggableStart, + onDraggableEnd: onDraggableEnd + }); + }); +}; + +/* harmony default export */ var block_draggable = (Object(external_this_wp_data_["withSelect"])(function (select, _ref3) { + var clientId = _ref3.clientId; + + var _select = select('core/block-editor'), + getBlockIndex = _select.getBlockIndex, + getBlockRootClientId = _select.getBlockRootClientId; + + var rootClientId = getBlockRootClientId(clientId); + return { + index: getBlockIndex(clientId, rootClientId), + rootClientId: rootClientId + }; +})(block_draggable_BlockDraggable)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-mover/drag-handle.js + + +/** + * External dependencies + */ + +/** + * Internal dependencies + */ + + +var drag_handle_IconDragHandle = function IconDragHandle(_ref) { + var isVisible = _ref.isVisible, + className = _ref.className, + icon = _ref.icon, + onDragStart = _ref.onDragStart, + onDragEnd = _ref.onDragEnd, + blockElementId = _ref.blockElementId, + clientId = _ref.clientId; + + if (!isVisible) { + return null; + } + + var dragHandleClassNames = classnames_default()('editor-block-mover__control-drag-handle block-editor-block-mover__control-drag-handle', className); + return Object(external_this_wp_element_["createElement"])(block_draggable, { + clientId: clientId, + blockElementId: blockElementId, + onDragStart: onDragStart, + onDragEnd: onDragEnd + }, function (_ref2) { + var onDraggableStart = _ref2.onDraggableStart, + onDraggableEnd = _ref2.onDraggableEnd; + return Object(external_this_wp_element_["createElement"])("div", { + className: dragHandleClassNames, + "aria-hidden": "true", + onDragStart: onDraggableStart, + onDragEnd: onDraggableEnd, + draggable: true + }, icon); + }); +}; + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-mover/index.js + + + + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + + + +/** + * Internal dependencies + */ + + + + +var block_mover_BlockMover = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockMover, _Component); + + function BlockMover() { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockMover); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockMover).apply(this, arguments)); + _this.state = { + isFocused: false + }; + _this.onFocus = _this.onFocus.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onBlur = _this.onBlur.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(BlockMover, [{ + key: "onFocus", + value: function onFocus() { + this.setState({ + isFocused: true + }); + } + }, { + key: "onBlur", + value: function onBlur() { + this.setState({ + isFocused: false + }); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + onMoveUp = _this$props.onMoveUp, + onMoveDown = _this$props.onMoveDown, + isFirst = _this$props.isFirst, + isLast = _this$props.isLast, + isDraggable = _this$props.isDraggable, + onDragStart = _this$props.onDragStart, + onDragEnd = _this$props.onDragEnd, + clientIds = _this$props.clientIds, + blockElementId = _this$props.blockElementId, + blockType = _this$props.blockType, + firstIndex = _this$props.firstIndex, + isLocked = _this$props.isLocked, + instanceId = _this$props.instanceId, + isHidden = _this$props.isHidden, + rootClientId = _this$props.rootClientId; + var isFocused = this.state.isFocused; + var blocksCount = Object(external_lodash_["castArray"])(clientIds).length; + + if (isLocked || isFirst && isLast && !rootClientId) { + return null; + } // We emulate a disabled state because forcefully applying the `disabled` + // attribute on the button while it has focus causes the screen to change + // to an unfocused state (body as active element) without firing blur on, + // the rendering parent, leaving it unable to react to focus out. + + + return Object(external_this_wp_element_["createElement"])("div", { + className: classnames_default()('editor-block-mover block-editor-block-mover', { + 'is-visible': isFocused || !isHidden + }) + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + className: "editor-block-mover__control block-editor-block-mover__control", + onClick: isFirst ? null : onMoveUp, + icon: upArrow, + label: Object(external_this_wp_i18n_["__"])('Move up'), + "aria-describedby": "block-editor-block-mover__up-description-".concat(instanceId), + "aria-disabled": isFirst, + onFocus: this.onFocus, + onBlur: this.onBlur + }), Object(external_this_wp_element_["createElement"])(drag_handle_IconDragHandle, { + className: "editor-block-mover__control block-editor-block-mover__control", + icon: dragHandle, + clientId: clientIds, + blockElementId: blockElementId, + isVisible: isDraggable, + onDragStart: onDragStart, + onDragEnd: onDragEnd + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + className: "editor-block-mover__control block-editor-block-mover__control", + onClick: isLast ? null : onMoveDown, + icon: downArrow, + label: Object(external_this_wp_i18n_["__"])('Move down'), + "aria-describedby": "block-editor-block-mover__down-description-".concat(instanceId), + "aria-disabled": isLast, + onFocus: this.onFocus, + onBlur: this.onBlur + }), Object(external_this_wp_element_["createElement"])("span", { + id: "block-editor-block-mover__up-description-".concat(instanceId), + className: "editor-block-mover__description block-editor-block-mover__description" + }, getBlockMoverDescription(blocksCount, blockType && blockType.title, firstIndex, isFirst, isLast, -1)), Object(external_this_wp_element_["createElement"])("span", { + id: "block-editor-block-mover__down-description-".concat(instanceId), + className: "editor-block-mover__description block-editor-block-mover__description" + }, getBlockMoverDescription(blocksCount, blockType && blockType.title, firstIndex, isFirst, isLast, 1))); + } + }]); + + return BlockMover; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var block_mover = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select, _ref) { + var clientIds = _ref.clientIds; + + var _select = select('core/block-editor'), + getBlock = _select.getBlock, + getBlockIndex = _select.getBlockIndex, + getTemplateLock = _select.getTemplateLock, + getBlockRootClientId = _select.getBlockRootClientId, + getBlockOrder = _select.getBlockOrder; + + var normalizedClientIds = Object(external_lodash_["castArray"])(clientIds); + var firstClientId = Object(external_lodash_["first"])(normalizedClientIds); + var block = getBlock(firstClientId); + var rootClientId = getBlockRootClientId(Object(external_lodash_["first"])(normalizedClientIds)); + var blockOrder = getBlockOrder(rootClientId); + var firstIndex = getBlockIndex(firstClientId, rootClientId); + var lastIndex = getBlockIndex(Object(external_lodash_["last"])(normalizedClientIds), rootClientId); + return { + blockType: block ? Object(external_this_wp_blocks_["getBlockType"])(block.name) : null, + isLocked: getTemplateLock(rootClientId) === 'all', + rootClientId: rootClientId, + firstIndex: firstIndex, + isFirst: firstIndex === 0, + isLast: lastIndex === blockOrder.length - 1 + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref2) { + var clientIds = _ref2.clientIds, + rootClientId = _ref2.rootClientId; + + var _dispatch = dispatch('core/block-editor'), + moveBlocksDown = _dispatch.moveBlocksDown, + moveBlocksUp = _dispatch.moveBlocksUp; + + return { + onMoveDown: Object(external_lodash_["partial"])(moveBlocksDown, clientIds, rootClientId), + onMoveUp: Object(external_lodash_["partial"])(moveBlocksUp, clientIds, rootClientId) + }; +}), external_this_wp_compose_["withInstanceId"])(block_mover_BlockMover)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/warning/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +function Warning(_ref) { + var className = _ref.className, + actions = _ref.actions, + children = _ref.children, + secondaryActions = _ref.secondaryActions; + return Object(external_this_wp_element_["createElement"])("div", { + className: classnames_default()(className, 'editor-warning block-editor-warning') + }, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-warning__contents block-editor-warning__contents" + }, Object(external_this_wp_element_["createElement"])("p", { + className: "editor-warning__message block-editor-warning__message" + }, children), external_this_wp_element_["Children"].count(actions) > 0 && Object(external_this_wp_element_["createElement"])("div", { + className: "editor-warning__actions block-editor-warning__actions" + }, external_this_wp_element_["Children"].map(actions, function (action, i) { + return Object(external_this_wp_element_["createElement"])("span", { + key: i, + className: "editor-warning__action block-editor-warning__action" + }, action); + }))), secondaryActions && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Dropdown"], { + className: "editor-warning__secondary block-editor-warning__secondary", + position: "bottom left", + renderToggle: function renderToggle(_ref2) { + var isOpen = _ref2.isOpen, + onToggle = _ref2.onToggle; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + icon: "ellipsis", + label: Object(external_this_wp_i18n_["__"])('More options'), + onClick: onToggle, + "aria-expanded": isOpen + }); + }, + renderContent: function renderContent() { + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuGroup"], null, secondaryActions.map(function (item, pos) { + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuItem"], { + onClick: item.onClick, + key: pos + }, item.title); + })); + } + })); +} + +/* harmony default export */ var warning = (Warning); + +// EXTERNAL MODULE: ./node_modules/diff/dist/diff.js +var dist_diff = __webpack_require__(219); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-compare/block-view.js + + +/** + * WordPress dependencies + */ + + +var block_view_BlockView = function BlockView(_ref) { + var title = _ref.title, + rawContent = _ref.rawContent, + renderedContent = _ref.renderedContent, + action = _ref.action, + actionText = _ref.actionText, + className = _ref.className; + return Object(external_this_wp_element_["createElement"])("div", { + className: className + }, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-compare__content block-editor-block-compare__content" + }, Object(external_this_wp_element_["createElement"])("h2", { + className: "editor-block-compare__heading block-editor-block-compare__heading" + }, title), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-compare__html block-editor-block-compare__html" + }, rawContent), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-compare__preview block-editor-block-compare__preview edit-post-visual-editor" + }, renderedContent)), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-compare__action block-editor-block-compare__action" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isLarge: true, + tabIndex: "0", + onClick: action + }, actionText))); +}; + +/* harmony default export */ var block_view = (block_view_BlockView); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-compare/index.js + + + + + + + +/** + * External dependencies + */ + + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + + +var block_compare_BlockCompare = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockCompare, _Component); + + function BlockCompare() { + Object(classCallCheck["a" /* default */])(this, BlockCompare); + + return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockCompare).apply(this, arguments)); + } + + Object(createClass["a" /* default */])(BlockCompare, [{ + key: "getDifference", + value: function getDifference(originalContent, newContent) { + var difference = Object(dist_diff["diffChars"])(originalContent, newContent); + return difference.map(function (item, pos) { + var classes = classnames_default()({ + 'editor-block-compare__added block-editor-block-compare__added': item.added, + 'editor-block-compare__removed block-editor-block-compare__removed': item.removed + }); + return Object(external_this_wp_element_["createElement"])("span", { + key: pos, + className: classes + }, item.value); + }); + } + }, { + key: "getOriginalContent", + value: function getOriginalContent(block) { + return { + rawContent: block.originalContent, + renderedContent: Object(external_this_wp_blocks_["getSaveElement"])(block.name, block.attributes) + }; + } + }, { + key: "getConvertedContent", + value: function getConvertedContent(block) { + // The convertor may return an array of items or a single item + var newBlocks = Object(external_lodash_["castArray"])(block); // Get converted block details + + var newContent = newBlocks.map(function (item) { + return Object(external_this_wp_blocks_["getSaveContent"])(item.name, item.attributes, item.innerBlocks); + }); + var renderedContent = newBlocks.map(function (item) { + return Object(external_this_wp_blocks_["getSaveElement"])(item.name, item.attributes, item.innerBlocks); + }); + return { + rawContent: newContent.join(''), + renderedContent: renderedContent + }; + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + block = _this$props.block, + onKeep = _this$props.onKeep, + onConvert = _this$props.onConvert, + convertor = _this$props.convertor, + convertButtonText = _this$props.convertButtonText; + var original = this.getOriginalContent(block); + var converted = this.getConvertedContent(convertor(block)); + var difference = this.getDifference(original.rawContent, converted.rawContent); + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-compare__wrapper block-editor-block-compare__wrapper" + }, Object(external_this_wp_element_["createElement"])(block_view, { + title: Object(external_this_wp_i18n_["__"])('Current'), + className: "editor-block-compare__current block-editor-block-compare__current", + action: onKeep, + actionText: Object(external_this_wp_i18n_["__"])('Convert to HTML'), + rawContent: original.rawContent, + renderedContent: original.renderedContent + }), Object(external_this_wp_element_["createElement"])(block_view, { + title: Object(external_this_wp_i18n_["__"])('After Conversion'), + className: "editor-block-compare__converted block-editor-block-compare__converted", + action: onConvert, + actionText: convertButtonText, + rawContent: difference, + renderedContent: converted.renderedContent + })); + } + }]); + + return BlockCompare; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var block_compare = (block_compare_BlockCompare); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-invalid-warning.js + + + + + + + + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + +var block_invalid_warning_BlockInvalidWarning = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockInvalidWarning, _Component); + + function BlockInvalidWarning(props) { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockInvalidWarning); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockInvalidWarning).call(this, props)); + _this.state = { + compare: false + }; + _this.onCompare = _this.onCompare.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onCompareClose = _this.onCompareClose.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(BlockInvalidWarning, [{ + key: "onCompare", + value: function onCompare() { + this.setState({ + compare: true + }); + } + }, { + key: "onCompareClose", + value: function onCompareClose() { + this.setState({ + compare: false + }); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + convertToHTML = _this$props.convertToHTML, + convertToBlocks = _this$props.convertToBlocks, + convertToClassic = _this$props.convertToClassic, + attemptBlockRecovery = _this$props.attemptBlockRecovery, + block = _this$props.block; + var hasHTMLBlock = !!Object(external_this_wp_blocks_["getBlockType"])('core/html'); + var compare = this.state.compare; + var hiddenActions = [{ + title: Object(external_this_wp_i18n_["__"])('Convert to Classic Block'), + onClick: convertToClassic + }, { + title: Object(external_this_wp_i18n_["__"])('Attempt Block Recovery'), + onClick: attemptBlockRecovery + }]; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(warning, { + actions: [Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + key: "convert", + onClick: this.onCompare, + isLarge: true, + isPrimary: !hasHTMLBlock + }, // translators: Button to fix block content + Object(external_this_wp_i18n_["_x"])('Resolve', 'imperative verb')), hasHTMLBlock && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + key: "edit", + onClick: convertToHTML, + isLarge: true, + isPrimary: true + }, Object(external_this_wp_i18n_["__"])('Convert to HTML'))], + secondaryActions: hiddenActions + }, Object(external_this_wp_i18n_["__"])('This block contains unexpected or invalid content.')), compare && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Modal"], { + title: // translators: Dialog title to fix block content + Object(external_this_wp_i18n_["__"])('Resolve Block'), + onRequestClose: this.onCompareClose, + className: "editor-block-compare block-editor-block-compare" + }, Object(external_this_wp_element_["createElement"])(block_compare, { + block: block, + onKeep: convertToHTML, + onConvert: convertToBlocks, + convertor: block_invalid_warning_blockToBlocks, + convertButtonText: Object(external_this_wp_i18n_["__"])('Convert to Blocks') + }))); + } + }]); + + return BlockInvalidWarning; +}(external_this_wp_element_["Component"]); + +var block_invalid_warning_blockToClassic = function blockToClassic(block) { + return Object(external_this_wp_blocks_["createBlock"])('core/freeform', { + content: block.originalContent + }); +}; + +var block_invalid_warning_blockToHTML = function blockToHTML(block) { + return Object(external_this_wp_blocks_["createBlock"])('core/html', { + content: block.originalContent + }); +}; + +var block_invalid_warning_blockToBlocks = function blockToBlocks(block) { + return Object(external_this_wp_blocks_["rawHandler"])({ + HTML: block.originalContent + }); +}; + +var block_invalid_warning_recoverBlock = function recoverBlock(_ref) { + var name = _ref.name, + attributes = _ref.attributes, + innerBlocks = _ref.innerBlocks; + return Object(external_this_wp_blocks_["createBlock"])(name, attributes, innerBlocks); +}; + +/* harmony default export */ var block_invalid_warning = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { + var clientId = _ref2.clientId; + return { + block: select('core/block-editor').getBlock(clientId) + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref3) { + var block = _ref3.block; + + var _dispatch = dispatch('core/block-editor'), + replaceBlock = _dispatch.replaceBlock; + + return { + convertToClassic: function convertToClassic() { + replaceBlock(block.clientId, block_invalid_warning_blockToClassic(block)); + }, + convertToHTML: function convertToHTML() { + replaceBlock(block.clientId, block_invalid_warning_blockToHTML(block)); + }, + convertToBlocks: function convertToBlocks() { + replaceBlock(block.clientId, block_invalid_warning_blockToBlocks(block)); + }, + attemptBlockRecovery: function attemptBlockRecovery() { + replaceBlock(block.clientId, block_invalid_warning_recoverBlock(block)); + } + }; +})])(block_invalid_warning_BlockInvalidWarning)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-warning.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + +var block_crash_warning_warning = Object(external_this_wp_element_["createElement"])(warning, { + className: "block-editor-block-list__block-crash-warning" +}, Object(external_this_wp_i18n_["__"])('This block has encountered an error and cannot be previewed.')); +/* harmony default export */ var block_crash_warning = (function () { + return block_crash_warning_warning; +}); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-crash-boundary.js + + + + + + +/** + * WordPress dependencies + */ + + +var block_crash_boundary_BlockCrashBoundary = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockCrashBoundary, _Component); + + function BlockCrashBoundary() { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockCrashBoundary); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockCrashBoundary).apply(this, arguments)); + _this.state = { + hasError: false + }; + return _this; + } + + Object(createClass["a" /* default */])(BlockCrashBoundary, [{ + key: "componentDidCatch", + value: function componentDidCatch(error) { + this.props.onError(error); + this.setState({ + hasError: true + }); + } + }, { + key: "render", + value: function render() { + if (this.state.hasError) { + return null; + } + + return this.props.children; + } + }]); + + return BlockCrashBoundary; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var block_crash_boundary = (block_crash_boundary_BlockCrashBoundary); + +// EXTERNAL MODULE: ./node_modules/react-autosize-textarea/lib/index.js +var react_autosize_textarea_lib = __webpack_require__(62); +var react_autosize_textarea_lib_default = /*#__PURE__*/__webpack_require__.n(react_autosize_textarea_lib); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-html.js + + + + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + +var block_html_BlockHTML = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockHTML, _Component); + + function BlockHTML(props) { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockHTML); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockHTML).apply(this, arguments)); + _this.onChange = _this.onChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onBlur = _this.onBlur.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.state = { + html: props.block.isValid ? Object(external_this_wp_blocks_["getBlockContent"])(props.block) : props.block.originalContent + }; + return _this; + } + + Object(createClass["a" /* default */])(BlockHTML, [{ + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + if (!Object(external_lodash_["isEqual"])(this.props.block.attributes, prevProps.block.attributes)) { + this.setState({ + html: Object(external_this_wp_blocks_["getBlockContent"])(this.props.block) + }); + } + } + }, { + key: "onBlur", + value: function onBlur() { + var html = this.state.html; + var blockType = Object(external_this_wp_blocks_["getBlockType"])(this.props.block.name); + var attributes = Object(external_this_wp_blocks_["getBlockAttributes"])(blockType, html, this.props.block.attributes); // If html is empty we reset the block to the default HTML and mark it as valid to avoid triggering an error + + var content = html ? html : Object(external_this_wp_blocks_["getSaveContent"])(blockType, attributes); + var isValid = html ? Object(external_this_wp_blocks_["isValidBlockContent"])(blockType, attributes, content) : true; + this.props.onChange(this.props.clientId, attributes, content, isValid); // Ensure the state is updated if we reset so it displays the default content + + if (!html) { + this.setState({ + html: content + }); + } + } + }, { + key: "onChange", + value: function onChange(event) { + this.setState({ + html: event.target.value + }); + } + }, { + key: "render", + value: function render() { + var html = this.state.html; + return Object(external_this_wp_element_["createElement"])(react_autosize_textarea_lib_default.a, { + className: "editor-block-list__block-html-textarea block-editor-block-list__block-html-textarea", + value: html, + onBlur: this.onBlur, + onChange: this.onChange + }); + } + }]); + + return BlockHTML; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var block_html = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, ownProps) { + return { + block: select('core/block-editor').getBlock(ownProps.clientId) + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + return { + onChange: function onChange(clientId, attributes, originalContent, isValid) { + dispatch('core/block-editor').updateBlock(clientId, { + attributes: attributes, + originalContent: originalContent, + isValid: isValid + }); + } + }; +})])(block_html_BlockHTML)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-title/index.js +/** + * WordPress dependencies + */ + + +/** + * Renders the block's configured title as a string, or empty if the title + * cannot be determined. + * + * @example + * + * ```jsx + * <BlockTitle clientId="afd1cb17-2c08-4e7a-91be-007ba7ddc3a1" /> + * ``` + * + * @param {Object} props + * @param {?string} props.name Block name. + * + * @return {?string} Block title. + */ + +function BlockTitle(_ref) { + var name = _ref.name; + + if (!name) { + return null; + } + + var blockType = Object(external_this_wp_blocks_["getBlockType"])(name); + + if (!blockType) { + return null; + } + + return blockType.title; +} +/* harmony default export */ var block_title = (Object(external_this_wp_data_["withSelect"])(function (select, ownProps) { + var _select = select('core/block-editor'), + getBlockName = _select.getBlockName; + + var clientId = ownProps.clientId; + return { + name: getBlockName(clientId) + }; +})(BlockTitle)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/breadcrumb.js + + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + +/** + * Block breadcrumb component, displaying the label of the block. If the block + * descends from a root block, a button is displayed enabling the user to select + * the root block. + * + * @param {string} props.clientId Client ID of block. + * @return {WPElement} Block Breadcrumb. + */ + +var BlockBreadcrumb = Object(external_this_wp_element_["forwardRef"])(function (_ref, ref) { + var clientId = _ref.clientId; + + var _useDispatch = Object(external_this_wp_data_["useDispatch"])('core/block-editor'), + setNavigationMode = _useDispatch.setNavigationMode; + + var _useSelect = Object(external_this_wp_data_["useSelect"])(function (select) { + return { + rootClientId: select('core/block-editor').getBlockRootClientId(clientId) + }; + }), + rootClientId = _useSelect.rootClientId; + + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-list__breadcrumb block-editor-block-list__breadcrumb" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Toolbar"], null, rootClientId && Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(block_title, { + clientId: rootClientId + }), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-block-list__descendant-arrow block-editor-block-list__descendant-arrow" + })), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + ref: ref, + onClick: function onClick() { + return setNavigationMode(false); + } + }, Object(external_this_wp_element_["createElement"])(block_title, { + clientId: clientId + })))); +}); +/* harmony default export */ var block_list_breadcrumb = (BlockBreadcrumb); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/navigable-toolbar/index.js + + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +var navigable_toolbar_NavigableToolbar = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(NavigableToolbar, _Component); + + function NavigableToolbar() { + var _this; + + Object(classCallCheck["a" /* default */])(this, NavigableToolbar); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(NavigableToolbar).apply(this, arguments)); + _this.focusToolbar = _this.focusToolbar.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.toolbar = Object(external_this_wp_element_["createRef"])(); + return _this; + } + + Object(createClass["a" /* default */])(NavigableToolbar, [{ + key: "focusToolbar", + value: function focusToolbar() { + var tabbables = external_this_wp_dom_["focus"].tabbable.find(this.toolbar.current); + + if (tabbables.length) { + tabbables[0].focus(); + } + } + }, { + key: "componentDidMount", + value: function componentDidMount() { + if (this.props.focusOnMount) { + this.focusToolbar(); + } // We use DOM event listeners instead of React event listeners + // because we want to catch events from the underlying DOM tree + // The React Tree can be different from the DOM tree when using + // portals. Block Toolbars for instance are rendered in a separate + // React Tree. + + + this.toolbar.current.addEventListener('keydown', this.switchOnKeyDown); + } + }, { + key: "componentwillUnmount", + value: function componentwillUnmount() { + this.toolbar.current.removeEventListener('keydown', this.switchOnKeyDown); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + children = _this$props.children, + props = Object(objectWithoutProperties["a" /* default */])(_this$props, ["children"]); + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["NavigableMenu"], Object(esm_extends["a" /* default */])({ + orientation: "horizontal", + role: "toolbar", + ref: this.toolbar + }, Object(external_lodash_["omit"])(props, ['focusOnMount'])), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["KeyboardShortcuts"], { + bindGlobal: true // Use the same event that TinyMCE uses in the Classic block for its own `alt+f10` shortcut. + , + eventName: "keydown", + shortcuts: { + 'alt+f10': this.focusToolbar + } + }), children); + } + }]); + + return NavigableToolbar; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var navigable_toolbar = (navigable_toolbar_NavigableToolbar); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-contextual-toolbar.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + + +function BlockContextualToolbar(_ref) { + var focusOnMount = _ref.focusOnMount; + return Object(external_this_wp_element_["createElement"])(navigable_toolbar, { + focusOnMount: focusOnMount, + className: "editor-block-contextual-toolbar block-editor-block-contextual-toolbar" + /* translators: accessibility text for the block toolbar */ + , + "aria-label": Object(external_this_wp_i18n_["__"])('Block tools') + }, Object(external_this_wp_element_["createElement"])(block_toolbar, null)); +} + +/* harmony default export */ var block_contextual_toolbar = (BlockContextualToolbar); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/multi-controls.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + +function BlockListMultiControls(_ref) { + var multiSelectedBlockClientIds = _ref.multiSelectedBlockClientIds, + isSelecting = _ref.isSelecting; + + if (isSelecting) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(block_mover, { + clientIds: multiSelectedBlockClientIds + }); +} + +/* harmony default export */ var multi_controls = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getMultiSelectedBlockClientIds = _select.getMultiSelectedBlockClientIds, + isMultiSelecting = _select.isMultiSelecting; + + var clientIds = getMultiSelectedBlockClientIds(); + return { + multiSelectedBlockClientIds: clientIds, + isSelecting: isMultiSelecting() + }; +})(BlockListMultiControls)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/block-mobile-toolbar.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + + +function BlockMobileToolbar(_ref) { + var clientId = _ref.clientId; + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-list__block-mobile-toolbar block-editor-block-list__block-mobile-toolbar" + }, Object(external_this_wp_element_["createElement"])(inserter, null), Object(external_this_wp_element_["createElement"])(block_mover, { + clientIds: [clientId] + })); +} + +/* harmony default export */ var block_mobile_toolbar = (Object(external_this_wp_viewport_["ifViewportMatches"])('< small')(BlockMobileToolbar)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/insertion-point.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + +var insertion_point_BlockInsertionPoint = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockInsertionPoint, _Component); + + function BlockInsertionPoint() { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockInsertionPoint); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockInsertionPoint).apply(this, arguments)); + _this.state = { + isInserterFocused: false + }; + _this.onBlurInserter = _this.onBlurInserter.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onFocusInserter = _this.onFocusInserter.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(BlockInsertionPoint, [{ + key: "onFocusInserter", + value: function onFocusInserter(event) { + // Stop propagation of the focus event to avoid selecting the current + // block while inserting a new block, as it is not relevant to sibling + // insertion and conflicts with contextual toolbar placement. + event.stopPropagation(); + this.setState({ + isInserterFocused: true + }); + } + }, { + key: "onBlurInserter", + value: function onBlurInserter() { + this.setState({ + isInserterFocused: false + }); + } + }, { + key: "render", + value: function render() { + var isInserterFocused = this.state.isInserterFocused; + var _this$props = this.props, + showInsertionPoint = _this$props.showInsertionPoint, + rootClientId = _this$props.rootClientId, + clientId = _this$props.clientId; + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-list__insertion-point block-editor-block-list__insertion-point" + }, showInsertionPoint && Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-list__insertion-point-indicator block-editor-block-list__insertion-point-indicator" + }), Object(external_this_wp_element_["createElement"])("div", { + onFocus: this.onFocusInserter, + onBlur: this.onBlurInserter // While ideally it would be enough to capture the + // bubbling focus event from the Inserter, due to the + // characteristics of click focusing of `button`s in + // Firefox and Safari, it is not reliable. + // + // See: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/button#Clicking_and_focus + , + tabIndex: -1, + className: classnames_default()('editor-block-list__insertion-point-inserter block-editor-block-list__insertion-point-inserter', { + 'is-visible': isInserterFocused + }) + }, Object(external_this_wp_element_["createElement"])(inserter, { + rootClientId: rootClientId, + clientId: clientId + }))); + } + }]); + + return BlockInsertionPoint; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var insertion_point = (Object(external_this_wp_data_["withSelect"])(function (select, _ref) { + var clientId = _ref.clientId, + rootClientId = _ref.rootClientId; + + var _select = select('core/block-editor'), + getBlockIndex = _select.getBlockIndex, + getBlockInsertionPoint = _select.getBlockInsertionPoint, + isBlockInsertionPointVisible = _select.isBlockInsertionPointVisible; + + var blockIndex = getBlockIndex(clientId, rootClientId); + var insertionPoint = getBlockInsertionPoint(); + var showInsertionPoint = isBlockInsertionPointVisible() && insertionPoint.index === blockIndex && insertionPoint.rootClientId === rootClientId; + return { + showInsertionPoint: showInsertionPoint + }; +})(insertion_point_BlockInsertionPoint)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/ignore-nested-events/index.js + + + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Component which renders a div with passed props applied except the optional + * `childHandledEvents` prop. Event prop handlers are replaced with a proxying + * event handler to capture and prevent events from being handled by ancestor + * `IgnoreNestedEvents` elements by testing the presence of a private property + * assigned on the event object. + * + * Optionally accepts an `childHandledEvents` prop array, which can be used in + * instances where an inner `IgnoreNestedEvents` element exists and the outer + * element should stop propagation but not invoke a callback handler, since it + * would be assumed these are invoked by the child element. + * + * @type {Component} + */ + +var ignore_nested_events_IgnoreNestedEvents = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(IgnoreNestedEvents, _Component); + + function IgnoreNestedEvents() { + var _this; + + Object(classCallCheck["a" /* default */])(this, IgnoreNestedEvents); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(IgnoreNestedEvents).apply(this, arguments)); + _this.proxyEvent = _this.proxyEvent.bind(Object(assertThisInitialized["a" /* default */])(_this)); // The event map is responsible for tracking an event type to a React + // component prop name, since it is easy to determine event type from + // a React prop name, but not the other way around. + + _this.eventMap = {}; + return _this; + } + /** + * General event handler which only calls to its original props callback if + * it has not already been handled by a descendant IgnoreNestedEvents. + * + * @param {Event} event Event object. + */ + + + Object(createClass["a" /* default */])(IgnoreNestedEvents, [{ + key: "proxyEvent", + value: function proxyEvent(event) { + var isHandled = !!event.nativeEvent._blockHandled; // Assign into the native event, since React will reuse their synthetic + // event objects and this property assignment could otherwise leak. + // + // See: https://reactjs.org/docs/events.html#event-pooling + + event.nativeEvent._blockHandled = true; // Invoke original prop handler + + var propKey = this.eventMap[event.type]; // If already handled (i.e. assume nested block), only invoke a + // corresponding "Handled"-suffixed prop callback. + + if (isHandled) { + propKey += 'Handled'; + } + + if (this.props[propKey]) { + this.props[propKey](event); + } + } + }, { + key: "render", + value: function render() { + var _this2 = this; + + var _this$props = this.props, + _this$props$childHand = _this$props.childHandledEvents, + childHandledEvents = _this$props$childHand === void 0 ? [] : _this$props$childHand, + forwardedRef = _this$props.forwardedRef, + _this$props$tagName = _this$props.tagName, + tagName = _this$props$tagName === void 0 ? 'div' : _this$props$tagName, + props = Object(objectWithoutProperties["a" /* default */])(_this$props, ["childHandledEvents", "forwardedRef", "tagName"]); + + var eventHandlers = Object(external_lodash_["reduce"])([].concat(Object(toConsumableArray["a" /* default */])(childHandledEvents), Object(toConsumableArray["a" /* default */])(Object.keys(props))), function (result, key) { + // Try to match prop key as event handler + var match = key.match(/^on([A-Z][a-zA-Z]+?)(Handled)?$/); + + if (match) { + var isHandledProp = !!match[2]; + + if (isHandledProp) { + // Avoid assigning through the invalid prop key. This + // assumes mutation of shallow clone by above spread. + delete props[key]; + } // Re-map the prop to the local proxy handler to check whether + // the event has already been handled. + + + var proxiedPropName = 'on' + match[1]; + result[proxiedPropName] = _this2.proxyEvent; // Assign event -> propName into an instance variable, so as to + // avoid re-renders which could be incurred either by setState + // or in mapping values to a newly created function. + + _this2.eventMap[match[1].toLowerCase()] = proxiedPropName; + } + + return result; + }, {}); + return Object(external_this_wp_element_["createElement"])(tagName, Object(objectSpread["a" /* default */])({ + ref: forwardedRef + }, props, eventHandlers)); + } + }]); + + return IgnoreNestedEvents; +}(external_this_wp_element_["Component"]); + +var ignore_nested_events_forwardedIgnoreNestedEvents = function forwardedIgnoreNestedEvents(props, ref) { + return Object(external_this_wp_element_["createElement"])(ignore_nested_events_IgnoreNestedEvents, Object(esm_extends["a" /* default */])({}, props, { + forwardedRef: ref + })); +}; + +ignore_nested_events_forwardedIgnoreNestedEvents.displayName = 'IgnoreNestedEvents'; +/* harmony default export */ var ignore_nested_events = (Object(external_this_wp_element_["forwardRef"])(ignore_nested_events_forwardedIgnoreNestedEvents)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inserter-with-shortcuts/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + +function InserterWithShortcuts(_ref) { + var items = _ref.items, + isLocked = _ref.isLocked, + onInsert = _ref.onInsert; + + if (isLocked) { + return null; + } + + var itemsWithoutDefaultBlock = Object(external_lodash_["filter"])(items, function (item) { + return !item.isDisabled && (item.name !== Object(external_this_wp_blocks_["getDefaultBlockName"])() || !Object(external_lodash_["isEmpty"])(item.initialAttributes)); + }).slice(0, 3); + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-inserter-with-shortcuts block-editor-inserter-with-shortcuts" + }, itemsWithoutDefaultBlock.map(function (item) { + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + key: item.id, + className: "editor-inserter-with-shortcuts__block block-editor-inserter-with-shortcuts__block", + onClick: function onClick() { + return onInsert(item); + } // translators: %s: block title/name to be added + , + label: Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["__"])('Add %s'), item.title), + icon: Object(external_this_wp_element_["createElement"])(BlockIcon, { + icon: item.icon + }) + }); + })); +} + +/* harmony default export */ var inserter_with_shortcuts = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { + var rootClientId = _ref2.rootClientId; + + var _select = select('core/block-editor'), + getInserterItems = _select.getInserterItems, + getTemplateLock = _select.getTemplateLock; + + return { + items: getInserterItems(rootClientId), + isLocked: !!getTemplateLock(rootClientId) + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, ownProps) { + var clientId = ownProps.clientId, + rootClientId = ownProps.rootClientId; + return { + onInsert: function onInsert(_ref3) { + var name = _ref3.name, + initialAttributes = _ref3.initialAttributes; + var block = Object(external_this_wp_blocks_["createBlock"])(name, initialAttributes); + + if (clientId) { + dispatch('core/block-editor').replaceBlocks(clientId, block); + } else { + dispatch('core/block-editor').insertBlock(block, undefined, rootClientId); + } + } + }; +}))(InserterWithShortcuts)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/utils/dom.js +/** + * Given a block client ID, returns the corresponding DOM node for the block, + * if exists. As much as possible, this helper should be avoided, and used only + * in cases where isolated behaviors need remote access to a block node. + * + * @param {string} clientId Block client ID. + * @param {Element} scope an optional DOM Element to which the selector should be scoped + * + * @return {Element} Block DOM node. + */ +function getBlockDOMNode(clientId) { + var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : document; + return scope.querySelector('[data-block="' + clientId + '"]'); +} +function getBlockPreviewContainerDOMNode(clientId, scope) { + var domNode = getBlockDOMNode(clientId, scope); + + if (!domNode) { + return; + } + + return domNode.firstChild || domNode; +} +/** + * Given a block client ID, returns the corresponding DOM node for the block + * focusable wrapper, if exists. As much as possible, this helper should be + * avoided, and used only in cases where isolated behaviors need remote access + * to a block node. + * + * @param {string} clientId Block client ID. + * + * @return {Element} Block DOM node. + */ + +function getBlockFocusableWrapper(clientId) { + return getBlockDOMNode(clientId).closest('.block-editor-block-list__block'); +} +/** + * Returns true if the given HTMLElement is a block focus stop. Blocks without + * their own text fields rely on the focus stop to be keyboard navigable. + * + * @param {HTMLElement} element Element to test. + * + * @return {boolean} Whether element is a block focus stop. + */ + +function isBlockFocusStop(element) { + return element.classList.contains('block-editor-block-list__block'); +} +/** + * Returns true if two elements are contained within the same block. + * + * @param {HTMLElement} a First element. + * @param {HTMLElement} b Second element. + * + * @return {boolean} Whether elements are in the same block. + */ + +function isInSameBlock(a, b) { + return a.closest('[data-block]') === b.closest('[data-block]'); +} +/** + * Returns true if an elements is considered part of the block and not its children. + * + * @param {HTMLElement} blockElement Block container element. + * @param {HTMLElement} element Element. + * + * @return {boolean} Whether element is in the block Element but not its children. + */ + +function isInsideRootBlock(blockElement, element) { + var innerBlocksContainer = blockElement.querySelector('.block-editor-block-list__layout'); + return blockElement.contains(element) && (!innerBlocksContainer || !innerBlocksContainer.contains(element)); +} +/** + * Returns true if the given HTMLElement contains inner blocks (an InnerBlocks + * element). + * + * @param {HTMLElement} element Element to test. + * + * @return {boolean} Whether element contains inner blocks. + */ + +function hasInnerBlocksContext(element) { + return !!element.querySelector('.block-editor-block-list__layout'); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/moving-animation.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Simple reducer used to increment a counter. + * + * @param {number} state Previous counter value. + * @return {number} New state value. + */ + +var counterReducer = function counterReducer(state) { + return state + 1; +}; + +var getAbsolutePosition = function getAbsolutePosition(element) { + return { + top: element.offsetTop, + left: element.offsetLeft + }; +}; +/** + * Hook used to compute the styles required to move a div into a new position. + * + * The way this animation works is the following: + * - It first renders the element as if there was no animation. + * - It takes a snapshot of the position of the block to use it + * as a destination point for the animation. + * - It restores the element to the previous position using a CSS transform + * - It uses the "resetAnimation" flag to reset the animation + * from the beginning in order to animate to the new destination point. + * + * @param {Object} ref Reference to the element to animate. + * @param {boolean} isSelected Whether it's the current block or not. + * @param {boolean} adjustScrolling Adjust the scroll position to the current block. + * @param {boolean} enableAnimation Enable/Disable animation. + * @param {*} triggerAnimationOnChange Variable used to trigger the animation if it changes. + * + * @return {Object} Style object. + */ + + +function useMovingAnimation(ref, isSelected, adjustScrolling, enableAnimation, triggerAnimationOnChange) { + var prefersReducedMotion = Object(external_this_wp_compose_["useReducedMotion"])() || !enableAnimation; + + var _useReducer = Object(external_this_wp_element_["useReducer"])(counterReducer, 0), + _useReducer2 = Object(slicedToArray["a" /* default */])(_useReducer, 2), + triggeredAnimation = _useReducer2[0], + triggerAnimation = _useReducer2[1]; + + var _useReducer3 = Object(external_this_wp_element_["useReducer"])(counterReducer, 0), + _useReducer4 = Object(slicedToArray["a" /* default */])(_useReducer3, 2), + finishedAnimation = _useReducer4[0], + endAnimation = _useReducer4[1]; + + var _useState = Object(external_this_wp_element_["useState"])({ + x: 0, + y: 0, + scrollTop: 0 + }), + _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), + transform = _useState2[0], + setTransform = _useState2[1]; + + var previous = ref.current ? getAbsolutePosition(ref.current) : null; + var scrollContainer = Object(external_this_wp_element_["useMemo"])(function () { + if (!adjustScrolling) { + return false; + } + + return Object(external_this_wp_dom_["getScrollContainer"])(ref.current); + }, [adjustScrolling]); + Object(external_this_wp_element_["useLayoutEffect"])(function () { + if (triggeredAnimation) { + endAnimation(); + } + }, [triggeredAnimation]); + Object(external_this_wp_element_["useLayoutEffect"])(function () { + if (prefersReducedMotion) { + if (adjustScrolling && scrollContainer) { + // if the animation is disabled and the scroll needs to be adjusted, + // just move directly to the final scroll position + ref.current.style.transform = 'none'; + + var _destination = getAbsolutePosition(ref.current); + + scrollContainer.scrollTop = scrollContainer.scrollTop - previous.top + _destination.top; + } + + return; + } + + ref.current.style.transform = 'none'; + var destination = getAbsolutePosition(ref.current); + var newTransform = { + x: previous ? previous.left - destination.left : 0, + y: previous ? previous.top - destination.top : 0, + scrollTop: previous && scrollContainer ? scrollContainer.scrollTop - previous.top + destination.top : 0 + }; + ref.current.style.transform = newTransform.x === 0 && newTransform.y === 0 ? undefined : "translate3d(".concat(newTransform.x, "px,").concat(newTransform.y, "px,0)"); + triggerAnimation(); + setTransform(newTransform); + }, [triggerAnimationOnChange]); + var animationProps = Object(web_cjs["useSpring"])({ + from: { + x: transform.x, + y: transform.y + }, + to: { + x: 0, + y: 0 + }, + reset: triggeredAnimation !== finishedAnimation, + config: { + mass: 5, + tension: 2000, + friction: 200 + }, + immediate: prefersReducedMotion, + onFrame: function onFrame(props) { + if (adjustScrolling && scrollContainer && !prefersReducedMotion && props.y) { + scrollContainer.scrollTop = transform.scrollTop + props.y; + } + } + }); // Dismiss animations if disabled. + + return prefersReducedMotion ? {} : { + transformOrigin: 'center', + transform: Object(web_cjs["interpolate"])([animationProps.x, animationProps.y], function (x, y) { + return x === 0 && y === 0 ? undefined : "translate3d(".concat(x, "px,").concat(y, "px,0)"); + }), + zIndex: Object(web_cjs["interpolate"])([animationProps.x, animationProps.y], function (x, y) { + return !isSelected || x === 0 && y === 0 ? undefined : "1"; + }) + }; +} + +/* harmony default export */ var moving_animation = (useMovingAnimation); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/block.js + + + + + +/** + * External dependencies + */ + + + +/** + * WordPress dependencies + */ + + + + + + + + + + +/** + * Internal dependencies + */ + + + + + + + + + + + + + + + + + + +/** + * Prevents default dragging behavior within a block to allow for multi- + * selection to take effect unhampered. + * + * @param {DragEvent} event Drag event. + */ + +var preventDrag = function preventDrag(event) { + event.preventDefault(); +}; + +function block_BlockListBlock(_ref) { + var blockRef = _ref.blockRef, + mode = _ref.mode, + isFocusMode = _ref.isFocusMode, + hasFixedToolbar = _ref.hasFixedToolbar, + isLocked = _ref.isLocked, + clientId = _ref.clientId, + rootClientId = _ref.rootClientId, + isSelected = _ref.isSelected, + isPartOfMultiSelection = _ref.isPartOfMultiSelection, + isFirstMultiSelected = _ref.isFirstMultiSelected, + isTypingWithinBlock = _ref.isTypingWithinBlock, + isCaretWithinFormattedText = _ref.isCaretWithinFormattedText, + isEmptyDefaultBlock = _ref.isEmptyDefaultBlock, + isMovable = _ref.isMovable, + isParentOfSelectedBlock = _ref.isParentOfSelectedBlock, + isDraggable = _ref.isDraggable, + isSelectionEnabled = _ref.isSelectionEnabled, + className = _ref.className, + name = _ref.name, + isValid = _ref.isValid, + isLast = _ref.isLast, + attributes = _ref.attributes, + initialPosition = _ref.initialPosition, + wrapperProps = _ref.wrapperProps, + setAttributes = _ref.setAttributes, + onReplace = _ref.onReplace, + onInsertBlocksAfter = _ref.onInsertBlocksAfter, + onMerge = _ref.onMerge, + onSelect = _ref.onSelect, + onRemove = _ref.onRemove, + onInsertDefaultBlockAfter = _ref.onInsertDefaultBlockAfter, + toggleSelection = _ref.toggleSelection, + onShiftSelection = _ref.onShiftSelection, + onSelectionStart = _ref.onSelectionStart, + animateOnChange = _ref.animateOnChange, + enableAnimation = _ref.enableAnimation, + isNavigationMode = _ref.isNavigationMode, + enableNavigationMode = _ref.enableNavigationMode; + + // Random state used to rerender the component if needed, ideally we don't need this + var _useState = Object(external_this_wp_element_["useState"])({}), + _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), + updateRerenderState = _useState2[1]; + + var rerender = function rerender() { + return updateRerenderState({}); + }; // Reference of the wrapper + + + var wrapper = Object(external_this_wp_element_["useRef"])(null); + Object(external_this_wp_element_["useEffect"])(function () { + blockRef(wrapper.current, clientId); + }, []); // Reference to the block edit node + + var blockNodeRef = Object(external_this_wp_element_["useRef"])(); + var breadcrumb = Object(external_this_wp_element_["useRef"])(); // Keep track of touchstart to disable hover on iOS + + var hadTouchStart = Object(external_this_wp_element_["useRef"])(false); + + var onTouchStart = function onTouchStart() { + hadTouchStart.current = true; + }; + + var onTouchStop = function onTouchStop() { + // Clear touchstart detection + // Browser will try to emulate mouse events also see https://www.html5rocks.com/en/mobile/touchandmouse/ + hadTouchStart.current = false; + }; // Handling isHovered + + + var _useState3 = Object(external_this_wp_element_["useState"])(false), + _useState4 = Object(slicedToArray["a" /* default */])(_useState3, 2), + isBlockHovered = _useState4[0], + setBlockHoveredState = _useState4[1]; + /** + * Sets the block state as unhovered if currently hovering. There are cases + * where mouseleave may occur but the block is not hovered (multi-select), + * so to avoid unnecesary renders, the state is only set if hovered. + */ + + + var hideHoverEffects = function hideHoverEffects() { + if (isBlockHovered) { + setBlockHoveredState(false); + } + }; + /** + * A mouseover event handler to apply hover effect when a pointer device is + * placed within the bounds of the block. The mouseover event is preferred + * over mouseenter because it may be the case that a previous mouseenter + * event was blocked from being handled by a IgnoreNestedEvents component, + * therefore transitioning out of a nested block to the bounds of the block + * would otherwise not trigger a hover effect. + * + * @see https://developer.mozilla.org/en-US/docs/Web/Events/mouseenter + */ + + + var maybeHover = function maybeHover() { + if (isBlockHovered || isPartOfMultiSelection || isSelected || hadTouchStart.current) { + return; + } + + setBlockHoveredState(true); + }; // Set hover to false once we start typing or select the block. + + + Object(external_this_wp_element_["useEffect"])(function () { + if (isTypingWithinBlock || isSelected) { + hideHoverEffects(); + } + }); // Handling the dragging state + + var _useState5 = Object(external_this_wp_element_["useState"])(false), + _useState6 = Object(slicedToArray["a" /* default */])(_useState5, 2), + isDragging = _useState6[0], + setBlockDraggingState = _useState6[1]; + + var onDragStart = function onDragStart() { + setBlockDraggingState(true); + }; + + var onDragEnd = function onDragEnd() { + setBlockDraggingState(false); + }; // Handling the error state + + + var _useState7 = Object(external_this_wp_element_["useState"])(false), + _useState8 = Object(slicedToArray["a" /* default */])(_useState7, 2), + hasError = _useState8[0], + setErrorState = _useState8[1]; + + var onBlockError = function onBlockError() { + return setErrorState(true); + }; // Handling of forceContextualToolbarFocus + + + var isForcingContextualToolbar = Object(external_this_wp_element_["useRef"])(false); + Object(external_this_wp_element_["useEffect"])(function () { + if (isForcingContextualToolbar.current) { + // The forcing of contextual toolbar should only be true during one update, + // after the first update normal conditions should apply. + isForcingContextualToolbar.current = false; + } + }); + + var forceFocusedContextualToolbar = function forceFocusedContextualToolbar() { + isForcingContextualToolbar.current = true; // trigger a re-render + + rerender(); + }; // Handing the focus of the block on creation and update + + /** + * When a block becomes selected, transition focus to an inner tabbable. + * + * @param {boolean} ignoreInnerBlocks Should not focus inner blocks. + */ + + + var focusTabbable = function focusTabbable(ignoreInnerBlocks) { + // Focus is captured by the wrapper node, so while focus transition + // should only consider tabbables within editable display, since it + // may be the wrapper itself or a side control which triggered the + // focus event, don't unnecessary transition to an inner tabbable. + if (wrapper.current.contains(document.activeElement)) { + return; + } + + if (isNavigationMode) { + breadcrumb.current.focus(); + return; + } // Find all tabbables within node. + + + var textInputs = external_this_wp_dom_["focus"].tabbable.find(blockNodeRef.current).filter(external_this_wp_dom_["isTextField"]) // Exclude inner blocks + .filter(function (node) { + return !ignoreInnerBlocks || isInsideRootBlock(blockNodeRef.current, node); + }); // If reversed (e.g. merge via backspace), use the last in the set of + // tabbables. + + var isReverse = -1 === initialPosition; + var target = (isReverse ? external_lodash_["last"] : external_lodash_["first"])(textInputs); + + if (!target) { + wrapper.current.focus(); + return; + } + + Object(external_this_wp_dom_["placeCaretAtHorizontalEdge"])(target, isReverse); + }; // Focus the selected block's wrapper or inner input on mount and update + + + var isMounting = Object(external_this_wp_element_["useRef"])(true); + Object(external_this_wp_element_["useEffect"])(function () { + if (isSelected) { + focusTabbable(!isMounting.current); + } + + isMounting.current = false; + }, [isSelected]); // Focus the first multi selected block + + Object(external_this_wp_element_["useEffect"])(function () { + if (isFirstMultiSelected) { + wrapper.current.focus(); + } + }, [isFirstMultiSelected]); // Block Reordering animation + + var animationStyle = moving_animation(wrapper, isSelected || isPartOfMultiSelection, isSelected || isFirstMultiSelected, enableAnimation, animateOnChange); // Focus the breadcrumb if the wrapper is focused on navigation mode. + // Focus the first editable or the wrapper if edit mode. + + Object(external_this_wp_element_["useLayoutEffect"])(function () { + if (isSelected) { + if (isNavigationMode) { + breadcrumb.current.focus(); + } else { + focusTabbable(true); + } + } + }, [isSelected, isNavigationMode]); // Other event handlers + + /** + * Marks the block as selected when focused and not already selected. This + * specifically handles the case where block does not set focus on its own + * (via `setFocus`), typically if there is no focusable input in the block. + */ + + var onFocus = function onFocus() { + if (!isSelected && !isPartOfMultiSelection) { + onSelect(); + } + }; + /** + * Interprets keydown event intent to remove or insert after block if key + * event occurs on wrapper node. This can occur when the block has no text + * fields of its own, particularly after initial insertion, to allow for + * easy deletion and continuous writing flow to add additional content. + * + * @param {KeyboardEvent} event Keydown event. + */ + + + var onKeyDown = function onKeyDown(event) { + var keyCode = event.keyCode, + target = event.target; // ENTER/BACKSPACE Shortcuts are only available if the wrapper is focused + // and the block is not locked. + + var canUseShortcuts = isSelected && !isLocked && (target === wrapper.current || target === breadcrumb.current); + var isEditMode = !isNavigationMode; + + switch (keyCode) { + case external_this_wp_keycodes_["ENTER"]: + if (canUseShortcuts && isEditMode) { + // Insert default block after current block if enter and event + // not already handled by descendant. + onInsertDefaultBlockAfter(); + event.preventDefault(); + } + + break; + + case external_this_wp_keycodes_["BACKSPACE"]: + case external_this_wp_keycodes_["DELETE"]: + if (canUseShortcuts) { + // Remove block on backspace. + onRemove(clientId); + event.preventDefault(); + } + + break; + + case external_this_wp_keycodes_["ESCAPE"]: + if (isSelected && isEditMode) { + enableNavigationMode(); + wrapper.current.focus(); + } + + break; + } + }; + /** + * Begins tracking cursor multi-selection when clicking down within block. + * + * @param {MouseEvent} event A mousedown event. + */ + + + var onPointerDown = function onPointerDown(event) { + // Not the main button. + // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button + if (event.button !== 0) { + return; + } + + if (event.shiftKey) { + if (!isSelected) { + onShiftSelection(); + event.preventDefault(); + } // Avoid triggering multi-selection if we click toolbars/inspectors + // and all elements that are outside the Block Edit DOM tree. + + } else if (blockNodeRef.current.contains(event.target)) { + onSelectionStart(clientId); // Allow user to escape out of a multi-selection to a singular + // selection of a block via click. This is handled here since + // onFocus excludes blocks involved in a multiselection, as + // focus can be incurred by starting a multiselection (focus + // moved to first block's multi-controls). + + if (isPartOfMultiSelection) { + onSelect(); + } + } + }; + + var selectOnOpen = function selectOnOpen(open) { + if (open && !isSelected) { + onSelect(); + } + }; // Rendering the output + + + var isHovered = isBlockHovered && !isPartOfMultiSelection; + var blockType = Object(external_this_wp_blocks_["getBlockType"])(name); // translators: %s: Type of block (i.e. Text, Image etc) + + var blockLabel = Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["__"])('Block: %s'), blockType.title); // The block as rendered in the editor is composed of general block UI + // (mover, toolbar, wrapper) and the display of the block content. + + var isUnregisteredBlock = name === Object(external_this_wp_blocks_["getUnregisteredTypeHandlerName"])(); // If the block is selected and we're typing the block should not appear. + // Empty paragraph blocks should always show up as unselected. + + var showInserterShortcuts = !isNavigationMode && (isSelected || isHovered) && isEmptyDefaultBlock && isValid; + var showEmptyBlockSideInserter = !isNavigationMode && (isSelected || isHovered || isLast) && isEmptyDefaultBlock && isValid; + var shouldAppearSelected = !isFocusMode && !showEmptyBlockSideInserter && isSelected && !isTypingWithinBlock; + var shouldAppearHovered = !isFocusMode && !hasFixedToolbar && isHovered && !isEmptyDefaultBlock; // We render block movers and block settings to keep them tabbale even if hidden + + var shouldRenderMovers = !isNavigationMode && isSelected && !showEmptyBlockSideInserter && !isPartOfMultiSelection && !isTypingWithinBlock; + var shouldShowBreadcrumb = isSelected && isNavigationMode || !isNavigationMode && !isFocusMode && isHovered && !isEmptyDefaultBlock; + var shouldShowContextualToolbar = !isNavigationMode && !hasFixedToolbar && !showEmptyBlockSideInserter && (isSelected && (!isTypingWithinBlock || isCaretWithinFormattedText) || isFirstMultiSelected); + var shouldShowMobileToolbar = !isNavigationMode && shouldAppearSelected; // Insertion point can only be made visible if the block is at the + // the extent of a multi-selection, or not in a multi-selection. + + var shouldShowInsertionPoint = isPartOfMultiSelection && isFirstMultiSelected || !isPartOfMultiSelection; // The wp-block className is important for editor styles. + // Generate the wrapper class names handling the different states of the block. + + var wrapperClassName = classnames_default()('wp-block editor-block-list__block block-editor-block-list__block', { + 'has-warning': !isValid || !!hasError || isUnregisteredBlock, + 'is-selected': shouldAppearSelected, + 'is-navigate-mode': isNavigationMode, + 'is-multi-selected': isPartOfMultiSelection, + 'is-hovered': shouldAppearHovered, + 'is-reusable': Object(external_this_wp_blocks_["isReusableBlock"])(blockType), + 'is-dragging': isDragging, + 'is-typing': isTypingWithinBlock, + 'is-focused': isFocusMode && (isSelected || isParentOfSelectedBlock), + 'is-focus-mode': isFocusMode, + 'has-child-selected': isParentOfSelectedBlock + }, className); // Determine whether the block has props to apply to the wrapper. + + if (blockType.getEditWrapperProps) { + wrapperProps = Object(objectSpread["a" /* default */])({}, wrapperProps, blockType.getEditWrapperProps(attributes)); + } + + var blockElementId = "block-".concat(clientId); // We wrap the BlockEdit component in a div that hides it when editing in + // HTML mode. This allows us to render all of the ancillary pieces + // (InspectorControls, etc.) which are inside `BlockEdit` but not + // `BlockHTML`, even in HTML mode. + + var blockEdit = Object(external_this_wp_element_["createElement"])(block_edit, { + name: name, + isSelected: isSelected, + attributes: attributes, + setAttributes: setAttributes, + insertBlocksAfter: isLocked ? undefined : onInsertBlocksAfter, + onReplace: isLocked ? undefined : onReplace, + mergeBlocks: isLocked ? undefined : onMerge, + clientId: clientId, + isSelectionEnabled: isSelectionEnabled, + toggleSelection: toggleSelection + }); + + if (mode !== 'visual') { + blockEdit = Object(external_this_wp_element_["createElement"])("div", { + style: { + display: 'none' + } + }, blockEdit); + } + + return Object(external_this_wp_element_["createElement"])(ignore_nested_events, Object(esm_extends["a" /* default */])({ + id: blockElementId, + ref: wrapper, + onMouseOver: maybeHover, + onMouseOverHandled: hideHoverEffects, + onMouseLeave: hideHoverEffects, + className: wrapperClassName, + "data-type": name, + onTouchStart: onTouchStart, + onFocus: onFocus, + onClick: onTouchStop, + onKeyDown: onKeyDown, + tabIndex: "0", + "aria-label": blockLabel, + childHandledEvents: ['onDragStart', 'onMouseDown'], + tagName: web_cjs["animated"].div + }, wrapperProps, { + style: wrapperProps && wrapperProps.style ? Object(objectSpread["a" /* default */])({}, wrapperProps.style, animationStyle) : animationStyle + }), shouldShowInsertionPoint && Object(external_this_wp_element_["createElement"])(insertion_point, { + clientId: clientId, + rootClientId: rootClientId + }), Object(external_this_wp_element_["createElement"])(block_drop_zone, { + clientId: clientId, + rootClientId: rootClientId + }), isFirstMultiSelected && Object(external_this_wp_element_["createElement"])(multi_controls, { + rootClientId: rootClientId + }), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-list__block-edit block-editor-block-list__block-edit" + }, shouldRenderMovers && Object(external_this_wp_element_["createElement"])(block_mover, { + clientIds: clientId, + blockElementId: blockElementId, + isHidden: !isSelected, + isDraggable: isDraggable !== false && !isPartOfMultiSelection && isMovable, + onDragStart: onDragStart, + onDragEnd: onDragEnd + }), shouldShowBreadcrumb && Object(external_this_wp_element_["createElement"])(block_list_breadcrumb, { + clientId: clientId, + ref: breadcrumb + }), (shouldShowContextualToolbar || isForcingContextualToolbar.current) && Object(external_this_wp_element_["createElement"])(block_contextual_toolbar // If the toolbar is being shown because of being forced + // it should focus the toolbar right after the mount. + , { + focusOnMount: isForcingContextualToolbar.current + }), !isNavigationMode && !shouldShowContextualToolbar && isSelected && !hasFixedToolbar && !isEmptyDefaultBlock && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["KeyboardShortcuts"], { + bindGlobal: true, + eventName: "keydown", + shortcuts: { + 'alt+f10': forceFocusedContextualToolbar + } + }), Object(external_this_wp_element_["createElement"])(ignore_nested_events, { + ref: blockNodeRef, + onDragStart: preventDrag, + onMouseDown: onPointerDown, + "data-block": clientId + }, Object(external_this_wp_element_["createElement"])(block_crash_boundary, { + onError: onBlockError + }, isValid && blockEdit, isValid && mode === 'html' && Object(external_this_wp_element_["createElement"])(block_html, { + clientId: clientId + }), !isValid && [Object(external_this_wp_element_["createElement"])(block_invalid_warning, { + key: "invalid-warning", + clientId: clientId + }), Object(external_this_wp_element_["createElement"])("div", { + key: "invalid-preview" + }, Object(external_this_wp_blocks_["getSaveElement"])(blockType, attributes))]), !!hasError && Object(external_this_wp_element_["createElement"])(block_crash_warning, null), shouldShowMobileToolbar && Object(external_this_wp_element_["createElement"])(block_mobile_toolbar, { + clientId: clientId + }))), showInserterShortcuts && Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-list__side-inserter block-editor-block-list__side-inserter" + }, Object(external_this_wp_element_["createElement"])(inserter_with_shortcuts, { + clientId: clientId, + rootClientId: rootClientId, + onToggle: selectOnOpen + })), showEmptyBlockSideInserter && Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-list__empty-block-inserter block-editor-block-list__empty-block-inserter" + }, Object(external_this_wp_element_["createElement"])(inserter, { + position: "top right", + onToggle: selectOnOpen, + rootClientId: rootClientId, + clientId: clientId + }))); +} + +var applyWithSelect = Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { + var clientId = _ref2.clientId, + rootClientId = _ref2.rootClientId, + isLargeViewport = _ref2.isLargeViewport; + + var _select = select('core/block-editor'), + isBlockSelected = _select.isBlockSelected, + isAncestorMultiSelected = _select.isAncestorMultiSelected, + isBlockMultiSelected = _select.isBlockMultiSelected, + isFirstMultiSelectedBlock = _select.isFirstMultiSelectedBlock, + isTyping = _select.isTyping, + isCaretWithinFormattedText = _select.isCaretWithinFormattedText, + getBlockMode = _select.getBlockMode, + isSelectionEnabled = _select.isSelectionEnabled, + getSelectedBlocksInitialCaretPosition = _select.getSelectedBlocksInitialCaretPosition, + getSettings = _select.getSettings, + hasSelectedInnerBlock = _select.hasSelectedInnerBlock, + getTemplateLock = _select.getTemplateLock, + getBlockIndex = _select.getBlockIndex, + getBlockOrder = _select.getBlockOrder, + __unstableGetBlockWithoutInnerBlocks = _select.__unstableGetBlockWithoutInnerBlocks, + isNavigationMode = _select.isNavigationMode; + + var block = __unstableGetBlockWithoutInnerBlocks(clientId); + + var isSelected = isBlockSelected(clientId); + + var _getSettings = getSettings(), + hasFixedToolbar = _getSettings.hasFixedToolbar, + focusMode = _getSettings.focusMode, + isRTL = _getSettings.isRTL; + + var templateLock = getTemplateLock(rootClientId); + var isParentOfSelectedBlock = hasSelectedInnerBlock(clientId, true); + var index = getBlockIndex(clientId, rootClientId); + var blockOrder = getBlockOrder(rootClientId); // The fallback to `{}` is a temporary fix. + // This function should never be called when a block is not present in the state. + // It happens now because the order in withSelect rendering is not correct. + + var _ref3 = block || {}, + name = _ref3.name, + attributes = _ref3.attributes, + isValid = _ref3.isValid; + + return { + isPartOfMultiSelection: isBlockMultiSelected(clientId) || isAncestorMultiSelected(clientId), + isFirstMultiSelected: isFirstMultiSelectedBlock(clientId), + // We only care about this prop when the block is selected + // Thus to avoid unnecessary rerenders we avoid updating the prop if the block is not selected. + isTypingWithinBlock: (isSelected || isParentOfSelectedBlock) && isTyping(), + isCaretWithinFormattedText: isCaretWithinFormattedText(), + mode: getBlockMode(clientId), + isSelectionEnabled: isSelectionEnabled(), + initialPosition: isSelected ? getSelectedBlocksInitialCaretPosition() : null, + isEmptyDefaultBlock: name && Object(external_this_wp_blocks_["isUnmodifiedDefaultBlock"])({ + name: name, + attributes: attributes + }), + isMovable: 'all' !== templateLock, + isLocked: !!templateLock, + isFocusMode: focusMode && isLargeViewport, + hasFixedToolbar: hasFixedToolbar && isLargeViewport, + isLast: index === blockOrder.length - 1, + isNavigationMode: isNavigationMode(), + isRTL: isRTL, + // Users of the editor.BlockListBlock filter used to be able to access the block prop + // Ideally these blocks would rely on the clientId prop only. + // This is kept for backward compatibility reasons. + block: block, + name: name, + attributes: attributes, + isValid: isValid, + isSelected: isSelected, + isParentOfSelectedBlock: isParentOfSelectedBlock + }; +}); +var applyWithDispatch = Object(external_this_wp_data_["withDispatch"])(function (dispatch, ownProps, _ref4) { + var select = _ref4.select; + + var _dispatch = dispatch('core/block-editor'), + updateBlockAttributes = _dispatch.updateBlockAttributes, + selectBlock = _dispatch.selectBlock, + multiSelect = _dispatch.multiSelect, + insertBlocks = _dispatch.insertBlocks, + insertDefaultBlock = _dispatch.insertDefaultBlock, + removeBlock = _dispatch.removeBlock, + mergeBlocks = _dispatch.mergeBlocks, + replaceBlocks = _dispatch.replaceBlocks, + _toggleSelection = _dispatch.toggleSelection, + setNavigationMode = _dispatch.setNavigationMode, + __unstableMarkLastChangeAsPersistent = _dispatch.__unstableMarkLastChangeAsPersistent; + + return { + setAttributes: function setAttributes(newAttributes) { + var clientId = ownProps.clientId; + updateBlockAttributes(clientId, newAttributes); + }, + onSelect: function onSelect() { + var clientId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ownProps.clientId; + var initialPosition = arguments.length > 1 ? arguments[1] : undefined; + selectBlock(clientId, initialPosition); + }, + onInsertBlocks: function onInsertBlocks(blocks, index) { + var rootClientId = ownProps.rootClientId; + insertBlocks(blocks, index, rootClientId); + }, + onInsertDefaultBlockAfter: function onInsertDefaultBlockAfter() { + var clientId = ownProps.clientId, + rootClientId = ownProps.rootClientId; + + var _select2 = select('core/block-editor'), + getBlockIndex = _select2.getBlockIndex; + + var index = getBlockIndex(clientId, rootClientId); + insertDefaultBlock({}, rootClientId, index + 1); + }, + onInsertBlocksAfter: function onInsertBlocksAfter(blocks) { + var clientId = ownProps.clientId, + rootClientId = ownProps.rootClientId; + + var _select3 = select('core/block-editor'), + getBlockIndex = _select3.getBlockIndex; + + var index = getBlockIndex(clientId, rootClientId); + insertBlocks(blocks, index + 1, rootClientId); + }, + onRemove: function onRemove(clientId) { + removeBlock(clientId); + }, + onMerge: function onMerge(forward) { + var clientId = ownProps.clientId; + + var _select4 = select('core/block-editor'), + getPreviousBlockClientId = _select4.getPreviousBlockClientId, + getNextBlockClientId = _select4.getNextBlockClientId; + + if (forward) { + var nextBlockClientId = getNextBlockClientId(clientId); + + if (nextBlockClientId) { + mergeBlocks(clientId, nextBlockClientId); + } + } else { + var previousBlockClientId = getPreviousBlockClientId(clientId); + + if (previousBlockClientId) { + mergeBlocks(previousBlockClientId, clientId); + } + } + }, + onReplace: function onReplace(blocks, indexToSelect) { + if (blocks.length && !Object(external_this_wp_blocks_["isUnmodifiedDefaultBlock"])(blocks[blocks.length - 1])) { + __unstableMarkLastChangeAsPersistent(); + } + + replaceBlocks([ownProps.clientId], blocks, indexToSelect); + }, + onShiftSelection: function onShiftSelection() { + if (!ownProps.isSelectionEnabled) { + return; + } + + var _select5 = select('core/block-editor'), + getBlockSelectionStart = _select5.getBlockSelectionStart; + + if (getBlockSelectionStart()) { + multiSelect(getBlockSelectionStart(), ownProps.clientId); + } else { + selectBlock(ownProps.clientId); + } + }, + toggleSelection: function toggleSelection(selectionEnabled) { + _toggleSelection(selectionEnabled); + }, + enableNavigationMode: function enableNavigationMode() { + setNavigationMode(true); + } + }; +}); +/* harmony default export */ var block_list_block = (Object(external_this_wp_compose_["compose"])(external_this_wp_compose_["pure"], Object(external_this_wp_viewport_["withViewportMatch"])({ + isLargeViewport: 'medium' +}), applyWithSelect, applyWithDispatch, // block is sometimes not mounted at the right time, causing it be undefined +// see issue for more info https://github.com/WordPress/gutenberg/issues/17013 +Object(external_this_wp_compose_["ifCondition"])(function (_ref5) { + var block = _ref5.block; + return !!block; +}), Object(external_this_wp_components_["withFilters"])('editor.BlockListBlock'))(block_BlockListBlock)); + +// EXTERNAL MODULE: external {"this":["wp","htmlEntities"]} +var external_this_wp_htmlEntities_ = __webpack_require__(52); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/default-block-appender/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + + +function default_block_appender_DefaultBlockAppender(_ref) { + var isLocked = _ref.isLocked, + isVisible = _ref.isVisible, + onAppend = _ref.onAppend, + showPrompt = _ref.showPrompt, + placeholder = _ref.placeholder, + rootClientId = _ref.rootClientId, + hovered = _ref.hovered, + setState = _ref.setState; + + if (isLocked || !isVisible) { + return null; + } + + var value = Object(external_this_wp_htmlEntities_["decodeEntities"])(placeholder) || Object(external_this_wp_i18n_["__"])('Start writing or type / to choose a block'); // The appender "button" is in-fact a text field so as to support + // transitions by WritingFlow occurring by arrow key press. WritingFlow + // only supports tab transitions into text fields and to the block focus + // boundary. + // + // See: https://github.com/WordPress/gutenberg/issues/4829#issuecomment-374213658 + // + // If it were ever to be made to be a proper `button` element, it is + // important to note that `onFocus` alone would not be sufficient to + // capture click events, notably in Firefox. + // + // See: https://gist.github.com/cvrebert/68659d0333a578d75372 + // The wp-block className is important for editor styles. + + + return Object(external_this_wp_element_["createElement"])("div", { + "data-root-client-id": rootClientId || '', + className: "wp-block editor-default-block-appender block-editor-default-block-appender", + onMouseEnter: function onMouseEnter() { + return setState({ + hovered: true + }); + }, + onMouseLeave: function onMouseLeave() { + return setState({ + hovered: false + }); + } + }, Object(external_this_wp_element_["createElement"])(block_drop_zone, { + rootClientId: rootClientId + }), Object(external_this_wp_element_["createElement"])(react_autosize_textarea_lib_default.a, { + role: "button", + "aria-label": Object(external_this_wp_i18n_["__"])('Add block'), + className: "editor-default-block-appender__content block-editor-default-block-appender__content", + readOnly: true, + onFocus: onAppend, + value: showPrompt ? value : '' + }), hovered && Object(external_this_wp_element_["createElement"])(inserter_with_shortcuts, { + rootClientId: rootClientId + }), Object(external_this_wp_element_["createElement"])(inserter, { + rootClientId: rootClientId, + position: "top right", + isAppender: true + })); +} +/* harmony default export */ var default_block_appender = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_compose_["withState"])({ + hovered: false +}), Object(external_this_wp_data_["withSelect"])(function (select, ownProps) { + var _select = select('core/block-editor'), + getBlockCount = _select.getBlockCount, + getBlockName = _select.getBlockName, + isBlockValid = _select.isBlockValid, + getSettings = _select.getSettings, + getTemplateLock = _select.getTemplateLock; + + var isEmpty = !getBlockCount(ownProps.rootClientId); + var isLastBlockDefault = getBlockName(ownProps.lastBlockClientId) === Object(external_this_wp_blocks_["getDefaultBlockName"])(); + var isLastBlockValid = isBlockValid(ownProps.lastBlockClientId); + + var _getSettings = getSettings(), + bodyPlaceholder = _getSettings.bodyPlaceholder; + + return { + isVisible: isEmpty || !isLastBlockDefault || !isLastBlockValid, + showPrompt: isEmpty, + isLocked: !!getTemplateLock(ownProps.rootClientId), + placeholder: bodyPlaceholder + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, ownProps) { + var _dispatch = dispatch('core/block-editor'), + insertDefaultBlock = _dispatch.insertDefaultBlock, + startTyping = _dispatch.startTyping; + + return { + onAppend: function onAppend() { + var rootClientId = ownProps.rootClientId; + insertDefaultBlock(undefined, rootClientId); + startTyping(); + } + }; +}))(default_block_appender_DefaultBlockAppender)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list-appender/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + + +function BlockListAppender(_ref) { + var blockClientIds = _ref.blockClientIds, + rootClientId = _ref.rootClientId, + canInsertDefaultBlock = _ref.canInsertDefaultBlock, + isLocked = _ref.isLocked, + CustomAppender = _ref.renderAppender; + + if (isLocked) { + return null; + } // If a render prop has been provided + // use it to render the appender. + + + if (CustomAppender) { + return Object(external_this_wp_element_["createElement"])("div", { + className: "block-list-appender" + }, Object(external_this_wp_element_["createElement"])(CustomAppender, null)); + } // a false value means, don't render any appender. + + + if (CustomAppender === false) { + return null; + } // Render the default block appender when renderAppender has not been + // provided and the context supports use of the default appender. + + + if (canInsertDefaultBlock) { + return Object(external_this_wp_element_["createElement"])("div", { + className: "block-list-appender" + }, Object(external_this_wp_element_["createElement"])(ignore_nested_events, { + childHandledEvents: ['onFocus', 'onClick', 'onKeyDown'] + }, Object(external_this_wp_element_["createElement"])(default_block_appender, { + rootClientId: rootClientId, + lastBlockClientId: Object(external_lodash_["last"])(blockClientIds) + }))); + } // Fallback in the case no renderAppender has been provided and the + // default block can't be inserted. + + + return Object(external_this_wp_element_["createElement"])("div", { + className: "block-list-appender" + }, Object(external_this_wp_element_["createElement"])(button_block_appender, { + rootClientId: rootClientId, + className: "block-list-appender__toggle" + })); +} + +/* harmony default export */ var block_list_appender = (Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { + var rootClientId = _ref2.rootClientId; + + var _select = select('core/block-editor'), + getBlockOrder = _select.getBlockOrder, + canInsertBlockType = _select.canInsertBlockType, + getTemplateLock = _select.getTemplateLock; + + return { + isLocked: !!getTemplateLock(rootClientId), + blockClientIds: getBlockOrder(rootClientId), + canInsertDefaultBlock: canInsertBlockType(Object(external_this_wp_blocks_["getDefaultBlockName"])(), rootClientId) + }; +})(BlockListAppender)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-list/index.js + + + + + + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + + + + +/** + * If the block count exceeds the threshold, we disable the reordering animation + * to avoid laginess. + */ + +var BLOCK_ANIMATION_THRESHOLD = 200; + +var block_list_forceSyncUpdates = function forceSyncUpdates(WrappedComponent) { + return function (props) { + return Object(external_this_wp_element_["createElement"])(external_this_wp_data_["__experimentalAsyncModeProvider"], { + value: false + }, Object(external_this_wp_element_["createElement"])(WrappedComponent, props)); + }; +}; + +var block_list_BlockList = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockList, _Component); + + function BlockList(props) { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockList); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockList).call(this, props)); + _this.onSelectionStart = _this.onSelectionStart.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onSelectionEnd = _this.onSelectionEnd.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.setBlockRef = _this.setBlockRef.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.setLastClientY = _this.setLastClientY.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onPointerMove = Object(external_lodash_["throttle"])(_this.onPointerMove.bind(Object(assertThisInitialized["a" /* default */])(_this)), 100); // Browser does not fire `*move` event when the pointer position changes + // relative to the document, so fire it with the last known position. + + _this.onScroll = function () { + return _this.onPointerMove({ + clientY: _this.lastClientY + }); + }; + + _this.lastClientY = 0; + _this.nodes = {}; + return _this; + } + + Object(createClass["a" /* default */])(BlockList, [{ + key: "componentDidMount", + value: function componentDidMount() { + window.addEventListener('mousemove', this.setLastClientY); + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + window.removeEventListener('mousemove', this.setLastClientY); + } + }, { + key: "setLastClientY", + value: function setLastClientY(_ref) { + var clientY = _ref.clientY; + this.lastClientY = clientY; + } + }, { + key: "setBlockRef", + value: function setBlockRef(node, clientId) { + if (node === null) { + delete this.nodes[clientId]; + } else { + this.nodes = Object(objectSpread["a" /* default */])({}, this.nodes, Object(defineProperty["a" /* default */])({}, clientId, node)); + } + } + /** + * Handles a pointer move event to update the extent of the current cursor + * multi-selection. + * + * @param {MouseEvent} event A mousemove event object. + */ + + }, { + key: "onPointerMove", + value: function onPointerMove(_ref2) { + var clientY = _ref2.clientY; + + // We don't start multi-selection until the mouse starts moving, so as + // to avoid dispatching multi-selection actions on an in-place click. + if (!this.props.isMultiSelecting) { + this.props.onStartMultiSelect(); + } + + var blockContentBoundaries = getBlockDOMNode(this.selectionAtStart).getBoundingClientRect(); // prevent multi-selection from triggering when the selected block is a float + // and the cursor is still between the top and the bottom of the block. + + if (clientY >= blockContentBoundaries.top && clientY <= blockContentBoundaries.bottom) { + return; + } + + var y = clientY - blockContentBoundaries.top; + var key = Object(external_lodash_["findLast"])(this.coordMapKeys, function (coordY) { + return coordY < y; + }); + this.onSelectionChange(this.coordMap[key]); + } + /** + * Binds event handlers to the document for tracking a pending multi-select + * in response to a mousedown event occurring in a rendered block. + * + * @param {string} clientId Client ID of block where mousedown occurred. + */ + + }, { + key: "onSelectionStart", + value: function onSelectionStart(clientId) { + if (!this.props.isSelectionEnabled) { + return; + } + + var boundaries = this.nodes[clientId].getBoundingClientRect(); // Create a clientId to Y coördinate map. + + var clientIdToCoordMap = Object(external_lodash_["mapValues"])(this.nodes, function (node) { + return node.getBoundingClientRect().top - boundaries.top; + }); // Cache a Y coördinate to clientId map for use in `onPointerMove`. + + this.coordMap = Object(external_lodash_["invert"])(clientIdToCoordMap); // Cache an array of the Y coördinates for use in `onPointerMove`. + // Sort the coördinates, as `this.nodes` will not necessarily reflect + // the current block sequence. + + this.coordMapKeys = Object(external_lodash_["sortBy"])(Object.values(clientIdToCoordMap)); + this.selectionAtStart = clientId; + window.addEventListener('mousemove', this.onPointerMove); // Capture scroll on all elements. + + window.addEventListener('scroll', this.onScroll, true); + window.addEventListener('mouseup', this.onSelectionEnd); + } + /** + * Handles multi-selection changes in response to pointer move. + * + * @param {string} clientId Client ID of block under cursor in multi-select + * drag. + */ + + }, { + key: "onSelectionChange", + value: function onSelectionChange(clientId) { + var _this$props = this.props, + onMultiSelect = _this$props.onMultiSelect, + selectionStart = _this$props.selectionStart, + selectionEnd = _this$props.selectionEnd; + var selectionAtStart = this.selectionAtStart; + var isAtStart = selectionAtStart === clientId; + + if (!selectionAtStart || !this.props.isSelectionEnabled) { + return; + } // If multi-selecting and cursor extent returns to the start of + // selection, cancel multi-select. + + + if (isAtStart && selectionStart) { + onMultiSelect(null, null); + } // Expand multi-selection to block under cursor. + + + if (!isAtStart && selectionEnd !== clientId) { + onMultiSelect(selectionAtStart, clientId); + } + } + /** + * Handles a mouseup event to end the current cursor multi-selection. + */ + + }, { + key: "onSelectionEnd", + value: function onSelectionEnd() { + // Cancel throttled calls. + this.onPointerMove.cancel(); + delete this.coordMap; + delete this.coordMapKeys; + delete this.selectionAtStart; + window.removeEventListener('mousemove', this.onPointerMove); + window.removeEventListener('scroll', this.onScroll, true); + window.removeEventListener('mouseup', this.onSelectionEnd); // We may or may not be in a multi-selection when mouseup occurs (e.g. + // an in-place mouse click), so only trigger stop if multi-selecting. + + if (this.props.isMultiSelecting) { + this.props.onStopMultiSelect(); + } + } + }, { + key: "render", + value: function render() { + var _this2 = this; + + var _this$props2 = this.props, + className = _this$props2.className, + blockClientIds = _this$props2.blockClientIds, + rootClientId = _this$props2.rootClientId, + isDraggable = _this$props2.isDraggable, + selectedBlockClientId = _this$props2.selectedBlockClientId, + multiSelectedBlockClientIds = _this$props2.multiSelectedBlockClientIds, + hasMultiSelection = _this$props2.hasMultiSelection, + renderAppender = _this$props2.renderAppender, + enableAnimation = _this$props2.enableAnimation; + return Object(external_this_wp_element_["createElement"])("div", { + className: classnames_default()('editor-block-list__layout block-editor-block-list__layout', className) + }, blockClientIds.map(function (clientId, index) { + var isBlockInSelection = hasMultiSelection ? multiSelectedBlockClientIds.includes(clientId) : selectedBlockClientId === clientId; + return Object(external_this_wp_element_["createElement"])(block_async_mode_provider, { + key: 'block-' + clientId, + clientId: clientId, + isBlockInSelection: isBlockInSelection + }, Object(external_this_wp_element_["createElement"])(block_list_block, { + rootClientId: rootClientId, + clientId: clientId, + blockRef: _this2.setBlockRef, + onSelectionStart: _this2.onSelectionStart, + isDraggable: isDraggable // This prop is explicitely computed and passed down + // to avoid being impacted by the async mode + // otherwise there might be a small delay to trigger the animation. + , + animateOnChange: index, + enableAnimation: enableAnimation + })); + }), Object(external_this_wp_element_["createElement"])(block_list_appender, { + rootClientId: rootClientId, + renderAppender: renderAppender + })); + } + }]); + + return BlockList; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var block_list = (Object(external_this_wp_compose_["compose"])([// This component needs to always be synchronous +// as it's the one changing the async mode +// depending on the block selection. +block_list_forceSyncUpdates, Object(external_this_wp_data_["withSelect"])(function (select, ownProps) { + var _select = select('core/block-editor'), + getBlockOrder = _select.getBlockOrder, + isSelectionEnabled = _select.isSelectionEnabled, + isMultiSelecting = _select.isMultiSelecting, + getMultiSelectedBlocksStartClientId = _select.getMultiSelectedBlocksStartClientId, + getMultiSelectedBlocksEndClientId = _select.getMultiSelectedBlocksEndClientId, + getSelectedBlockClientId = _select.getSelectedBlockClientId, + getMultiSelectedBlockClientIds = _select.getMultiSelectedBlockClientIds, + hasMultiSelection = _select.hasMultiSelection, + getGlobalBlockCount = _select.getGlobalBlockCount, + isTyping = _select.isTyping; + + var rootClientId = ownProps.rootClientId; + return { + blockClientIds: getBlockOrder(rootClientId), + selectionStart: getMultiSelectedBlocksStartClientId(), + selectionEnd: getMultiSelectedBlocksEndClientId(), + isSelectionEnabled: isSelectionEnabled(), + isMultiSelecting: isMultiSelecting(), + selectedBlockClientId: getSelectedBlockClientId(), + multiSelectedBlockClientIds: getMultiSelectedBlockClientIds(), + hasMultiSelection: hasMultiSelection(), + enableAnimation: !isTyping() && getGlobalBlockCount() <= BLOCK_ANIMATION_THRESHOLD + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/block-editor'), + startMultiSelect = _dispatch.startMultiSelect, + stopMultiSelect = _dispatch.stopMultiSelect, + multiSelect = _dispatch.multiSelect; + + return { + onStartMultiSelect: startMultiSelect, + onStopMultiSelect: stopMultiSelect, + onMultiSelect: multiSelect + }; +})])(block_list_BlockList)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-preview/index.js + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + + + + +function ScaledBlockPreview(_ref) { + var blocks = _ref.blocks, + viewportWidth = _ref.viewportWidth, + _ref$padding = _ref.padding, + padding = _ref$padding === void 0 ? 0 : _ref$padding; + var previewRef = Object(external_this_wp_element_["useRef"])(null); + + var _useState = Object(external_this_wp_element_["useState"])(false), + _useState2 = Object(slicedToArray["a" /* default */])(_useState, 2), + isReady = _useState2[0], + setIsReady = _useState2[1]; + + var _useState3 = Object(external_this_wp_element_["useState"])(1), + _useState4 = Object(slicedToArray["a" /* default */])(_useState3, 2), + previewScale = _useState4[0], + setPreviewScale = _useState4[1]; + + var _useState5 = Object(external_this_wp_element_["useState"])({ + x: 0, + y: 0 + }), + _useState6 = Object(slicedToArray["a" /* default */])(_useState5, 2), + _useState6$ = _useState6[0], + x = _useState6$.x, + y = _useState6$.y, + setPosition = _useState6[1]; // Dynamically calculate the scale factor + + + Object(external_this_wp_element_["useLayoutEffect"])(function () { + // Timer - required to account for async render of `BlockEditorProvider` + var timerId = setTimeout(function () { + var containerElement = previewRef.current; + + if (!containerElement) { + return; + } // If we're previewing a single block, scale the preview to fit it. + + + if (blocks.length === 1) { + var block = blocks[0]; + var previewElement = getBlockPreviewContainerDOMNode(block.clientId, containerElement); + + if (!previewElement) { + return; + } + + var containerElementRect = containerElement.getBoundingClientRect(); + containerElementRect = { + width: containerElementRect.width - padding * 2, + height: containerElementRect.height - padding * 2, + left: containerElementRect.left, + top: containerElementRect.top + }; + var scaledElementRect = previewElement.getBoundingClientRect(); + var scale = containerElementRect.width / scaledElementRect.width || 1; + var offsetX = -(scaledElementRect.left - containerElementRect.left) * scale + padding; + var offsetY = containerElementRect.height > scaledElementRect.height * scale ? (containerElementRect.height - scaledElementRect.height * scale) / 2 + padding : 0; + setPreviewScale(scale); + setPosition({ + x: offsetX, + y: offsetY + }); // Hack: we need to reset the scaled elements margins + + previewElement.style.marginTop = '0'; + } else { + var _containerElementRect = containerElement.getBoundingClientRect(); + + setPreviewScale(_containerElementRect.width / viewportWidth); + } + + setIsReady(true); + }, 100); // Cleanup + + return function () { + if (timerId) { + window.clearTimeout(timerId); + } + }; + }, []); + + if (!blocks || blocks.length === 0) { + return null; + } + + var previewStyles = { + transform: "scale(".concat(previewScale, ")"), + visibility: isReady ? 'visible' : 'hidden', + left: x, + top: y, + width: viewportWidth + }; + return Object(external_this_wp_element_["createElement"])("div", { + ref: previewRef, + className: classnames_default()('block-editor-block-preview__container editor-styles-wrapper', { + 'is-ready': isReady + }), + "aria-hidden": true + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Disabled"], { + style: previewStyles, + className: "block-editor-block-preview__content" + }, Object(external_this_wp_element_["createElement"])(block_list, null))); +} + +function BlockPreview(_ref2) { + var blocks = _ref2.blocks, + _ref2$viewportWidth = _ref2.viewportWidth, + viewportWidth = _ref2$viewportWidth === void 0 ? 700 : _ref2$viewportWidth, + padding = _ref2.padding, + settings = _ref2.settings; + var renderedBlocks = Object(external_this_wp_element_["useMemo"])(function () { + return Object(external_lodash_["castArray"])(blocks); + }, [blocks]); + + var _useReducer = Object(external_this_wp_element_["useReducer"])(function (state) { + return state + 1; + }, 0), + _useReducer2 = Object(slicedToArray["a" /* default */])(_useReducer, 2), + recompute = _useReducer2[0], + triggerRecompute = _useReducer2[1]; + + Object(external_this_wp_element_["useLayoutEffect"])(triggerRecompute, [blocks]); + return Object(external_this_wp_element_["createElement"])(provider, { + value: renderedBlocks, + settings: settings + }, Object(external_this_wp_element_["createElement"])(ScaledBlockPreview, { + key: recompute, + blocks: renderedBlocks, + viewportWidth: viewportWidth, + padding: padding + })); +} +/** + * BlockPreview renders a preview of a block or array of blocks. + * + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/block-preview/README.md + * + * @param {Array|Object} blocks A block instance (object) or an array of blocks to be previewed. + * @param {number} viewportWidth Width of the preview container in pixels. Controls at what size the blocks will be rendered inside the preview. Default: 700. + * @return {WPElement} Rendered element. + */ + +/* harmony default export */ var block_preview = (Object(external_this_wp_data_["withSelect"])(function (select) { + return { + settings: select('core/block-editor').getSettings() + }; +})(BlockPreview)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inserter-list-item/index.js + + + + +/** + * External dependencies + */ + +/** + * Internal dependencies + */ + + + +function InserterListItem(_ref) { + var icon = _ref.icon, + _onClick = _ref.onClick, + isDisabled = _ref.isDisabled, + title = _ref.title, + className = _ref.className, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["icon", "onClick", "isDisabled", "title", "className"]); + + var itemIconStyle = icon ? { + backgroundColor: icon.background, + color: icon.foreground + } : {}; + return Object(external_this_wp_element_["createElement"])("li", { + className: "editor-block-types-list__list-item block-editor-block-types-list__list-item" + }, Object(external_this_wp_element_["createElement"])("button", Object(esm_extends["a" /* default */])({ + className: classnames_default()('editor-block-types-list__item block-editor-block-types-list__item', className), + onClick: function onClick(event) { + event.preventDefault(); + + _onClick(); + }, + disabled: isDisabled + }, props), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-block-types-list__item-icon block-editor-block-types-list__item-icon", + style: itemIconStyle + }, Object(external_this_wp_element_["createElement"])(BlockIcon, { + icon: icon, + showColors: true + })), Object(external_this_wp_element_["createElement"])("span", { + className: "editor-block-types-list__item-title block-editor-block-types-list__item-title" + }, title))); +} + +/* harmony default export */ var inserter_list_item = (InserterListItem); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-types-list/index.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + +function BlockTypesList(_ref) { + var items = _ref.items, + onSelect = _ref.onSelect, + _ref$onHover = _ref.onHover, + onHover = _ref$onHover === void 0 ? function () {} : _ref$onHover, + children = _ref.children; + return ( + /* + * Disable reason: The `list` ARIA role is redundant but + * Safari+VoiceOver won't announce the list otherwise. + */ + + /* eslint-disable jsx-a11y/no-redundant-roles */ + Object(external_this_wp_element_["createElement"])("ul", { + role: "list", + className: "editor-block-types-list block-editor-block-types-list" + }, items && items.map(function (item) { + return Object(external_this_wp_element_["createElement"])(inserter_list_item, { + key: item.id, + className: Object(external_this_wp_blocks_["getBlockMenuDefaultClassName"])(item.id), + icon: item.icon, + onClick: function onClick() { + onSelect(item); + onHover(null); + }, + onFocus: function onFocus() { + return onHover(item); + }, + onMouseEnter: function onMouseEnter() { + return onHover(item); + }, + onMouseLeave: function onMouseLeave() { + return onHover(null); + }, + onBlur: function onBlur() { + return onHover(null); + }, + isDisabled: item.isDisabled, + title: item.title + }); + }), children) + /* eslint-enable jsx-a11y/no-redundant-roles */ + + ); +} + +/* harmony default export */ var block_types_list = (BlockTypesList); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-card/index.js + + +/** + * Internal dependencies + */ + + +function BlockCard(_ref) { + var blockType = _ref.blockType; + return Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-block-card" + }, Object(external_this_wp_element_["createElement"])(BlockIcon, { + icon: blockType.icon, + showColors: true + }), Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-block-card__content" + }, Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-block-card__title" + }, blockType.title), Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-block-card__description" + }, blockType.description))); +} + +/* harmony default export */ var block_card = (BlockCard); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inserter/child-blocks.js + + + + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + + + +function ChildBlocks(_ref) { + var rootBlockIcon = _ref.rootBlockIcon, + rootBlockTitle = _ref.rootBlockTitle, + items = _ref.items, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["rootBlockIcon", "rootBlockTitle", "items"]); + + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-inserter__child-blocks block-editor-inserter__child-blocks" + }, (rootBlockIcon || rootBlockTitle) && Object(external_this_wp_element_["createElement"])("div", { + className: "editor-inserter__parent-block-header block-editor-inserter__parent-block-header" + }, Object(external_this_wp_element_["createElement"])(BlockIcon, { + icon: rootBlockIcon, + showColors: true + }), rootBlockTitle && Object(external_this_wp_element_["createElement"])("h2", null, rootBlockTitle)), Object(external_this_wp_element_["createElement"])(block_types_list, Object(esm_extends["a" /* default */])({ + items: items + }, props))); +} + +/* harmony default export */ var child_blocks = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_compose_["ifCondition"])(function (_ref2) { + var items = _ref2.items; + return items && items.length > 0; +}), Object(external_this_wp_data_["withSelect"])(function (select, _ref3) { + var rootClientId = _ref3.rootClientId; + + var _select = select('core/blocks'), + getBlockType = _select.getBlockType; + + var _select2 = select('core/block-editor'), + getBlockName = _select2.getBlockName; + + var rootBlockName = getBlockName(rootClientId); + var rootBlockType = getBlockType(rootBlockName); + return { + rootBlockTitle: rootBlockType && rootBlockType.title, + rootBlockIcon: rootBlockType && rootBlockType.icon + }; +}))(ChildBlocks)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inserter-menu-extension/index.js +/** + * WordPress dependencies + */ + + +var inserter_menu_extension_createSlotFill = Object(external_this_wp_components_["createSlotFill"])('__experimentalInserterMenuExtension'), + __experimentalInserterMenuExtension = inserter_menu_extension_createSlotFill.Fill, + inserter_menu_extension_Slot = inserter_menu_extension_createSlotFill.Slot; + +__experimentalInserterMenuExtension.Slot = inserter_menu_extension_Slot; +/* harmony default export */ var inserter_menu_extension = (__experimentalInserterMenuExtension); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inserter/menu.js + + + + + + + + + +/** + * External dependencies + */ + + + +/** + * WordPress dependencies + */ + + + + + + + + + +/** + * Internal dependencies + */ + + + + + + +var MAX_SUGGESTED_ITEMS = 9; + +var stopKeyPropagation = function stopKeyPropagation(event) { + return event.stopPropagation(); +}; +/** + * Filters an item list given a search term. + * + * @param {Array} items Item list + * @param {string} searchTerm Search term. + * + * @return {Array} Filtered item list. + */ + + +var menu_searchItems = function searchItems(items, searchTerm) { + var normalizedSearchTerm = menu_normalizeTerm(searchTerm); + + var matchSearch = function matchSearch(string) { + return menu_normalizeTerm(string).indexOf(normalizedSearchTerm) !== -1; + }; + + var categories = Object(external_this_wp_blocks_["getCategories"])(); + return items.filter(function (item) { + var itemCategory = Object(external_lodash_["find"])(categories, { + slug: item.category + }); + return matchSearch(item.title) || Object(external_lodash_["some"])(item.keywords, matchSearch) || itemCategory && matchSearch(itemCategory.title); + }); +}; +/** + * Converts the search term into a normalized term. + * + * @param {string} term The search term to normalize. + * + * @return {string} The normalized search term. + */ + +var menu_normalizeTerm = function normalizeTerm(term) { + // Disregard diacritics. + // Input: "média" + term = Object(external_lodash_["deburr"])(term); // Accommodate leading slash, matching autocomplete expectations. + // Input: "/media" + + term = term.replace(/^\//, ''); // Lowercase. + // Input: "MEDIA" + + term = term.toLowerCase(); // Strip leading and trailing whitespace. + // Input: " media " + + term = term.trim(); + return term; +}; +var menu_InserterMenu = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(InserterMenu, _Component); + + function InserterMenu() { + var _this; + + Object(classCallCheck["a" /* default */])(this, InserterMenu); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(InserterMenu).apply(this, arguments)); + _this.state = { + childItems: [], + filterValue: '', + hoveredItem: null, + suggestedItems: [], + reusableItems: [], + itemsPerCategory: {}, + openPanels: ['suggested'] + }; + _this.onChangeSearchInput = _this.onChangeSearchInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onHover = _this.onHover.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.panels = {}; + _this.inserterResults = Object(external_this_wp_element_["createRef"])(); + return _this; + } + + Object(createClass["a" /* default */])(InserterMenu, [{ + key: "componentDidMount", + value: function componentDidMount() { + // This could be replaced by a resolver. + this.props.fetchReusableBlocks(); + this.filter(); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + if (prevProps.items !== this.props.items) { + this.filter(this.state.filterValue); + } + } + }, { + key: "onChangeSearchInput", + value: function onChangeSearchInput(event) { + this.filter(event.target.value); + } + }, { + key: "onHover", + value: function onHover(item) { + this.setState({ + hoveredItem: item + }); + var _this$props = this.props, + showInsertionPoint = _this$props.showInsertionPoint, + hideInsertionPoint = _this$props.hideInsertionPoint; + + if (item) { + showInsertionPoint(); + } else { + hideInsertionPoint(); + } + } + }, { + key: "bindPanel", + value: function bindPanel(name) { + var _this2 = this; + + return function (ref) { + _this2.panels[name] = ref; + }; + } + }, { + key: "onTogglePanel", + value: function onTogglePanel(panel) { + var _this3 = this; + + return function () { + var isOpened = _this3.state.openPanels.indexOf(panel) !== -1; + + if (isOpened) { + _this3.setState({ + openPanels: Object(external_lodash_["without"])(_this3.state.openPanels, panel) + }); + } else { + _this3.setState({ + openPanels: [].concat(Object(toConsumableArray["a" /* default */])(_this3.state.openPanels), [panel]) + }); + + _this3.props.setTimeout(function () { + // We need a generic way to access the panel's container + lib_default()(_this3.panels[panel], _this3.inserterResults.current, { + alignWithTop: true + }); + }); + } + }; + } + }, { + key: "filterOpenPanels", + value: function filterOpenPanels(filterValue, itemsPerCategory, filteredItems, reusableItems) { + if (filterValue === this.state.filterValue) { + return this.state.openPanels; + } + + if (!filterValue) { + return ['suggested']; + } + + var openPanels = []; + + if (reusableItems.length > 0) { + openPanels.push('reusable'); + } + + if (filteredItems.length > 0) { + openPanels = openPanels.concat(Object.keys(itemsPerCategory)); + } + + return openPanels; + } + }, { + key: "filter", + value: function filter() { + var filterValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + var _this$props2 = this.props, + debouncedSpeak = _this$props2.debouncedSpeak, + items = _this$props2.items, + rootChildBlocks = _this$props2.rootChildBlocks; + var filteredItems = menu_searchItems(items, filterValue); + + var childItems = Object(external_lodash_["filter"])(filteredItems, function (_ref) { + var name = _ref.name; + return Object(external_lodash_["includes"])(rootChildBlocks, name); + }); + + var suggestedItems = []; + + if (!filterValue) { + var maxSuggestedItems = this.props.maxSuggestedItems || MAX_SUGGESTED_ITEMS; + suggestedItems = Object(external_lodash_["filter"])(items, function (item) { + return item.utility > 0; + }).slice(0, maxSuggestedItems); + } + + var reusableItems = Object(external_lodash_["filter"])(filteredItems, { + category: 'reusable' + }); + + var getCategoryIndex = function getCategoryIndex(item) { + return Object(external_lodash_["findIndex"])(Object(external_this_wp_blocks_["getCategories"])(), function (category) { + return category.slug === item.category; + }); + }; + + var itemsPerCategory = Object(external_lodash_["flow"])(function (itemList) { + return Object(external_lodash_["filter"])(itemList, function (item) { + return item.category !== 'reusable'; + }); + }, function (itemList) { + return Object(external_lodash_["sortBy"])(itemList, getCategoryIndex); + }, function (itemList) { + return Object(external_lodash_["groupBy"])(itemList, 'category'); + })(filteredItems); + this.setState({ + hoveredItem: null, + childItems: childItems, + filterValue: filterValue, + suggestedItems: suggestedItems, + reusableItems: reusableItems, + itemsPerCategory: itemsPerCategory, + openPanels: this.filterOpenPanels(filterValue, itemsPerCategory, filteredItems, reusableItems) + }); + var resultCount = Object.keys(itemsPerCategory).reduce(function (accumulator, currentCategorySlug) { + return accumulator + itemsPerCategory[currentCategorySlug].length; + }, 0); + var resultsFoundMessage = Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('%d result found.', '%d results found.', resultCount), resultCount); + debouncedSpeak(resultsFoundMessage); + } + }, { + key: "onKeyDown", + value: function onKeyDown(event) { + if (Object(external_lodash_["includes"])([external_this_wp_keycodes_["LEFT"], external_this_wp_keycodes_["DOWN"], external_this_wp_keycodes_["RIGHT"], external_this_wp_keycodes_["UP"], external_this_wp_keycodes_["BACKSPACE"], external_this_wp_keycodes_["ENTER"]], event.keyCode)) { + // Stop the key event from propagating up to ObserveTyping.startTypingInTextField. + event.stopPropagation(); + } + } + }, { + key: "render", + value: function render() { + var _this4 = this; + + var _this$props3 = this.props, + instanceId = _this$props3.instanceId, + onSelect = _this$props3.onSelect, + rootClientId = _this$props3.rootClientId, + showInserterHelpPanel = _this$props3.showInserterHelpPanel; + var _this$state = this.state, + childItems = _this$state.childItems, + hoveredItem = _this$state.hoveredItem, + itemsPerCategory = _this$state.itemsPerCategory, + openPanels = _this$state.openPanels, + reusableItems = _this$state.reusableItems, + suggestedItems = _this$state.suggestedItems, + filterValue = _this$state.filterValue; + + var isPanelOpen = function isPanelOpen(panel) { + return openPanels.indexOf(panel) !== -1; + }; + + var hasItems = !Object(external_lodash_["isEmpty"])(suggestedItems) || !Object(external_lodash_["isEmpty"])(reusableItems) || !Object(external_lodash_["isEmpty"])(itemsPerCategory); + var hoveredItemBlockType = hoveredItem ? Object(external_this_wp_blocks_["getBlockType"])(hoveredItem.name) : null; + var hasHelpPanel = hasItems && showInserterHelpPanel; // Disable reason (no-autofocus): The inserter menu is a modal display, not one which + // is always visible, and one which already incurs this behavior of autoFocus via + // Popover's focusOnMount. + // Disable reason (no-static-element-interactions): Navigational key-presses within + // the menu are prevented from triggering WritingFlow and ObserveTyping interactions. + + /* eslint-disable jsx-a11y/no-autofocus, jsx-a11y/no-static-element-interactions */ + + return Object(external_this_wp_element_["createElement"])("div", { + className: classnames_default()('editor-inserter__menu block-editor-inserter__menu', { + 'has-help-panel': hasHelpPanel + }), + onKeyPress: stopKeyPropagation, + onKeyDown: this.onKeyDown + }, Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-inserter__main-area" + }, Object(external_this_wp_element_["createElement"])("label", { + htmlFor: "block-editor-inserter__search-".concat(instanceId), + className: "screen-reader-text" + }, Object(external_this_wp_i18n_["__"])('Search for a block')), Object(external_this_wp_element_["createElement"])("input", { + id: "block-editor-inserter__search-".concat(instanceId), + type: "search", + placeholder: Object(external_this_wp_i18n_["__"])('Search for a block'), + className: "editor-inserter__search block-editor-inserter__search", + autoFocus: true, + onChange: this.onChangeSearchInput + }), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-inserter__results block-editor-inserter__results", + ref: this.inserterResults, + tabIndex: "0", + role: "region", + "aria-label": Object(external_this_wp_i18n_["__"])('Available block types') + }, Object(external_this_wp_element_["createElement"])(child_blocks, { + rootClientId: rootClientId, + items: childItems, + onSelect: onSelect, + onHover: this.onHover + }), !!suggestedItems.length && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + title: Object(external_this_wp_i18n_["_x"])('Most Used', 'blocks'), + opened: isPanelOpen('suggested'), + onToggle: this.onTogglePanel('suggested'), + ref: this.bindPanel('suggested') + }, Object(external_this_wp_element_["createElement"])(block_types_list, { + items: suggestedItems, + onSelect: onSelect, + onHover: this.onHover + })), Object(external_lodash_["map"])(Object(external_this_wp_blocks_["getCategories"])(), function (category) { + var categoryItems = itemsPerCategory[category.slug]; + + if (!categoryItems || !categoryItems.length) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + key: category.slug, + title: category.title, + icon: category.icon, + opened: isPanelOpen(category.slug), + onToggle: _this4.onTogglePanel(category.slug), + ref: _this4.bindPanel(category.slug) + }, Object(external_this_wp_element_["createElement"])(block_types_list, { + items: categoryItems, + onSelect: onSelect, + onHover: _this4.onHover + })); + }), !!reusableItems.length && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + className: "editor-inserter__reusable-blocks-panel block-editor-inserter__reusable-blocks-panel", + title: Object(external_this_wp_i18n_["__"])('Reusable'), + opened: isPanelOpen('reusable'), + onToggle: this.onTogglePanel('reusable'), + icon: "controls-repeat", + ref: this.bindPanel('reusable') + }, Object(external_this_wp_element_["createElement"])(block_types_list, { + items: reusableItems, + onSelect: onSelect, + onHover: this.onHover + }), Object(external_this_wp_element_["createElement"])("a", { + className: "editor-inserter__manage-reusable-blocks block-editor-inserter__manage-reusable-blocks", + href: Object(external_this_wp_url_["addQueryArgs"])('edit.php', { + post_type: 'wp_block' + }) + }, Object(external_this_wp_i18n_["__"])('Manage All Reusable Blocks'))), Object(external_this_wp_element_["createElement"])(inserter_menu_extension.Slot, { + fillProps: { + onSelect: onSelect, + onHover: this.onHover, + filterValue: filterValue, + hasItems: hasItems + } + }, function (fills) { + if (fills.length) { + return fills; + } + + if (!hasItems) { + return Object(external_this_wp_element_["createElement"])("p", { + className: "editor-inserter__no-results block-editor-inserter__no-results" + }, Object(external_this_wp_i18n_["__"])('No blocks found.')); + } + + return null; + }))), hasHelpPanel && Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-inserter__menu-help-panel" + }, hoveredItem && Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, !Object(external_this_wp_blocks_["isReusableBlock"])(hoveredItem) && Object(external_this_wp_element_["createElement"])(block_card, { + blockType: hoveredItemBlockType + }), Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-inserter__preview" + }, Object(external_this_wp_blocks_["isReusableBlock"])(hoveredItem) || hoveredItemBlockType.example ? Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-inserter__preview-content" + }, Object(external_this_wp_element_["createElement"])(block_preview, { + padding: 10, + viewportWidth: 500, + blocks: hoveredItemBlockType.example ? Object(external_this_wp_blocks_["getBlockFromExample"])(hoveredItem.name, hoveredItemBlockType.example) : Object(external_this_wp_blocks_["createBlock"])(hoveredItem.name, hoveredItem.initialAttributes) + })) : Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-inserter__preview-content-missing" + }, Object(external_this_wp_i18n_["__"])('No Preview Available.')))), !hoveredItem && Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-inserter__menu-help-panel-no-block" + }, Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-inserter__menu-help-panel-no-block-text" + }, Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-inserter__menu-help-panel-title" + }, Object(external_this_wp_i18n_["__"])('Content Blocks')), Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_i18n_["__"])('Welcome to the wonderful world of blocks! Blocks are the basis of all content within the editor.')), Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_i18n_["__"])('There are blocks available for all kinds of content: insert text, headings, images, lists, videos, tables, and lots more.')), Object(external_this_wp_element_["createElement"])("p", null, Object(external_this_wp_i18n_["__"])('Browse through the library to learn more about what each block does.'))), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Tip"], null, Object(external_this_wp_i18n_["__"])('While writing, you can press "/" to quickly insert new blocks.'))))); + /* eslint-enable jsx-a11y/no-autofocus, jsx-a11y/no-static-element-interactions */ + } + }]); + + return InserterMenu; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var menu = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { + var clientId = _ref2.clientId, + isAppender = _ref2.isAppender, + rootClientId = _ref2.rootClientId, + showInserterHelpPanel = _ref2.showInserterHelpPanel; + + var _select = select('core/block-editor'), + getInserterItems = _select.getInserterItems, + getBlockName = _select.getBlockName, + getBlockRootClientId = _select.getBlockRootClientId, + getBlockSelectionEnd = _select.getBlockSelectionEnd, + getSettings = _select.getSettings; + + var _select2 = select('core/blocks'), + getChildBlockNames = _select2.getChildBlockNames; + + var destinationRootClientId = rootClientId; + + if (!destinationRootClientId && !clientId && !isAppender) { + var end = getBlockSelectionEnd(); + + if (end) { + destinationRootClientId = getBlockRootClientId(end) || undefined; + } + } + + var destinationRootBlockName = getBlockName(destinationRootClientId); + return { + rootChildBlocks: getChildBlockNames(destinationRootBlockName), + items: getInserterItems(destinationRootClientId), + showInserterHelpPanel: showInserterHelpPanel && getSettings().showInserterHelpPanel, + destinationRootClientId: destinationRootClientId + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, ownProps, _ref3) { + var select = _ref3.select; + + var _dispatch = dispatch('core/block-editor'), + _showInsertionPoint = _dispatch.showInsertionPoint, + hideInsertionPoint = _dispatch.hideInsertionPoint; // This should be an external action provided in the editor settings. + + + var _dispatch2 = dispatch('core/editor'), + fetchReusableBlocks = _dispatch2.__experimentalFetchReusableBlocks; // To avoid duplication, getInsertionIndex is extracted and used in two event handlers + // This breaks the withDispatch not containing any logic rule. + // Since it's a function only called when the event handlers are called, + // it's fine to extract it. + // eslint-disable-next-line no-restricted-syntax + + + function getInsertionIndex() { + var _select3 = select('core/block-editor'), + getBlockIndex = _select3.getBlockIndex, + getBlockSelectionEnd = _select3.getBlockSelectionEnd, + getBlockOrder = _select3.getBlockOrder; + + var clientId = ownProps.clientId, + destinationRootClientId = ownProps.destinationRootClientId, + isAppender = ownProps.isAppender; // If the clientId is defined, we insert at the position of the block. + + if (clientId) { + return getBlockIndex(clientId, destinationRootClientId); + } // If there a selected block, we insert after the selected block. + + + var end = getBlockSelectionEnd(); + + if (!isAppender && end) { + return getBlockIndex(end, destinationRootClientId) + 1; + } // Otherwise, we insert at the end of the current rootClientId + + + return getBlockOrder(destinationRootClientId).length; + } + + return { + fetchReusableBlocks: fetchReusableBlocks, + showInsertionPoint: function showInsertionPoint() { + var index = getInsertionIndex(); + + _showInsertionPoint(ownProps.destinationRootClientId, index); + }, + hideInsertionPoint: hideInsertionPoint, + onSelect: function onSelect(item) { + var _dispatch3 = dispatch('core/block-editor'), + replaceBlocks = _dispatch3.replaceBlocks, + insertBlock = _dispatch3.insertBlock; + + var _select4 = select('core/block-editor'), + getSelectedBlock = _select4.getSelectedBlock; + + var isAppender = ownProps.isAppender; + var name = item.name, + initialAttributes = item.initialAttributes; + var selectedBlock = getSelectedBlock(); + var insertedBlock = Object(external_this_wp_blocks_["createBlock"])(name, initialAttributes); + + if (!isAppender && selectedBlock && Object(external_this_wp_blocks_["isUnmodifiedDefaultBlock"])(selectedBlock)) { + replaceBlocks(selectedBlock.clientId, insertedBlock); + } else { + insertBlock(insertedBlock, getInsertionIndex(), ownProps.destinationRootClientId); + } + + ownProps.onSelect(); + return insertedBlock; + } + }; +}), external_this_wp_components_["withSpokenMessages"], external_this_wp_compose_["withInstanceId"], external_this_wp_compose_["withSafeTimeout"])(menu_InserterMenu)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inserter/index.js + + + + + + + + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + + +var inserter_defaultRenderToggle = function defaultRenderToggle(_ref) { + var onToggle = _ref.onToggle, + disabled = _ref.disabled, + isOpen = _ref.isOpen; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + icon: "insert", + label: Object(external_this_wp_i18n_["__"])('Add block'), + labelPosition: "bottom", + onClick: onToggle, + className: "editor-inserter__toggle block-editor-inserter__toggle", + "aria-haspopup": "true", + "aria-expanded": isOpen, + disabled: disabled + }); +}; + +var inserter_Inserter = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(Inserter, _Component); + + function Inserter() { + var _this; + + Object(classCallCheck["a" /* default */])(this, Inserter); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Inserter).apply(this, arguments)); + _this.onToggle = _this.onToggle.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.renderToggle = _this.renderToggle.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.renderContent = _this.renderContent.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(Inserter, [{ + key: "onToggle", + value: function onToggle(isOpen) { + var onToggle = this.props.onToggle; // Surface toggle callback to parent component + + if (onToggle) { + onToggle(isOpen); + } + } + /** + * Render callback to display Dropdown toggle element. + * + * @param {Object} options + * @param {Function} options.onToggle Callback to invoke when toggle is + * pressed. + * @param {boolean} options.isOpen Whether dropdown is currently open. + * + * @return {WPElement} Dropdown toggle element. + */ + + }, { + key: "renderToggle", + value: function renderToggle(_ref2) { + var onToggle = _ref2.onToggle, + isOpen = _ref2.isOpen; + var _this$props = this.props, + disabled = _this$props.disabled, + _this$props$renderTog = _this$props.renderToggle, + renderToggle = _this$props$renderTog === void 0 ? inserter_defaultRenderToggle : _this$props$renderTog; + return renderToggle({ + onToggle: onToggle, + isOpen: isOpen, + disabled: disabled + }); + } + /** + * Render callback to display Dropdown content element. + * + * @param {Object} options + * @param {Function} options.onClose Callback to invoke when dropdown is + * closed. + * + * @return {WPElement} Dropdown content element. + */ + + }, { + key: "renderContent", + value: function renderContent(_ref3) { + var onClose = _ref3.onClose; + var _this$props2 = this.props, + rootClientId = _this$props2.rootClientId, + clientId = _this$props2.clientId, + isAppender = _this$props2.isAppender, + showInserterHelpPanel = _this$props2.showInserterHelpPanel; + return Object(external_this_wp_element_["createElement"])(menu, { + onSelect: onClose, + rootClientId: rootClientId, + clientId: clientId, + isAppender: isAppender, + showInserterHelpPanel: showInserterHelpPanel + }); + } + }, { + key: "render", + value: function render() { + var position = this.props.position; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Dropdown"], { + className: "editor-inserter block-editor-inserter", + contentClassName: "editor-inserter__popover block-editor-inserter__popover", + position: position, + onToggle: this.onToggle, + expandOnMobile: true, + headerTitle: Object(external_this_wp_i18n_["__"])('Add a block'), + renderToggle: this.renderToggle, + renderContent: this.renderContent + }); + } + }]); + + return Inserter; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var inserter = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, _ref4) { + var rootClientId = _ref4.rootClientId; + + var _select = select('core/block-editor'), + hasInserterItems = _select.hasInserterItems; + + return { + hasItems: hasInserterItems(rootClientId) + }; +}), Object(external_this_wp_compose_["ifCondition"])(function (_ref5) { + var hasItems = _ref5.hasItems; + return hasItems; +})])(inserter_Inserter)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/button-block-appender/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + +function button_block_appender_ButtonBlockAppender(_ref) { + var rootClientId = _ref.rootClientId, + className = _ref.className; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(block_drop_zone, { + rootClientId: rootClientId + }), Object(external_this_wp_element_["createElement"])(inserter, { + rootClientId: rootClientId, + renderToggle: function renderToggle(_ref2) { + var onToggle = _ref2.onToggle, + disabled = _ref2.disabled, + isOpen = _ref2.isOpen; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: classnames_default()(className, 'block-editor-button-block-appender'), + onClick: onToggle, + "aria-expanded": isOpen, + disabled: disabled + }, Object(external_this_wp_element_["createElement"])("span", { + className: "screen-reader-text" + }, Object(external_this_wp_i18n_["__"])('Add Block')), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Icon"], { + icon: "insert" + })); + }, + isAppender: true + })); +} +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/button-block-appender/README.md + */ + + +/* harmony default export */ var button_block_appender = (button_block_appender_ButtonBlockAppender); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/color-palette/with-color-context.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/* harmony default export */ var with_color_context = (Object(external_this_wp_compose_["createHigherOrderComponent"])(Object(external_this_wp_data_["withSelect"])(function (select, ownProps) { + var settings = select('core/block-editor').getSettings(); + var colors = ownProps.colors === undefined ? settings.colors : ownProps.colors; + var disableCustomColors = ownProps.disableCustomColors === undefined ? settings.disableCustomColors : ownProps.disableCustomColors; + return { + colors: colors, + disableCustomColors: disableCustomColors, + hasColorsToChoose: !Object(external_lodash_["isEmpty"])(colors) || !disableCustomColors + }; +}), 'withColorContext')); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/color-palette/index.js +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + +/* harmony default export */ var color_palette = (with_color_context(external_this_wp_components_["ColorPalette"])); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/contrast-checker/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +function ContrastCheckerMessage(_ref) { + var tinyBackgroundColor = _ref.tinyBackgroundColor, + tinyTextColor = _ref.tinyTextColor, + backgroundColor = _ref.backgroundColor, + textColor = _ref.textColor; + var msg = tinyBackgroundColor.getBrightness() < tinyTextColor.getBrightness() ? Object(external_this_wp_i18n_["__"])('This color combination may be hard for people to read. Try using a darker background color and/or a brighter text color.') : Object(external_this_wp_i18n_["__"])('This color combination may be hard for people to read. Try using a brighter background color and/or a darker text color.'); + Object(external_this_wp_element_["useEffect"])(function () { + Object(external_this_wp_a11y_["speak"])(Object(external_this_wp_i18n_["__"])('This color combination may be hard for people to read.')); + }, [backgroundColor, textColor]); + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-contrast-checker block-editor-contrast-checker" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Notice"], { + status: "warning", + isDismissible: false + }, msg)); +} + +function ContrastChecker(_ref2) { + var backgroundColor = _ref2.backgroundColor, + fallbackBackgroundColor = _ref2.fallbackBackgroundColor, + fallbackTextColor = _ref2.fallbackTextColor, + fontSize = _ref2.fontSize, + isLargeText = _ref2.isLargeText, + textColor = _ref2.textColor; + + if (!(backgroundColor || fallbackBackgroundColor) || !(textColor || fallbackTextColor)) { + return null; + } + + var tinyBackgroundColor = tinycolor_default()(backgroundColor || fallbackBackgroundColor); + var tinyTextColor = tinycolor_default()(textColor || fallbackTextColor); + var hasTransparency = tinyBackgroundColor.getAlpha() !== 1 || tinyTextColor.getAlpha() !== 1; + + if (hasTransparency || tinycolor_default.a.isReadable(tinyBackgroundColor, tinyTextColor, { + level: 'AA', + size: isLargeText || isLargeText !== false && fontSize >= 24 ? 'large' : 'small' + })) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(ContrastCheckerMessage, { + backgroundColor: backgroundColor, + textColor: textColor, + tinyBackgroundColor: tinyBackgroundColor, + tinyTextColor: tinyTextColor + }); +} + +/* harmony default export */ var contrast_checker = (ContrastChecker); + +// EXTERNAL MODULE: external {"this":["wp","isShallowEqual"]} +var external_this_wp_isShallowEqual_ = __webpack_require__(41); +var external_this_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_isShallowEqual_); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/with-client-id.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + +var withClientId = Object(external_this_wp_compose_["createHigherOrderComponent"])(function (WrappedComponent) { + return context_withBlockEditContext(function (context) { + return Object(external_lodash_["pick"])(context, ['clientId']); + })(WrappedComponent); +}, 'withClientId'); +/* harmony default export */ var with_client_id = (withClientId); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/button-block-appender.js + + +/** + * Internal dependencies + */ + + +var inner_blocks_button_block_appender_ButtonBlockAppender = function ButtonBlockAppender(_ref) { + var clientId = _ref.clientId; + return Object(external_this_wp_element_["createElement"])(button_block_appender, { + rootClientId: clientId + }); +}; +/* harmony default export */ var inner_blocks_button_block_appender = (with_client_id(inner_blocks_button_block_appender_ButtonBlockAppender)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/default-block-appender.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + +var inner_blocks_default_block_appender_DefaultBlockAppender = function DefaultBlockAppender(_ref) { + var clientId = _ref.clientId, + lastBlockClientId = _ref.lastBlockClientId; + return Object(external_this_wp_element_["createElement"])(ignore_nested_events, { + childHandledEvents: ['onFocus', 'onClick', 'onKeyDown'] + }, Object(external_this_wp_element_["createElement"])(default_block_appender, { + rootClientId: clientId, + lastBlockClientId: lastBlockClientId + })); +}; +/* harmony default export */ var inner_blocks_default_block_appender = (Object(external_this_wp_compose_["compose"])([with_client_id, Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { + var clientId = _ref2.clientId; + + var _select = select('core/block-editor'), + getBlockOrder = _select.getBlockOrder; + + var blockClientIds = getBlockOrder(clientId); + return { + lastBlockClientId: Object(external_lodash_["last"])(blockClientIds) + }; +})])(inner_blocks_default_block_appender_DefaultBlockAppender)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/template-picker.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +function InnerBlocksTemplatePicker(_ref) { + var options = _ref.options, + onSelect = _ref.onSelect, + allowSkip = _ref.allowSkip; + var classes = classnames_default()('block-editor-inner-blocks__template-picker', { + 'has-many-options': options.length > 4 + }); + var instructions = allowSkip ? Object(external_this_wp_i18n_["__"])('Select a layout to start with, or make one yourself.') : Object(external_this_wp_i18n_["__"])('Select a layout to start with.'); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Placeholder"], { + icon: "layout", + label: Object(external_this_wp_i18n_["__"])('Choose Layout'), + instructions: instructions, + className: classes + }, Object(external_this_wp_element_["createElement"])("ul", { + className: "block-editor-inner-blocks__template-picker-options", + role: "list" + }, options.map(function (templateOption, index) { + return Object(external_this_wp_element_["createElement"])("li", { + key: index + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + isLarge: true, + icon: templateOption.icon, + onClick: function onClick() { + return onSelect(templateOption.template); + }, + className: "block-editor-inner-blocks__template-picker-option", + label: templateOption.title + })); + })), allowSkip && Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-inner-blocks__template-picker-skip" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isLink: true, + onClick: function onClick() { + return onSelect(undefined); + } + }, Object(external_this_wp_i18n_["__"])('Skip')))); +} + +/* harmony default export */ var template_picker = (InnerBlocksTemplatePicker); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inner-blocks/index.js + + + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + // Temporary click-through disable on desktop. + + + + + + +/** + * Internal dependencies + */ + + + +/** + * Internal dependencies + */ + + + + + +var inner_blocks_InnerBlocks = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(InnerBlocks, _Component); + + function InnerBlocks() { + var _this; + + Object(classCallCheck["a" /* default */])(this, InnerBlocks); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(InnerBlocks).apply(this, arguments)); + _this.state = { + templateInProcess: !!_this.props.template + }; + + _this.updateNestedSettings(); + + return _this; + } + + Object(createClass["a" /* default */])(InnerBlocks, [{ + key: "componentDidMount", + value: function componentDidMount() { + var _this$props = this.props, + templateLock = _this$props.templateLock, + block = _this$props.block; + var innerBlocks = block.innerBlocks; // Only synchronize innerBlocks with template if innerBlocks are empty or a locking all exists directly on the block. + + if (innerBlocks.length === 0 || templateLock === 'all') { + this.synchronizeBlocksWithTemplate(); + } + + if (this.state.templateInProcess) { + this.setState({ + templateInProcess: false + }); + } + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + var _this$props2 = this.props, + template = _this$props2.template, + block = _this$props2.block, + templateLock = _this$props2.templateLock; + var innerBlocks = block.innerBlocks; + this.updateNestedSettings(); // Only synchronize innerBlocks with template if innerBlocks are empty or a locking all exists directly on the block. + + if (innerBlocks.length === 0 || templateLock === 'all') { + var hasTemplateChanged = !Object(external_lodash_["isEqual"])(template, prevProps.template); + + if (hasTemplateChanged) { + this.synchronizeBlocksWithTemplate(); + } + } + } + /** + * Called on mount or when a mismatch exists between the templates and + * inner blocks, synchronizes inner blocks with the template, replacing + * current blocks. + */ + + }, { + key: "synchronizeBlocksWithTemplate", + value: function synchronizeBlocksWithTemplate() { + var _this$props3 = this.props, + template = _this$props3.template, + block = _this$props3.block, + replaceInnerBlocks = _this$props3.replaceInnerBlocks; + var innerBlocks = block.innerBlocks; // Synchronize with templates. If the next set differs, replace. + + var nextBlocks = Object(external_this_wp_blocks_["synchronizeBlocksWithTemplate"])(innerBlocks, template); + + if (!Object(external_lodash_["isEqual"])(nextBlocks, innerBlocks)) { + replaceInnerBlocks(nextBlocks); + } + } + }, { + key: "updateNestedSettings", + value: function updateNestedSettings() { + var _this$props4 = this.props, + blockListSettings = _this$props4.blockListSettings, + allowedBlocks = _this$props4.allowedBlocks, + updateNestedSettings = _this$props4.updateNestedSettings, + templateLock = _this$props4.templateLock, + parentLock = _this$props4.parentLock; + var newSettings = { + allowedBlocks: allowedBlocks, + templateLock: templateLock === undefined ? parentLock : templateLock + }; + + if (!external_this_wp_isShallowEqual_default()(blockListSettings, newSettings)) { + updateNestedSettings(newSettings); + } + } + }, { + key: "render", + value: function render() { + var _this$props5 = this.props, + isSmallScreen = _this$props5.isSmallScreen, + clientId = _this$props5.clientId, + hasOverlay = _this$props5.hasOverlay, + renderAppender = _this$props5.renderAppender, + template = _this$props5.template, + templateOptions = _this$props5.__experimentalTemplateOptions, + onSelectTemplateOption = _this$props5.__experimentalOnSelectTemplateOption, + allowTemplateOptionSkip = _this$props5.__experimentalAllowTemplateOptionSkip; + var templateInProcess = this.state.templateInProcess; + var isPlaceholder = template === null && !!templateOptions; + var classes = classnames_default()('editor-inner-blocks block-editor-inner-blocks', { + 'has-overlay': isSmallScreen && hasOverlay && !isPlaceholder // Temporary click-through disable on desktop. + + }); + return Object(external_this_wp_element_["createElement"])("div", { + className: classes + }, !templateInProcess && (isPlaceholder ? Object(external_this_wp_element_["createElement"])(template_picker, { + options: templateOptions, + onSelect: onSelectTemplateOption, + allowSkip: allowTemplateOptionSkip + }) : Object(external_this_wp_element_["createElement"])(block_list, { + rootClientId: clientId, + renderAppender: renderAppender + }))); + } + }]); + + return InnerBlocks; +}(external_this_wp_element_["Component"]); + +inner_blocks_InnerBlocks = Object(external_this_wp_compose_["compose"])([Object(external_this_wp_viewport_["withViewportMatch"])({ + isSmallScreen: '< medium' +}), // Temporary click-through disable on desktop. +context_withBlockEditContext(function (context) { + return Object(external_lodash_["pick"])(context, ['clientId']); +}), Object(external_this_wp_data_["withSelect"])(function (select, ownProps) { + var _select = select('core/block-editor'), + isBlockSelected = _select.isBlockSelected, + hasSelectedInnerBlock = _select.hasSelectedInnerBlock, + getBlock = _select.getBlock, + getBlockListSettings = _select.getBlockListSettings, + getBlockRootClientId = _select.getBlockRootClientId, + getTemplateLock = _select.getTemplateLock; + + var clientId = ownProps.clientId; + var block = getBlock(clientId); + var rootClientId = getBlockRootClientId(clientId); + return { + block: block, + blockListSettings: getBlockListSettings(clientId), + hasOverlay: block.name !== 'core/template' && !isBlockSelected(clientId) && !hasSelectedInnerBlock(clientId, true), + parentLock: getTemplateLock(rootClientId) + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, ownProps) { + var _dispatch = dispatch('core/block-editor'), + _replaceInnerBlocks = _dispatch.replaceInnerBlocks, + updateBlockListSettings = _dispatch.updateBlockListSettings; + + var block = ownProps.block, + clientId = ownProps.clientId, + _ownProps$templateIns = ownProps.templateInsertUpdatesSelection, + templateInsertUpdatesSelection = _ownProps$templateIns === void 0 ? true : _ownProps$templateIns; + return { + replaceInnerBlocks: function replaceInnerBlocks(blocks) { + _replaceInnerBlocks(clientId, blocks, block.innerBlocks.length === 0 && templateInsertUpdatesSelection); + }, + updateNestedSettings: function updateNestedSettings(settings) { + dispatch(updateBlockListSettings(clientId, settings)); + } + }; +})])(inner_blocks_InnerBlocks); // Expose default appender placeholders as components. + +inner_blocks_InnerBlocks.DefaultBlockAppender = inner_blocks_default_block_appender; +inner_blocks_InnerBlocks.ButtonBlockAppender = inner_blocks_button_block_appender; +inner_blocks_InnerBlocks.Content = Object(external_this_wp_blocks_["withBlockContentContext"])(function (_ref) { + var BlockContent = _ref.BlockContent; + return Object(external_this_wp_element_["createElement"])(BlockContent, null); +}); +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/inner-blocks/README.md + */ + +/* harmony default export */ var inner_blocks = (inner_blocks_InnerBlocks); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inspector-advanced-controls/index.js +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + +var inspector_advanced_controls_createSlotFill = Object(external_this_wp_components_["createSlotFill"])('InspectorAdvancedControls'), + inspector_advanced_controls_Fill = inspector_advanced_controls_createSlotFill.Fill, + inspector_advanced_controls_Slot = inspector_advanced_controls_createSlotFill.Slot; + +var InspectorAdvancedControls = ifBlockEditSelected(inspector_advanced_controls_Fill); +InspectorAdvancedControls.Slot = inspector_advanced_controls_Slot; +/* harmony default export */ var inspector_advanced_controls = (InspectorAdvancedControls); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/inspector-controls/index.js +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + +var inspector_controls_createSlotFill = Object(external_this_wp_components_["createSlotFill"])('InspectorControls'), + inspector_controls_Fill = inspector_controls_createSlotFill.Fill, + inspector_controls_Slot = inspector_controls_createSlotFill.Slot; + +var InspectorControls = ifBlockEditSelected(inspector_controls_Fill); +InspectorControls.Slot = inspector_controls_Slot; +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/inspector-controls/README.md + */ + +/* harmony default export */ var inspector_controls = (InspectorControls); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/media-upload/index.js +/** + * WordPress dependencies + */ + +/** + * This is a placeholder for the media upload component necessary to make it possible to provide + * an integration with the core blocks that handle media files. By default it renders nothing but + * it provides a way to have it overridden with the `editor.MediaUpload` filter. + * + * @return {WPElement} Media upload element. + */ + +var MediaUpload = function MediaUpload() { + return null; +}; +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/media-upload/README.md + */ + + +/* harmony default export */ var media_upload = (Object(external_this_wp_components_["withFilters"])('editor.MediaUpload')(MediaUpload)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-viewer.js + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +function LinkViewerUrl(_ref) { + var url = _ref.url, + urlLabel = _ref.urlLabel, + className = _ref.className; + var linkClassName = classnames_default()(className, 'block-editor-url-popover__link-viewer-url'); + + if (!url) { + return Object(external_this_wp_element_["createElement"])("span", { + className: linkClassName + }); + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ExternalLink"], { + className: linkClassName, + href: url + }, urlLabel || Object(external_this_wp_url_["filterURLForDisplay"])(Object(external_this_wp_url_["safeDecodeURI"])(url))); +} + +function LinkViewer(_ref2) { + var className = _ref2.className, + linkClassName = _ref2.linkClassName, + onEditLinkClick = _ref2.onEditLinkClick, + url = _ref2.url, + urlLabel = _ref2.urlLabel, + props = Object(objectWithoutProperties["a" /* default */])(_ref2, ["className", "linkClassName", "onEditLinkClick", "url", "urlLabel"]); + + return Object(external_this_wp_element_["createElement"])("div", Object(esm_extends["a" /* default */])({ + className: classnames_default()('block-editor-url-popover__link-viewer', className) + }, props), Object(external_this_wp_element_["createElement"])(LinkViewerUrl, { + url: url, + urlLabel: urlLabel, + className: linkClassName + }), onEditLinkClick && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + icon: "edit", + label: Object(external_this_wp_i18n_["__"])('Edit'), + onClick: onEditLinkClick + })); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/url-input/index.js + + + + + + + + +/** + * External dependencies + */ + + + +/** + * WordPress dependencies + */ + + + + + + + // Since URLInput is rendered in the context of other inputs, but should be +// considered a separate modal node, prevent keyboard events from propagating +// as being considered from the input. + +var stopEventPropagation = function stopEventPropagation(event) { + return event.stopPropagation(); +}; + +var url_input_URLInput = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(URLInput, _Component); + + function URLInput(_ref) { + var _this; + + var autocompleteRef = _ref.autocompleteRef; + + Object(classCallCheck["a" /* default */])(this, URLInput); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(URLInput).apply(this, arguments)); + _this.onChange = _this.onChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onKeyDown = _this.onKeyDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.autocompleteRef = autocompleteRef || Object(external_this_wp_element_["createRef"])(); + _this.inputRef = Object(external_this_wp_element_["createRef"])(); + _this.updateSuggestions = Object(external_lodash_["throttle"])(_this.updateSuggestions.bind(Object(assertThisInitialized["a" /* default */])(_this)), 200); + _this.suggestionNodes = []; + _this.state = { + suggestions: [], + showSuggestions: false, + selectedSuggestion: null + }; + return _this; + } + + Object(createClass["a" /* default */])(URLInput, [{ + key: "componentDidUpdate", + value: function componentDidUpdate() { + var _this2 = this; + + var _this$state = this.state, + showSuggestions = _this$state.showSuggestions, + selectedSuggestion = _this$state.selectedSuggestion; // only have to worry about scrolling selected suggestion into view + // when already expanded + + if (showSuggestions && selectedSuggestion !== null && !this.scrollingIntoView) { + this.scrollingIntoView = true; + lib_default()(this.suggestionNodes[selectedSuggestion], this.autocompleteRef.current, { + onlyScrollIfNeeded: true + }); + this.props.setTimeout(function () { + _this2.scrollingIntoView = false; + }, 100); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + delete this.suggestionsRequest; + } + }, { + key: "bindSuggestionNode", + value: function bindSuggestionNode(index) { + var _this3 = this; + + return function (ref) { + _this3.suggestionNodes[index] = ref; + }; + } + }, { + key: "updateSuggestions", + value: function updateSuggestions(value) { + var _this4 = this; + + var fetchLinkSuggestions = this.props.fetchLinkSuggestions; + + if (!fetchLinkSuggestions) { + return; + } // Show the suggestions after typing at least 2 characters + // and also for URLs + + + if (value.length < 2 || /^https?:/.test(value)) { + this.setState({ + showSuggestions: false, + selectedSuggestion: null, + loading: false + }); + return; + } + + this.setState({ + showSuggestions: true, + selectedSuggestion: null, + loading: true + }); + var request = fetchLinkSuggestions(value); + request.then(function (suggestions) { + // A fetch Promise doesn't have an abort option. It's mimicked by + // comparing the request reference in on the instance, which is + // reset or deleted on subsequent requests or unmounting. + if (_this4.suggestionsRequest !== request) { + return; + } + + _this4.setState({ + suggestions: suggestions, + loading: false + }); + + if (!!suggestions.length) { + _this4.props.debouncedSpeak(Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('%d result found, use up and down arrow keys to navigate.', '%d results found, use up and down arrow keys to navigate.', suggestions.length), suggestions.length), 'assertive'); + } else { + _this4.props.debouncedSpeak(Object(external_this_wp_i18n_["__"])('No results.'), 'assertive'); + } + }).catch(function () { + if (_this4.suggestionsRequest === request) { + _this4.setState({ + loading: false + }); + } + }); + this.suggestionsRequest = request; + } + }, { + key: "onChange", + value: function onChange(event) { + var inputValue = event.target.value; + this.props.onChange(inputValue); + this.updateSuggestions(inputValue); + } + }, { + key: "onKeyDown", + value: function onKeyDown(event) { + var _this$state2 = this.state, + showSuggestions = _this$state2.showSuggestions, + selectedSuggestion = _this$state2.selectedSuggestion, + suggestions = _this$state2.suggestions, + loading = _this$state2.loading; // If the suggestions are not shown or loading, we shouldn't handle the arrow keys + // We shouldn't preventDefault to allow block arrow keys navigation + + if (!showSuggestions || !suggestions.length || loading) { + // In the Windows version of Firefox the up and down arrows don't move the caret + // within an input field like they do for Mac Firefox/Chrome/Safari. This causes + // a form of focus trapping that is disruptive to the user experience. This disruption + // only happens if the caret is not in the first or last position in the text input. + // See: https://github.com/WordPress/gutenberg/issues/5693#issuecomment-436684747 + switch (event.keyCode) { + // When UP is pressed, if the caret is at the start of the text, move it to the 0 + // position. + case external_this_wp_keycodes_["UP"]: + { + if (0 !== event.target.selectionStart) { + event.stopPropagation(); + event.preventDefault(); // Set the input caret to position 0 + + event.target.setSelectionRange(0, 0); + } + + break; + } + // When DOWN is pressed, if the caret is not at the end of the text, move it to the + // last position. + + case external_this_wp_keycodes_["DOWN"]: + { + if (this.props.value.length !== event.target.selectionStart) { + event.stopPropagation(); + event.preventDefault(); // Set the input caret to the last position + + event.target.setSelectionRange(this.props.value.length, this.props.value.length); + } + + break; + } + } + + return; + } + + var suggestion = this.state.suggestions[this.state.selectedSuggestion]; + + switch (event.keyCode) { + case external_this_wp_keycodes_["UP"]: + { + event.stopPropagation(); + event.preventDefault(); + var previousIndex = !selectedSuggestion ? suggestions.length - 1 : selectedSuggestion - 1; + this.setState({ + selectedSuggestion: previousIndex + }); + break; + } + + case external_this_wp_keycodes_["DOWN"]: + { + event.stopPropagation(); + event.preventDefault(); + var nextIndex = selectedSuggestion === null || selectedSuggestion === suggestions.length - 1 ? 0 : selectedSuggestion + 1; + this.setState({ + selectedSuggestion: nextIndex + }); + break; + } + + case external_this_wp_keycodes_["TAB"]: + { + if (this.state.selectedSuggestion !== null) { + this.selectLink(suggestion); // Announce a link has been selected when tabbing away from the input field. + + this.props.speak(Object(external_this_wp_i18n_["__"])('Link selected.')); + } + + break; + } + + case external_this_wp_keycodes_["ENTER"]: + { + if (this.state.selectedSuggestion !== null) { + event.stopPropagation(); + this.selectLink(suggestion); + } + + break; + } + } + } + }, { + key: "selectLink", + value: function selectLink(suggestion) { + this.props.onChange(suggestion.url, suggestion); + this.setState({ + selectedSuggestion: null, + showSuggestions: false + }); + } + }, { + key: "handleOnClick", + value: function handleOnClick(suggestion) { + this.selectLink(suggestion); // Move focus to the input field when a link suggestion is clicked. + + this.inputRef.current.focus(); + } + }, { + key: "render", + value: function render() { + var _this5 = this; + + var _this$props = this.props, + _this$props$value = _this$props.value, + value = _this$props$value === void 0 ? '' : _this$props$value, + _this$props$autoFocus = _this$props.autoFocus, + autoFocus = _this$props$autoFocus === void 0 ? true : _this$props$autoFocus, + instanceId = _this$props.instanceId, + className = _this$props.className, + id = _this$props.id, + isFullWidth = _this$props.isFullWidth, + hasBorder = _this$props.hasBorder; + var _this$state3 = this.state, + showSuggestions = _this$state3.showSuggestions, + suggestions = _this$state3.suggestions, + selectedSuggestion = _this$state3.selectedSuggestion, + loading = _this$state3.loading; + var suggestionsListboxId = "block-editor-url-input-suggestions-".concat(instanceId); + var suggestionOptionIdPrefix = "block-editor-url-input-suggestion-".concat(instanceId); + /* eslint-disable jsx-a11y/no-autofocus */ + + return Object(external_this_wp_element_["createElement"])("div", { + className: classnames_default()('editor-url-input block-editor-url-input', className, { + 'is-full-width': isFullWidth, + 'has-border': hasBorder + }) + }, Object(external_this_wp_element_["createElement"])("input", { + id: id, + autoFocus: autoFocus, + type: "text", + "aria-label": Object(external_this_wp_i18n_["__"])('URL'), + required: true, + value: value, + onChange: this.onChange, + onInput: stopEventPropagation, + placeholder: Object(external_this_wp_i18n_["__"])('Paste URL or type to search'), + onKeyDown: this.onKeyDown, + role: "combobox", + "aria-expanded": showSuggestions, + "aria-autocomplete": "list", + "aria-owns": suggestionsListboxId, + "aria-activedescendant": selectedSuggestion !== null ? "".concat(suggestionOptionIdPrefix, "-").concat(selectedSuggestion) : undefined, + ref: this.inputRef + }), loading && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Spinner"], null), showSuggestions && !!suggestions.length && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Popover"], { + position: "bottom", + noArrow: true, + focusOnMount: false + }, Object(external_this_wp_element_["createElement"])("div", { + className: classnames_default()('editor-url-input__suggestions', 'block-editor-url-input__suggestions', "".concat(className, "__suggestions")), + id: suggestionsListboxId, + ref: this.autocompleteRef, + role: "listbox" + }, suggestions.map(function (suggestion, index) { + return Object(external_this_wp_element_["createElement"])("button", { + key: suggestion.id, + role: "option", + tabIndex: "-1", + id: "".concat(suggestionOptionIdPrefix, "-").concat(index), + ref: _this5.bindSuggestionNode(index), + className: classnames_default()('editor-url-input__suggestion block-editor-url-input__suggestion', { + 'is-selected': index === selectedSuggestion + }), + onClick: function onClick() { + return _this5.handleOnClick(suggestion); + }, + "aria-selected": index === selectedSuggestion + }, suggestion.title); + })))); + /* eslint-enable jsx-a11y/no-autofocus */ + } + }], [{ + key: "getDerivedStateFromProps", + value: function getDerivedStateFromProps(_ref2, _ref3) { + var disableSuggestions = _ref2.disableSuggestions; + var showSuggestions = _ref3.showSuggestions; + return { + showSuggestions: disableSuggestions === true ? false : showSuggestions + }; + } + }]); + + return URLInput; +}(external_this_wp_element_["Component"]); +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/url-input/README.md + */ + + +/* harmony default export */ var url_input = (Object(external_this_wp_compose_["compose"])(external_this_wp_compose_["withSafeTimeout"], external_this_wp_components_["withSpokenMessages"], external_this_wp_compose_["withInstanceId"], Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getSettings = _select.getSettings; + + return { + fetchLinkSuggestions: getSettings().__experimentalFetchLinkSuggestions + }; +}))(url_input_URLInput)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/url-popover/link-editor.js + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + +function LinkEditor(_ref) { + var autocompleteRef = _ref.autocompleteRef, + className = _ref.className, + onChangeInputValue = _ref.onChangeInputValue, + value = _ref.value, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["autocompleteRef", "className", "onChangeInputValue", "value"]); + + return Object(external_this_wp_element_["createElement"])("form", Object(esm_extends["a" /* default */])({ + className: classnames_default()('block-editor-url-popover__link-editor', className) + }, props), Object(external_this_wp_element_["createElement"])(url_input, { + value: value, + onChange: onChangeInputValue, + autocompleteRef: autocompleteRef + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + icon: "editor-break", + label: Object(external_this_wp_i18n_["__"])('Apply'), + type: "submit" + })); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/url-popover/index.js + + + + + + + + + + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + +var url_popover_URLPopover = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(URLPopover, _Component); + + function URLPopover() { + var _this; + + Object(classCallCheck["a" /* default */])(this, URLPopover); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(URLPopover).apply(this, arguments)); + _this.toggleSettingsVisibility = _this.toggleSettingsVisibility.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.state = { + isSettingsExpanded: false + }; + return _this; + } + + Object(createClass["a" /* default */])(URLPopover, [{ + key: "toggleSettingsVisibility", + value: function toggleSettingsVisibility() { + this.setState({ + isSettingsExpanded: !this.state.isSettingsExpanded + }); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + additionalControls = _this$props.additionalControls, + children = _this$props.children, + renderSettings = _this$props.renderSettings, + _this$props$position = _this$props.position, + position = _this$props$position === void 0 ? 'bottom center' : _this$props$position, + _this$props$focusOnMo = _this$props.focusOnMount, + focusOnMount = _this$props$focusOnMo === void 0 ? 'firstElement' : _this$props$focusOnMo, + popoverProps = Object(objectWithoutProperties["a" /* default */])(_this$props, ["additionalControls", "children", "renderSettings", "position", "focusOnMount"]); + + var isSettingsExpanded = this.state.isSettingsExpanded; + var showSettings = !!renderSettings && isSettingsExpanded; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Popover"], Object(esm_extends["a" /* default */])({ + className: "editor-url-popover block-editor-url-popover", + focusOnMount: focusOnMount, + position: position + }, popoverProps), Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-url-popover__input-container" + }, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-url-popover__row block-editor-url-popover__row" + }, children, !!renderSettings && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + className: "editor-url-popover__settings-toggle block-editor-url-popover__settings-toggle", + icon: "arrow-down-alt2", + label: Object(external_this_wp_i18n_["__"])('Link settings'), + onClick: this.toggleSettingsVisibility, + "aria-expanded": isSettingsExpanded + })), showSettings && Object(external_this_wp_element_["createElement"])("div", { + className: "editor-url-popover__row block-editor-url-popover__row editor-url-popover__settings block-editor-url-popover__settings" + }, renderSettings())), additionalControls && !showSettings && Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-url-popover__additional-controls" + }, additionalControls)); + } + }]); + + return URLPopover; +}(external_this_wp_element_["Component"]); + +url_popover_URLPopover.LinkEditor = LinkEditor; +url_popover_URLPopover.LinkViewer = LinkViewer; +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/url-popover/README.md + */ + +/* harmony default export */ var url_popover = (url_popover_URLPopover); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/media-placeholder/index.js + + + + + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + + + +var media_placeholder_InsertFromURLPopover = function InsertFromURLPopover(_ref) { + var src = _ref.src, + onChange = _ref.onChange, + onSubmit = _ref.onSubmit, + onClose = _ref.onClose; + return Object(external_this_wp_element_["createElement"])(url_popover, { + onClose: onClose + }, Object(external_this_wp_element_["createElement"])("form", { + className: "editor-media-placeholder__url-input-form block-editor-media-placeholder__url-input-form", + onSubmit: onSubmit + }, Object(external_this_wp_element_["createElement"])("input", { + className: "editor-media-placeholder__url-input-field block-editor-media-placeholder__url-input-field", + type: "url", + "aria-label": Object(external_this_wp_i18n_["__"])('URL'), + placeholder: Object(external_this_wp_i18n_["__"])('Paste or type URL'), + onChange: onChange, + value: src + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + className: "editor-media-placeholder__url-input-submit-button block-editor-media-placeholder__url-input-submit-button", + icon: "editor-break", + label: Object(external_this_wp_i18n_["__"])('Apply'), + type: "submit" + }))); +}; + +var media_placeholder_MediaPlaceholder = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(MediaPlaceholder, _Component); + + function MediaPlaceholder() { + var _this; + + Object(classCallCheck["a" /* default */])(this, MediaPlaceholder); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(MediaPlaceholder).apply(this, arguments)); + _this.state = { + src: '', + isURLInputVisible: false + }; + _this.onChangeSrc = _this.onChangeSrc.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onSubmitSrc = _this.onSubmitSrc.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onUpload = _this.onUpload.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onFilesUpload = _this.onFilesUpload.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.openURLInput = _this.openURLInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.closeURLInput = _this.closeURLInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(MediaPlaceholder, [{ + key: "onlyAllowsImages", + value: function onlyAllowsImages() { + var allowedTypes = this.props.allowedTypes; + + if (!allowedTypes) { + return false; + } + + return Object(external_lodash_["every"])(allowedTypes, function (allowedType) { + return allowedType === 'image' || Object(external_lodash_["startsWith"])(allowedType, 'image/'); + }); + } + }, { + key: "componentDidMount", + value: function componentDidMount() { + this.setState({ + src: Object(external_lodash_["get"])(this.props.value, ['src'], '') + }); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + if (Object(external_lodash_["get"])(prevProps.value, ['src'], '') !== Object(external_lodash_["get"])(this.props.value, ['src'], '')) { + this.setState({ + src: Object(external_lodash_["get"])(this.props.value, ['src'], '') + }); + } + } + }, { + key: "onChangeSrc", + value: function onChangeSrc(event) { + this.setState({ + src: event.target.value + }); + } + }, { + key: "onSubmitSrc", + value: function onSubmitSrc(event) { + event.preventDefault(); + + if (this.state.src && this.props.onSelectURL) { + this.props.onSelectURL(this.state.src); + this.closeURLInput(); + } + } + }, { + key: "onUpload", + value: function onUpload(event) { + this.onFilesUpload(event.target.files); + } + }, { + key: "onFilesUpload", + value: function onFilesUpload(files) { + var _this$props = this.props, + addToGallery = _this$props.addToGallery, + allowedTypes = _this$props.allowedTypes, + mediaUpload = _this$props.mediaUpload, + multiple = _this$props.multiple, + onError = _this$props.onError, + onSelect = _this$props.onSelect, + _this$props$value = _this$props.value, + value = _this$props$value === void 0 ? [] : _this$props$value; + var setMedia; + + if (multiple) { + if (addToGallery) { + var currentValue = value; + + setMedia = function setMedia(newMedia) { + onSelect(currentValue.concat(newMedia)); + }; + } else { + setMedia = onSelect; + } + } else { + setMedia = function setMedia(_ref2) { + var _ref3 = Object(slicedToArray["a" /* default */])(_ref2, 1), + media = _ref3[0]; + + return onSelect(media); + }; + } + + mediaUpload({ + allowedTypes: allowedTypes, + filesList: files, + onFileChange: setMedia, + onError: onError + }); + } + }, { + key: "openURLInput", + value: function openURLInput() { + this.setState({ + isURLInputVisible: true + }); + } + }, { + key: "closeURLInput", + value: function closeURLInput() { + this.setState({ + isURLInputVisible: false + }); + } + }, { + key: "renderPlaceholder", + value: function renderPlaceholder(content, onClick) { + var _this$props2 = this.props, + _this$props2$allowedT = _this$props2.allowedTypes, + allowedTypes = _this$props2$allowedT === void 0 ? [] : _this$props2$allowedT, + className = _this$props2.className, + icon = _this$props2.icon, + isAppender = _this$props2.isAppender, + _this$props2$labels = _this$props2.labels, + labels = _this$props2$labels === void 0 ? {} : _this$props2$labels, + onDoubleClick = _this$props2.onDoubleClick, + mediaPreview = _this$props2.mediaPreview, + notices = _this$props2.notices, + onSelectURL = _this$props2.onSelectURL, + mediaUpload = _this$props2.mediaUpload, + children = _this$props2.children; + var instructions = labels.instructions; + var title = labels.title; + + if (!mediaUpload && !onSelectURL) { + instructions = Object(external_this_wp_i18n_["__"])('To edit this block, you need permission to upload media.'); + } + + if (instructions === undefined || title === undefined) { + var isOneType = 1 === allowedTypes.length; + var isAudio = isOneType && 'audio' === allowedTypes[0]; + var isImage = isOneType && 'image' === allowedTypes[0]; + var isVideo = isOneType && 'video' === allowedTypes[0]; + + if (instructions === undefined && mediaUpload) { + instructions = Object(external_this_wp_i18n_["__"])('Upload a media file or pick one from your media library.'); + + if (isAudio) { + instructions = Object(external_this_wp_i18n_["__"])('Upload an audio file, pick one from your media library, or add one with a URL.'); + } else if (isImage) { + instructions = Object(external_this_wp_i18n_["__"])('Upload an image file, pick one from your media library, or add one with a URL.'); + } else if (isVideo) { + instructions = Object(external_this_wp_i18n_["__"])('Upload a video file, pick one from your media library, or add one with a URL.'); + } + } + + if (title === undefined) { + title = Object(external_this_wp_i18n_["__"])('Media'); + + if (isAudio) { + title = Object(external_this_wp_i18n_["__"])('Audio'); + } else if (isImage) { + title = Object(external_this_wp_i18n_["__"])('Image'); + } else if (isVideo) { + title = Object(external_this_wp_i18n_["__"])('Video'); + } + } + } + + var placeholderClassName = classnames_default()('block-editor-media-placeholder', 'editor-media-placeholder', className, { + 'is-appender': isAppender + }); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Placeholder"], { + icon: icon, + label: title, + instructions: instructions, + className: placeholderClassName, + notices: notices, + onClick: onClick, + onDoubleClick: onDoubleClick, + preview: mediaPreview + }, content, children); + } + }, { + key: "renderDropZone", + value: function renderDropZone() { + var _this$props3 = this.props, + disableDropZone = _this$props3.disableDropZone, + _this$props3$onHTMLDr = _this$props3.onHTMLDrop, + onHTMLDrop = _this$props3$onHTMLDr === void 0 ? external_lodash_["noop"] : _this$props3$onHTMLDr; + + if (disableDropZone) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["DropZone"], { + onFilesDrop: this.onFilesUpload, + onHTMLDrop: onHTMLDrop + }); + } + }, { + key: "renderCancelLink", + value: function renderCancelLink() { + var onCancel = this.props.onCancel; + return onCancel && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: "block-editor-media-placeholder__cancel-button", + title: Object(external_this_wp_i18n_["__"])('Cancel'), + isLink: true, + onClick: onCancel + }, Object(external_this_wp_i18n_["__"])('Cancel')); + } + }, { + key: "renderUrlSelectionUI", + value: function renderUrlSelectionUI() { + var onSelectURL = this.props.onSelectURL; + + if (!onSelectURL) { + return null; + } + + var _this$state = this.state, + isURLInputVisible = _this$state.isURLInputVisible, + src = _this$state.src; + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-media-placeholder__url-input-container block-editor-media-placeholder__url-input-container" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + className: "editor-media-placeholder__button block-editor-media-placeholder__button", + onClick: this.openURLInput, + isToggled: isURLInputVisible, + isLarge: true + }, Object(external_this_wp_i18n_["__"])('Insert from URL')), isURLInputVisible && Object(external_this_wp_element_["createElement"])(media_placeholder_InsertFromURLPopover, { + src: src, + onChange: this.onChangeSrc, + onSubmit: this.onSubmitSrc, + onClose: this.closeURLInput + })); + } + }, { + key: "renderMediaUploadChecked", + value: function renderMediaUploadChecked() { + var _this2 = this; + + var _this$props4 = this.props, + accept = _this$props4.accept, + addToGallery = _this$props4.addToGallery, + _this$props4$allowedT = _this$props4.allowedTypes, + allowedTypes = _this$props4$allowedT === void 0 ? [] : _this$props4$allowedT, + isAppender = _this$props4.isAppender, + mediaUpload = _this$props4.mediaUpload, + _this$props4$multiple = _this$props4.multiple, + multiple = _this$props4$multiple === void 0 ? false : _this$props4$multiple, + onSelect = _this$props4.onSelect, + _this$props4$value = _this$props4.value, + value = _this$props4$value === void 0 ? {} : _this$props4$value; + var mediaLibraryButton = Object(external_this_wp_element_["createElement"])(media_upload, { + addToGallery: addToGallery, + gallery: multiple && this.onlyAllowsImages(), + multiple: multiple, + onSelect: onSelect, + allowedTypes: allowedTypes, + value: Object(external_lodash_["isArray"])(value) ? value.map(function (_ref4) { + var id = _ref4.id; + return id; + }) : value.id, + render: function render(_ref5) { + var open = _ref5.open; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isLarge: true, + className: classnames_default()('editor-media-placeholder__button', 'editor-media-placeholder__media-library-button'), + onClick: function onClick(event) { + event.stopPropagation(); + open(); + } + }, Object(external_this_wp_i18n_["__"])('Media Library')); + } + }); + + if (mediaUpload && isAppender) { + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, this.renderDropZone(), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["FormFileUpload"], { + onChange: this.onUpload, + accept: accept, + multiple: multiple, + render: function render(_ref6) { + var openFileDialog = _ref6.openFileDialog; + var content = Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + isLarge: true, + className: classnames_default()('block-editor-media-placeholder__button', 'editor-media-placeholder__button', 'block-editor-media-placeholder__upload-button'), + icon: "upload" + }, Object(external_this_wp_i18n_["__"])('Upload')), mediaLibraryButton, _this2.renderUrlSelectionUI(), _this2.renderCancelLink()); + return _this2.renderPlaceholder(content, openFileDialog); + } + })); + } + + if (mediaUpload) { + var content = Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, this.renderDropZone(), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["FormFileUpload"], { + isLarge: true, + className: classnames_default()('block-editor-media-placeholder__button', 'editor-media-placeholder__button', 'block-editor-media-placeholder__upload-button'), + onChange: this.onUpload, + accept: accept, + multiple: multiple + }, Object(external_this_wp_i18n_["__"])('Upload')), mediaLibraryButton, this.renderUrlSelectionUI(), this.renderCancelLink()); + return this.renderPlaceholder(content); + } + + return this.renderPlaceholder(mediaLibraryButton); + } + }, { + key: "render", + value: function render() { + var dropZoneUIOnly = this.props.dropZoneUIOnly; + + if (dropZoneUIOnly) { + return Object(external_this_wp_element_["createElement"])(check, null, this.renderDropZone()); + } + + return Object(external_this_wp_element_["createElement"])(check, { + fallback: this.renderPlaceholder(this.renderUrlSelectionUI()) + }, this.renderMediaUploadChecked()); + } + }]); + + return MediaPlaceholder; +}(external_this_wp_element_["Component"]); +var media_placeholder_applyWithSelect = Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getSettings = _select.getSettings; + + return { + mediaUpload: getSettings().__experimentalMediaUpload + }; +}); +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/media-placeholder/README.md + */ + +/* harmony default export */ var media_placeholder = (Object(external_this_wp_compose_["compose"])(media_placeholder_applyWithSelect, Object(external_this_wp_components_["withFilters"])('editor.MediaPlaceholder'))(media_placeholder_MediaPlaceholder)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/color-palette/control.js + + + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + // translators: first %s: The type of color (e.g. background color), second %s: the color name or value (e.g. red or #ff0000) + +var colorIndicatorAriaLabel = Object(external_this_wp_i18n_["__"])('(current %s: %s)'); + +function ColorPaletteControl(_ref) { + var colors = _ref.colors, + disableCustomColors = _ref.disableCustomColors, + label = _ref.label, + onChange = _ref.onChange, + value = _ref.value; + var colorObject = utils_getColorObjectByColorValue(colors, value); + var colorName = colorObject && colorObject.name; + var ariaLabel = Object(external_this_wp_i18n_["sprintf"])(colorIndicatorAriaLabel, label.toLowerCase(), colorName || value); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["BaseControl"], { + className: "editor-color-palette-control block-editor-color-palette-control" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["BaseControl"].VisualLabel, null, label, value && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ColorIndicator"], { + colorValue: value, + "aria-label": ariaLabel + })), Object(external_this_wp_element_["createElement"])(color_palette, Object(esm_extends["a" /* default */])({ + className: "editor-color-palette-control__color-palette block-editor-color-palette-control__color-palette", + value: value, + onChange: onChange + }, { + colors: colors, + disableCustomColors: disableCustomColors + }))); +} +/* harmony default export */ var color_palette_control = (Object(external_this_wp_compose_["compose"])([with_color_context, Object(external_this_wp_compose_["ifCondition"])(function (_ref2) { + var hasColorsToChoose = _ref2.hasColorsToChoose; + return hasColorsToChoose; +})])(ColorPaletteControl)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/panel-color-settings/index.js + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + + + + +var hasCustomColorsDisabledForSetting = function hasCustomColorsDisabledForSetting(disableCustomColors, colorSetting) { + if (colorSetting.disableCustomColors !== undefined) { + return colorSetting.disableCustomColors; + } + + return disableCustomColors; +}; + +var hasColorsToChooseInSetting = function hasColorsToChooseInSetting() { + var colors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : []; + var disableCustomColors = arguments.length > 1 ? arguments[1] : undefined; + var colorSetting = arguments.length > 2 ? arguments[2] : undefined; + + if (!hasCustomColorsDisabledForSetting(disableCustomColors, colorSetting)) { + return true; + } + + return (colorSetting.colors || colors).length > 0; +}; + +var panel_color_settings_hasColorsToChoose = function hasColorsToChoose(_ref) { + var colors = _ref.colors, + disableCustomColors = _ref.disableCustomColors, + colorSettings = _ref.colorSettings; + return Object(external_lodash_["some"])(colorSettings, function (colorSetting) { + return hasColorsToChooseInSetting(colors, disableCustomColors, colorSetting); + }); +}; // translators: first %s: The type of color (e.g. background color), second %s: the color name or value (e.g. red or #ff0000) + + +var panel_color_settings_colorIndicatorAriaLabel = Object(external_this_wp_i18n_["__"])('(%s: %s)'); + +var panel_color_settings_renderColorIndicators = function renderColorIndicators(colorSettings, colors) { + return colorSettings.map(function (_ref2, index) { + var value = _ref2.value, + label = _ref2.label, + availableColors = _ref2.colors; + + if (!value) { + return null; + } + + var colorObject = utils_getColorObjectByColorValue(availableColors || colors, value); + var colorName = colorObject && colorObject.name; + var ariaLabel = Object(external_this_wp_i18n_["sprintf"])(panel_color_settings_colorIndicatorAriaLabel, label.toLowerCase(), colorName || value); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ColorIndicator"], { + key: index, + colorValue: value, + "aria-label": ariaLabel + }); + }); +}; // colorSettings is passed as an array of props so that it can be used for +// mapping both ColorIndicator and ColorPaletteControl components. Passing +// an array of components/nodes here wouldn't be feasible. + + +var PanelColorSettings = Object(external_this_wp_compose_["ifCondition"])(panel_color_settings_hasColorsToChoose)(function (_ref3) { + var children = _ref3.children, + colors = _ref3.colors, + colorSettings = _ref3.colorSettings, + disableCustomColors = _ref3.disableCustomColors, + title = _ref3.title, + props = Object(objectWithoutProperties["a" /* default */])(_ref3, ["children", "colors", "colorSettings", "disableCustomColors", "title"]); + + var titleElement = Object(external_this_wp_element_["createElement"])("span", { + className: "editor-panel-color-settings__panel-title block-editor-panel-color-settings__panel-title" + }, title, panel_color_settings_renderColorIndicators(colorSettings, colors)); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], Object(esm_extends["a" /* default */])({ + className: "editor-panel-color-settings block-editor-panel-color-settings", + title: titleElement + }, props), colorSettings.map(function (settings, index) { + return Object(external_this_wp_element_["createElement"])(color_palette_control, Object(esm_extends["a" /* default */])({ + key: index + }, Object(objectSpread["a" /* default */])({ + colors: colors, + disableCustomColors: disableCustomColors + }, settings))); + }), children); +}); +/* harmony default export */ var panel_color_settings = (with_color_context(PanelColorSettings)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/plain-text/index.js + + + + +/** + * WordPress dependencies + */ + +/** + * External dependencies + */ + + + +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/plain-text/README.md + */ + +var PlainText = Object(external_this_wp_element_["forwardRef"])(function (_ref, ref) { + var _onChange = _ref.onChange, + className = _ref.className, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["onChange", "className"]); + + return Object(external_this_wp_element_["createElement"])(react_autosize_textarea_lib_default.a, Object(esm_extends["a" /* default */])({ + ref: ref, + className: classnames_default()('editor-plain-text block-editor-plain-text', className), + onChange: function onChange(event) { + return _onChange(event.target.value); + } + }, props)); +}); +/* harmony default export */ var plain_text = (PlainText); + +// EXTERNAL MODULE: external {"this":["wp","blob"]} +var external_this_wp_blob_ = __webpack_require__(35); + +// EXTERNAL MODULE: external {"this":["wp","deprecated"]} +var external_this_wp_deprecated_ = __webpack_require__(37); +var external_this_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_deprecated_); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/rich-text/format-toolbar/index.js + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +var POPOVER_PROPS = { + position: 'bottom left' +}; + +var format_toolbar_FormatToolbar = function FormatToolbar() { + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-format-toolbar block-editor-format-toolbar" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Toolbar"], null, ['bold', 'italic', 'link'].map(function (format) { + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Slot"], { + name: "RichText.ToolbarControls.".concat(format), + key: format + }); + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Slot"], { + name: "RichText.ToolbarControls" + }, function (fills) { + return fills.length !== 0 && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["DropdownMenu"], { + icon: false, + label: Object(external_this_wp_i18n_["__"])('More rich text controls'), + controls: Object(external_lodash_["orderBy"])(fills.map(function (_ref) { + var _ref2 = Object(slicedToArray["a" /* default */])(_ref, 1), + props = _ref2[0].props; + + return props; + }), 'title'), + popoverProps: POPOVER_PROPS + }); + }))); +}; + +/* harmony default export */ var format_toolbar = (format_toolbar_FormatToolbar); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/rich-text/remove-browser-shortcuts.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Set of keyboard shortcuts handled internally by RichText. + * + * @type {Array} + */ + +var HANDLED_SHORTCUTS = [external_this_wp_keycodes_["rawShortcut"].primary('z'), external_this_wp_keycodes_["rawShortcut"].primaryShift('z'), external_this_wp_keycodes_["rawShortcut"].primary('y')]; +/** + * An instance of a KeyboardShortcuts element pre-bound for the handled + * shortcuts. Since shortcuts never change, the element can be considered + * static, and can be skipped in reconciliation. + * + * @type {WPElement} + */ + +var SHORTCUTS_ELEMENT = Object(external_this_wp_element_["createElement"])(external_this_wp_components_["KeyboardShortcuts"], { + bindGlobal: true, + shortcuts: Object(external_lodash_["fromPairs"])(HANDLED_SHORTCUTS.map(function (shortcut) { + return [shortcut, function (event) { + return event.preventDefault(); + }]; + })) +}); +/** + * Component which registered keyboard event handlers to prevent default + * behaviors for key combinations otherwise handled internally by RichText. + * + * @return {WPElement} WordPress element. + */ + +var RemoveBrowserShortcuts = function RemoveBrowserShortcuts() { + return SHORTCUTS_ELEMENT; +}; + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/rich-text/shortcut.js + + + + + + + + + +/** + * WordPress dependencies + */ + + + +var shortcut_RichTextShortcut = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(RichTextShortcut, _Component); + + function RichTextShortcut() { + var _this; + + Object(classCallCheck["a" /* default */])(this, RichTextShortcut); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(RichTextShortcut).apply(this, arguments)); + _this.onUse = _this.onUse.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(RichTextShortcut, [{ + key: "onUse", + value: function onUse() { + this.props.onUse(); + return false; + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + character = _this$props.character, + type = _this$props.type; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["KeyboardShortcuts"], { + bindGlobal: true, + shortcuts: Object(defineProperty["a" /* default */])({}, external_this_wp_keycodes_["rawShortcut"][type](character), this.onUse) + }); + } + }]); + + return RichTextShortcut; +}(external_this_wp_element_["Component"]); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/rich-text/toolbar-button.js + + + + +/** + * WordPress dependencies + */ + + +function RichTextToolbarButton(_ref) { + var name = _ref.name, + shortcutType = _ref.shortcutType, + shortcutCharacter = _ref.shortcutCharacter, + props = Object(objectWithoutProperties["a" /* default */])(_ref, ["name", "shortcutType", "shortcutCharacter"]); + + var shortcut; + var fillName = 'RichText.ToolbarControls'; + + if (name) { + fillName += ".".concat(name); + } + + if (shortcutType && shortcutCharacter) { + shortcut = external_this_wp_keycodes_["displayShortcut"][shortcutType](shortcutCharacter); + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Fill"], { + name: fillName + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ToolbarButton"], Object(esm_extends["a" /* default */])({}, props, { + shortcut: shortcut + }))); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/rich-text/input-event.js + + + + + + + +/** + * WordPress dependencies + */ + +var input_event_unstableRichTextInputEvent = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(__unstableRichTextInputEvent, _Component); + + function __unstableRichTextInputEvent() { + var _this; + + Object(classCallCheck["a" /* default */])(this, __unstableRichTextInputEvent); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(__unstableRichTextInputEvent).apply(this, arguments)); + _this.onInput = _this.onInput.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(__unstableRichTextInputEvent, [{ + key: "onInput", + value: function onInput(event) { + if (event.inputType === this.props.inputType) { + this.props.onInput(); + } + } + }, { + key: "componentDidMount", + value: function componentDidMount() { + document.addEventListener('input', this.onInput, true); + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + document.removeEventListener('input', this.onInput, true); + } + }, { + key: "render", + value: function render() { + return null; + } + }]); + + return __unstableRichTextInputEvent; +}(external_this_wp_element_["Component"]); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/rich-text/index.js + + + + + + + + + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + + + + + + +/** + * Internal dependencies + */ + + + + + + + +var requestIdleCallback = window.requestIdleCallback || function fallbackRequestIdleCallback(fn) { + window.setTimeout(fn, 100); +}; + +var wrapperClasses = 'editor-rich-text block-editor-rich-text'; +var rich_text_classes = 'editor-rich-text__editable block-editor-rich-text__editable'; +/** + * Get the multiline tag based on the multiline prop. + * + * @param {?(string|boolean)} multiline The multiline prop. + * + * @return {?string} The multiline tag. + */ + +function getMultilineTag(multiline) { + if (multiline !== true && multiline !== 'p' && multiline !== 'li') { + return; + } + + return multiline === true ? 'p' : multiline; +} + +var rich_text_RichTextWrapper = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(RichTextWrapper, _Component); + + function RichTextWrapper() { + var _this; + + Object(classCallCheck["a" /* default */])(this, RichTextWrapper); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(RichTextWrapper).apply(this, arguments)); + _this.onEnter = _this.onEnter.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onSplit = _this.onSplit.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onPaste = _this.onPaste.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onDelete = _this.onDelete.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.inputRule = _this.inputRule.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.markAutomaticChange = _this.markAutomaticChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(RichTextWrapper, [{ + key: "onEnter", + value: function onEnter(_ref) { + var value = _ref.value, + onChange = _ref.onChange, + shiftKey = _ref.shiftKey; + var _this$props = this.props, + onReplace = _this$props.onReplace, + onSplit = _this$props.onSplit, + multiline = _this$props.multiline; + var canSplit = onReplace && onSplit; + + if (onReplace) { + var transforms = Object(external_this_wp_blocks_["getBlockTransforms"])('from').filter(function (_ref2) { + var type = _ref2.type; + return type === 'enter'; + }); + var transformation = Object(external_this_wp_blocks_["findTransform"])(transforms, function (item) { + return item.regExp.test(value.text); + }); + + if (transformation) { + onReplace([transformation.transform({ + content: value.text + })]); + this.markAutomaticChange(); + } + } + + if (multiline) { + if (shiftKey) { + onChange(Object(external_this_wp_richText_["insert"])(value, '\n')); + } else if (canSplit && Object(external_this_wp_richText_["__unstableIsEmptyLine"])(value)) { + this.onSplit(value); + } else { + onChange(Object(external_this_wp_richText_["__unstableInsertLineSeparator"])(value)); + } + } else if (shiftKey || !canSplit) { + onChange(Object(external_this_wp_richText_["insert"])(value, '\n')); + } else { + this.onSplit(value); + } + } + }, { + key: "onDelete", + value: function onDelete(_ref3) { + var value = _ref3.value, + isReverse = _ref3.isReverse; + var _this$props2 = this.props, + onMerge = _this$props2.onMerge, + onRemove = _this$props2.onRemove; + + if (onMerge) { + onMerge(!isReverse); + } // Only handle remove on Backspace. This serves dual-purpose of being + // an intentional user interaction distinguishing between Backspace and + // Delete to remove the empty field, but also to avoid merge & remove + // causing destruction of two fields (merge, then removed merged). + + + if (onRemove && Object(external_this_wp_richText_["isEmpty"])(value) && isReverse) { + onRemove(!isReverse); + } + } + }, { + key: "onPaste", + value: function onPaste(_ref4) { + var value = _ref4.value, + onChange = _ref4.onChange, + html = _ref4.html, + plainText = _ref4.plainText, + image = _ref4.image; + var _this$props3 = this.props, + onReplace = _this$props3.onReplace, + onSplit = _this$props3.onSplit, + tagName = _this$props3.tagName, + canUserUseUnfilteredHTML = _this$props3.canUserUseUnfilteredHTML, + multiline = _this$props3.multiline, + __unstableEmbedURLOnPaste = _this$props3.__unstableEmbedURLOnPaste; + + if (image && !html) { + var file = image.getAsFile ? image.getAsFile() : image; + + var _content = Object(external_this_wp_blocks_["pasteHandler"])({ + HTML: "<img src=\"".concat(Object(external_this_wp_blob_["createBlobURL"])(file), "\">"), + mode: 'BLOCKS', + tagName: tagName + }); // Allows us to ask for this information when we get a report. + + + window.console.log('Received item:\n\n', file); + + if (onReplace && Object(external_this_wp_richText_["isEmpty"])(value)) { + onReplace(_content); + } else { + this.onSplit(value, _content); + } + + return; + } + + var mode = onReplace && onSplit ? 'AUTO' : 'INLINE'; + + if (__unstableEmbedURLOnPaste && Object(external_this_wp_richText_["isEmpty"])(value) && Object(external_this_wp_url_["isURL"])(plainText.trim())) { + mode = 'BLOCKS'; + } + + var content = Object(external_this_wp_blocks_["pasteHandler"])({ + HTML: html, + plainText: plainText, + mode: mode, + tagName: tagName, + canUserUseUnfilteredHTML: canUserUseUnfilteredHTML + }); + + if (typeof content === 'string') { + var valueToInsert = Object(external_this_wp_richText_["create"])({ + html: content + }); // If the content should be multiline, we should process text + // separated by a line break as separate lines. + + if (multiline) { + valueToInsert = Object(external_this_wp_richText_["replace"])(valueToInsert, /\n+/g, external_this_wp_richText_["__UNSTABLE_LINE_SEPARATOR"]); + } + + onChange(Object(external_this_wp_richText_["insert"])(value, valueToInsert)); + } else if (content.length > 0) { + if (onReplace && Object(external_this_wp_richText_["isEmpty"])(value)) { + onReplace(content); + } else { + this.onSplit(value, content); + } + } + } + /** + * Signals to the RichText owner that the block can be replaced with two + * blocks as a result of splitting the block by pressing enter, or with + * blocks as a result of splitting the block by pasting block content in the + * instance. + * + * @param {Object} record The rich text value to split. + * @param {Array} pastedBlocks The pasted blocks to insert, if any. + */ + + }, { + key: "onSplit", + value: function onSplit(record) { + var pastedBlocks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + var _this$props4 = this.props, + onReplace = _this$props4.onReplace, + onSplit = _this$props4.onSplit, + onSplitMiddle = _this$props4.__unstableOnSplitMiddle, + multiline = _this$props4.multiline; + + if (!onReplace || !onSplit) { + return; + } + + var blocks = []; + + var _split = Object(external_this_wp_richText_["split"])(record), + _split2 = Object(slicedToArray["a" /* default */])(_split, 2), + before = _split2[0], + after = _split2[1]; + + var hasPastedBlocks = pastedBlocks.length > 0; + var multilineTag = getMultilineTag(multiline); // Create a block with the content before the caret if there's no pasted + // blocks, or if there are pasted blocks and the value is not empty. + // We do not want a leading empty block on paste, but we do if split + // with e.g. the enter key. + + if (!hasPastedBlocks || !Object(external_this_wp_richText_["isEmpty"])(before)) { + blocks.push(onSplit(Object(external_this_wp_richText_["toHTMLString"])({ + value: before, + multilineTag: multilineTag + }))); + } + + if (hasPastedBlocks) { + blocks.push.apply(blocks, Object(toConsumableArray["a" /* default */])(pastedBlocks)); + } else if (onSplitMiddle) { + blocks.push(onSplitMiddle()); + } // If there's pasted blocks, append a block with the content after the + // caret. Otherwise, do append and empty block if there is no + // `onSplitMiddle` prop, but if there is and the content is empty, the + // middle block is enough to set focus in. + + + if (hasPastedBlocks || !onSplitMiddle || !Object(external_this_wp_richText_["isEmpty"])(after)) { + blocks.push(onSplit(Object(external_this_wp_richText_["toHTMLString"])({ + value: after, + multilineTag: multilineTag + }))); + } // If there are pasted blocks, set the selection to the last one. + // Otherwise, set the selection to the second block. + + + var indexToSelect = hasPastedBlocks ? blocks.length - 1 : 1; + onReplace(blocks, indexToSelect); + } + }, { + key: "inputRule", + value: function inputRule(value, valueToFormat) { + var onReplace = this.props.onReplace; + + if (!onReplace) { + return; + } + + var start = value.start, + text = value.text; + var characterBefore = text.slice(start - 1, start); // The character right before the caret must be a plain space. + + if (characterBefore !== ' ') { + return; + } + + var trimmedTextBefore = text.slice(0, start).trim(); + var prefixTransforms = Object(external_this_wp_blocks_["getBlockTransforms"])('from').filter(function (_ref5) { + var type = _ref5.type; + return type === 'prefix'; + }); + var transformation = Object(external_this_wp_blocks_["findTransform"])(prefixTransforms, function (_ref6) { + var prefix = _ref6.prefix; + return trimmedTextBefore === prefix; + }); + + if (!transformation) { + return; + } + + var content = valueToFormat(Object(external_this_wp_richText_["slice"])(value, start, text.length)); + var block = transformation.transform(content); + onReplace([block]); + this.markAutomaticChange(); + } + }, { + key: "getAllowedFormats", + value: function getAllowedFormats() { + var _this$props5 = this.props, + allowedFormats = _this$props5.allowedFormats, + formattingControls = _this$props5.formattingControls; + + if (!allowedFormats && !formattingControls) { + return; + } + + if (allowedFormats) { + return allowedFormats; + } + + external_this_wp_deprecated_default()('wp.blockEditor.RichText formattingControls prop', { + alternative: 'allowedFormats' + }); + return formattingControls.map(function (name) { + return "core/".concat(name); + }); + } + /** + * Marks the last change as an automatic change at the next idle period to + * ensure all selection changes have been recorded. + */ + + }, { + key: "markAutomaticChange", + value: function markAutomaticChange() { + var _this2 = this; + + requestIdleCallback(function () { + _this2.props.markAutomaticChange(); + }); + } + }, { + key: "render", + value: function render() { + var _this$props6 = this.props, + children = _this$props6.children, + tagName = _this$props6.tagName, + originalValue = _this$props6.value, + originalOnChange = _this$props6.onChange, + selectionStart = _this$props6.selectionStart, + selectionEnd = _this$props6.selectionEnd, + onSelectionChange = _this$props6.onSelectionChange, + multiline = _this$props6.multiline, + inlineToolbar = _this$props6.inlineToolbar, + wrapperClassName = _this$props6.wrapperClassName, + className = _this$props6.className, + autocompleters = _this$props6.autocompleters, + onReplace = _this$props6.onReplace, + isCaretWithinFormattedText = _this$props6.isCaretWithinFormattedText, + onEnterFormattedText = _this$props6.onEnterFormattedText, + onExitFormattedText = _this$props6.onExitFormattedText, + originalIsSelected = _this$props6.isSelected, + onCreateUndoLevel = _this$props6.onCreateUndoLevel, + markAutomaticChange = _this$props6.markAutomaticChange, + didAutomaticChange = _this$props6.didAutomaticChange, + undo = _this$props6.undo, + placeholder = _this$props6.placeholder, + keepPlaceholderOnFocus = _this$props6.keepPlaceholderOnFocus, + allowedFormats = _this$props6.allowedFormats, + withoutInteractiveFormatting = _this$props6.withoutInteractiveFormatting, + onRemove = _this$props6.onRemove, + onMerge = _this$props6.onMerge, + onSplit = _this$props6.onSplit, + canUserUseUnfilteredHTML = _this$props6.canUserUseUnfilteredHTML, + clientId = _this$props6.clientId, + identifier = _this$props6.identifier, + instanceId = _this$props6.instanceId, + start = _this$props6.start, + reversed = _this$props6.reversed, + experimentalProps = Object(objectWithoutProperties["a" /* default */])(_this$props6, ["children", "tagName", "value", "onChange", "selectionStart", "selectionEnd", "onSelectionChange", "multiline", "inlineToolbar", "wrapperClassName", "className", "autocompleters", "onReplace", "isCaretWithinFormattedText", "onEnterFormattedText", "onExitFormattedText", "isSelected", "onCreateUndoLevel", "markAutomaticChange", "didAutomaticChange", "undo", "placeholder", "keepPlaceholderOnFocus", "allowedFormats", "withoutInteractiveFormatting", "onRemove", "onMerge", "onSplit", "canUserUseUnfilteredHTML", "clientId", "identifier", "instanceId", "start", "reversed"]); + + var multilineTag = getMultilineTag(multiline); + var adjustedAllowedFormats = this.getAllowedFormats(); + var hasFormats = !adjustedAllowedFormats || adjustedAllowedFormats.length > 0; + var adjustedValue = originalValue; + var adjustedOnChange = originalOnChange; // Handle deprecated format. + + if (Array.isArray(originalValue)) { + adjustedValue = external_this_wp_blocks_["children"].toHTML(originalValue); + + adjustedOnChange = function adjustedOnChange(newValue) { + return originalOnChange(external_this_wp_blocks_["children"].fromDOM(Object(external_this_wp_richText_["__unstableCreateElement"])(document, newValue).childNodes)); + }; + } + + var content = Object(external_this_wp_element_["createElement"])(external_this_wp_richText_["__experimentalRichText"], Object(esm_extends["a" /* default */])({}, experimentalProps, { + value: adjustedValue, + onChange: adjustedOnChange, + selectionStart: selectionStart, + selectionEnd: selectionEnd, + onSelectionChange: onSelectionChange, + tagName: tagName, + className: classnames_default()(rich_text_classes, className, { + 'is-selected': originalIsSelected, + 'keep-placeholder-on-focus': keepPlaceholderOnFocus + }), + placeholder: placeholder, + allowedFormats: adjustedAllowedFormats, + withoutInteractiveFormatting: withoutInteractiveFormatting, + onEnter: this.onEnter, + onDelete: this.onDelete, + onPaste: this.onPaste, + __unstableIsSelected: originalIsSelected, + __unstableInputRule: this.inputRule, + __unstableMultilineTag: multilineTag, + __unstableIsCaretWithinFormattedText: isCaretWithinFormattedText, + __unstableOnEnterFormattedText: onEnterFormattedText, + __unstableOnExitFormattedText: onExitFormattedText, + __unstableOnCreateUndoLevel: onCreateUndoLevel, + __unstableMarkAutomaticChange: this.markAutomaticChange, + __unstableDidAutomaticChange: didAutomaticChange, + __unstableUndo: undo + }), function (_ref7) { + var isSelected = _ref7.isSelected, + value = _ref7.value, + onChange = _ref7.onChange, + Editable = _ref7.Editable; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, children && children({ + value: value, + onChange: onChange + }), isSelected && !inlineToolbar && hasFormats && Object(external_this_wp_element_["createElement"])(block_format_controls, null, Object(external_this_wp_element_["createElement"])(format_toolbar, null)), isSelected && inlineToolbar && hasFormats && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IsolatedEventContainer"], { + className: "editor-rich-text__inline-toolbar block-editor-rich-text__inline-toolbar" + }, Object(external_this_wp_element_["createElement"])(format_toolbar, null)), isSelected && Object(external_this_wp_element_["createElement"])(RemoveBrowserShortcuts, null), Object(external_this_wp_element_["createElement"])(autocomplete, { + onReplace: onReplace, + completers: autocompleters, + record: value, + onChange: onChange, + isSelected: isSelected + }, function (_ref8) { + var listBoxId = _ref8.listBoxId, + activeId = _ref8.activeId, + onKeyDown = _ref8.onKeyDown; + return Object(external_this_wp_element_["createElement"])(Editable, { + "aria-autocomplete": listBoxId ? 'list' : undefined, + "aria-owns": listBoxId, + "aria-activedescendant": activeId, + start: start, + reversed: reversed, + onKeyDown: onKeyDown + }); + })); + }); + return Object(external_this_wp_element_["createElement"])("div", { + className: classnames_default()(wrapperClasses, wrapperClassName) + }, content); + } + }]); + + return RichTextWrapper; +}(external_this_wp_element_["Component"]); + +var RichTextContainer = Object(external_this_wp_compose_["compose"])([external_this_wp_compose_["withInstanceId"], context_withBlockEditContext(function (_ref9) { + var clientId = _ref9.clientId; + return { + clientId: clientId + }; +}), Object(external_this_wp_data_["withSelect"])(function (select, _ref10) { + var clientId = _ref10.clientId, + instanceId = _ref10.instanceId, + _ref10$identifier = _ref10.identifier, + identifier = _ref10$identifier === void 0 ? instanceId : _ref10$identifier, + isSelected = _ref10.isSelected; + + var _select = select('core/block-editor'), + isCaretWithinFormattedText = _select.isCaretWithinFormattedText, + getSelectionStart = _select.getSelectionStart, + getSelectionEnd = _select.getSelectionEnd, + getSettings = _select.getSettings, + didAutomaticChange = _select.didAutomaticChange; + + var selectionStart = getSelectionStart(); + var selectionEnd = getSelectionEnd(); + + var _getSettings = getSettings(), + __experimentalCanUserUseUnfilteredHTML = _getSettings.__experimentalCanUserUseUnfilteredHTML; + + if (isSelected === undefined) { + isSelected = selectionStart.clientId === clientId && selectionStart.attributeKey === identifier; + } else if (isSelected) { + isSelected = selectionStart.clientId === clientId; + } + + return { + canUserUseUnfilteredHTML: __experimentalCanUserUseUnfilteredHTML, + isCaretWithinFormattedText: isCaretWithinFormattedText(), + selectionStart: isSelected ? selectionStart.offset : undefined, + selectionEnd: isSelected ? selectionEnd.offset : undefined, + isSelected: isSelected, + didAutomaticChange: didAutomaticChange() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref11) { + var clientId = _ref11.clientId, + instanceId = _ref11.instanceId, + _ref11$identifier = _ref11.identifier, + identifier = _ref11$identifier === void 0 ? instanceId : _ref11$identifier; + + var _dispatch = dispatch('core/block-editor'), + __unstableMarkLastChangeAsPersistent = _dispatch.__unstableMarkLastChangeAsPersistent, + enterFormattedText = _dispatch.enterFormattedText, + exitFormattedText = _dispatch.exitFormattedText, + selectionChange = _dispatch.selectionChange, + __unstableMarkAutomaticChange = _dispatch.__unstableMarkAutomaticChange; + + var _dispatch2 = dispatch('core/editor'), + undo = _dispatch2.undo; + + return { + onCreateUndoLevel: __unstableMarkLastChangeAsPersistent, + onEnterFormattedText: enterFormattedText, + onExitFormattedText: exitFormattedText, + onSelectionChange: function onSelectionChange(start, end) { + selectionChange(clientId, identifier, start, end); + }, + markAutomaticChange: __unstableMarkAutomaticChange, + undo: undo + }; +}), Object(external_this_wp_components_["withFilters"])('experimentalRichText')])(rich_text_RichTextWrapper); + +RichTextContainer.Content = function (_ref12) { + var value = _ref12.value, + Tag = _ref12.tagName, + multiline = _ref12.multiline, + props = Object(objectWithoutProperties["a" /* default */])(_ref12, ["value", "tagName", "multiline"]); + + // Handle deprecated `children` and `node` sources. + if (Array.isArray(value)) { + value = external_this_wp_blocks_["children"].toHTML(value); + } + + var MultilineTag = getMultilineTag(multiline); + + if (!value && MultilineTag) { + value = "<".concat(MultilineTag, "></").concat(MultilineTag, ">"); + } + + var content = Object(external_this_wp_element_["createElement"])(external_this_wp_element_["RawHTML"], null, value); + + if (Tag) { + return Object(external_this_wp_element_["createElement"])(Tag, Object(external_lodash_["omit"])(props, ['format']), content); + } + + return content; +}; + +RichTextContainer.isEmpty = function (value) { + return !value || value.length === 0; +}; + +RichTextContainer.Content.defaultProps = { + format: 'string', + value: '' +}; +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/rich-text/README.md + */ + +/* harmony default export */ var rich_text = (RichTextContainer); + + + + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/url-input/button.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + + +var button_URLInputButton = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(URLInputButton, _Component); + + function URLInputButton() { + var _this; + + Object(classCallCheck["a" /* default */])(this, URLInputButton); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(URLInputButton).apply(this, arguments)); + _this.toggle = _this.toggle.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.submitLink = _this.submitLink.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.state = { + expanded: false + }; + return _this; + } + + Object(createClass["a" /* default */])(URLInputButton, [{ + key: "toggle", + value: function toggle() { + this.setState({ + expanded: !this.state.expanded + }); + } + }, { + key: "submitLink", + value: function submitLink(event) { + event.preventDefault(); + this.toggle(); + } + }, { + key: "render", + value: function render() { + var _this$props = this.props, + url = _this$props.url, + onChange = _this$props.onChange; + var expanded = this.state.expanded; + var buttonLabel = url ? Object(external_this_wp_i18n_["__"])('Edit link') : Object(external_this_wp_i18n_["__"])('Insert link'); + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-url-input__button block-editor-url-input__button" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + icon: "admin-links", + label: buttonLabel, + onClick: this.toggle, + className: classnames_default()('components-toolbar__control', { + 'is-active': url + }) + }), expanded && Object(external_this_wp_element_["createElement"])("form", { + className: "editor-url-input__button-modal block-editor-url-input__button-modal", + onSubmit: this.submitLink + }, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-url-input__button-modal-line block-editor-url-input__button-modal-line" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + className: "editor-url-input__back block-editor-url-input__back", + icon: "arrow-left-alt", + label: Object(external_this_wp_i18n_["__"])('Close'), + onClick: this.toggle + }), Object(external_this_wp_element_["createElement"])(url_input, { + value: url || '', + onChange: onChange + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + icon: "editor-break", + label: Object(external_this_wp_i18n_["__"])('Submit'), + type: "submit" + })))); + } + }]); + + return URLInputButton; +}(external_this_wp_element_["Component"]); +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/url-input/README.md + */ + + +/* harmony default export */ var url_input_button = (button_URLInputButton); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-settings-menu-first-item.js +/** + * WordPress dependencies + */ + + +var block_settings_menu_first_item_createSlotFill = Object(external_this_wp_components_["createSlotFill"])('__experimentalBlockSettingsMenuFirstItem'), + __experimentalBlockSettingsMenuFirstItem = block_settings_menu_first_item_createSlotFill.Fill, + block_settings_menu_first_item_Slot = block_settings_menu_first_item_createSlotFill.Slot; + +__experimentalBlockSettingsMenuFirstItem.Slot = block_settings_menu_first_item_Slot; +/* harmony default export */ var block_settings_menu_first_item = (__experimentalBlockSettingsMenuFirstItem); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-settings-menu-plugins-extension.js +/** + * WordPress dependencies + */ + + +var block_settings_menu_plugins_extension_createSlotFill = Object(external_this_wp_components_["createSlotFill"])('__experimentalBlockSettingsMenuPluginsExtension'), + __experimentalBlockSettingsMenuPluginsExtension = block_settings_menu_plugins_extension_createSlotFill.Fill, + block_settings_menu_plugins_extension_Slot = block_settings_menu_plugins_extension_createSlotFill.Slot; + +__experimentalBlockSettingsMenuPluginsExtension.Slot = block_settings_menu_plugins_extension_Slot; +/* harmony default export */ var block_settings_menu_plugins_extension = (__experimentalBlockSettingsMenuPluginsExtension); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-actions/index.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +function BlockActions(_ref) { + var canDuplicate = _ref.canDuplicate, + canInsertDefaultBlock = _ref.canInsertDefaultBlock, + children = _ref.children, + isLocked = _ref.isLocked, + onDuplicate = _ref.onDuplicate, + onGroup = _ref.onGroup, + onInsertAfter = _ref.onInsertAfter, + onInsertBefore = _ref.onInsertBefore, + onRemove = _ref.onRemove, + onUngroup = _ref.onUngroup; + return children({ + canDuplicate: canDuplicate, + canInsertDefaultBlock: canInsertDefaultBlock, + isLocked: isLocked, + onDuplicate: onDuplicate, + onGroup: onGroup, + onInsertAfter: onInsertAfter, + onInsertBefore: onInsertBefore, + onRemove: onRemove, + onUngroup: onUngroup + }); +} + +/* harmony default export */ var block_actions = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, props) { + var _select = select('core/block-editor'), + canInsertBlockType = _select.canInsertBlockType, + getBlockRootClientId = _select.getBlockRootClientId, + getBlocksByClientId = _select.getBlocksByClientId, + getTemplateLock = _select.getTemplateLock; + + var _select2 = select('core/blocks'), + getDefaultBlockName = _select2.getDefaultBlockName; + + var blocks = getBlocksByClientId(props.clientIds); + var rootClientId = getBlockRootClientId(props.clientIds[0]); + var canDuplicate = Object(external_lodash_["every"])(blocks, function (block) { + return !!block && Object(external_this_wp_blocks_["hasBlockSupport"])(block.name, 'multiple', true) && canInsertBlockType(block.name, rootClientId); + }); + var canInsertDefaultBlock = canInsertBlockType(getDefaultBlockName(), rootClientId); + return { + blocks: blocks, + canDuplicate: canDuplicate, + canInsertDefaultBlock: canInsertDefaultBlock, + extraProps: props, + isLocked: !!getTemplateLock(rootClientId), + rootClientId: rootClientId + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, props, _ref2) { + var select = _ref2.select; + var clientIds = props.clientIds, + rootClientId = props.rootClientId, + blocks = props.blocks, + isLocked = props.isLocked, + canDuplicate = props.canDuplicate; + + var _dispatch = dispatch('core/block-editor'), + insertBlocks = _dispatch.insertBlocks, + multiSelect = _dispatch.multiSelect, + removeBlocks = _dispatch.removeBlocks, + insertDefaultBlock = _dispatch.insertDefaultBlock, + replaceBlocks = _dispatch.replaceBlocks; + + return { + onDuplicate: function onDuplicate() { + if (!canDuplicate) { + return; + } + + var _select3 = select('core/block-editor'), + getBlockIndex = _select3.getBlockIndex; + + var lastSelectedIndex = getBlockIndex(Object(external_lodash_["last"])(Object(external_lodash_["castArray"])(clientIds)), rootClientId); + var clonedBlocks = blocks.map(function (block) { + return Object(external_this_wp_blocks_["cloneBlock"])(block); + }); + insertBlocks(clonedBlocks, lastSelectedIndex + 1, rootClientId); + + if (clonedBlocks.length > 1) { + multiSelect(Object(external_lodash_["first"])(clonedBlocks).clientId, Object(external_lodash_["last"])(clonedBlocks).clientId); + } + }, + onRemove: function onRemove() { + if (!isLocked) { + removeBlocks(clientIds); + } + }, + onInsertBefore: function onInsertBefore() { + if (!isLocked) { + var _select4 = select('core/block-editor'), + getBlockIndex = _select4.getBlockIndex; + + var firstSelectedIndex = getBlockIndex(Object(external_lodash_["first"])(Object(external_lodash_["castArray"])(clientIds)), rootClientId); + insertDefaultBlock({}, rootClientId, firstSelectedIndex); + } + }, + onInsertAfter: function onInsertAfter() { + if (!isLocked) { + var _select5 = select('core/block-editor'), + getBlockIndex = _select5.getBlockIndex; + + var lastSelectedIndex = getBlockIndex(Object(external_lodash_["last"])(Object(external_lodash_["castArray"])(clientIds)), rootClientId); + insertDefaultBlock({}, rootClientId, lastSelectedIndex + 1); + } + }, + onGroup: function onGroup() { + if (!blocks.length) { + return; + } + + var _select6 = select('core/blocks'), + getGroupingBlockName = _select6.getGroupingBlockName; + + var groupingBlockName = getGroupingBlockName(); // Activate the `transform` on `core/group` which does the conversion + + var newBlocks = Object(external_this_wp_blocks_["switchToBlockType"])(blocks, groupingBlockName); + + if (!newBlocks) { + return; + } + + replaceBlocks(clientIds, newBlocks); + }, + onUngroup: function onUngroup() { + if (!blocks.length) { + return; + } + + var innerBlocks = blocks[0].innerBlocks; + + if (!innerBlocks.length) { + return; + } + + replaceBlocks(clientIds, innerBlocks); + } + }; +})])(BlockActions)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-editor-keyboard-shortcuts/index.js + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + + +var preventDefault = function preventDefault(event) { + event.preventDefault(); + return event; +}; + +var shortcuts = { + duplicate: { + raw: external_this_wp_keycodes_["rawShortcut"].primaryShift('d'), + display: external_this_wp_keycodes_["displayShortcut"].primaryShift('d') + }, + removeBlock: { + raw: external_this_wp_keycodes_["rawShortcut"].access('z'), + display: external_this_wp_keycodes_["displayShortcut"].access('z') + }, + insertBefore: { + raw: external_this_wp_keycodes_["rawShortcut"].primaryAlt('t'), + display: external_this_wp_keycodes_["displayShortcut"].primaryAlt('t') + }, + insertAfter: { + raw: external_this_wp_keycodes_["rawShortcut"].primaryAlt('y'), + display: external_this_wp_keycodes_["displayShortcut"].primaryAlt('y') + } +}; + +var block_editor_keyboard_shortcuts_BlockEditorKeyboardShortcuts = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockEditorKeyboardShortcuts, _Component); + + function BlockEditorKeyboardShortcuts() { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockEditorKeyboardShortcuts); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockEditorKeyboardShortcuts).apply(this, arguments)); + _this.selectAll = _this.selectAll.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.deleteSelectedBlocks = _this.deleteSelectedBlocks.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.clearMultiSelection = _this.clearMultiSelection.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(BlockEditorKeyboardShortcuts, [{ + key: "selectAll", + value: function selectAll(event) { + var _this$props = this.props, + rootBlocksClientIds = _this$props.rootBlocksClientIds, + onMultiSelect = _this$props.onMultiSelect; + event.preventDefault(); + onMultiSelect(Object(external_lodash_["first"])(rootBlocksClientIds), Object(external_lodash_["last"])(rootBlocksClientIds)); + } + }, { + key: "deleteSelectedBlocks", + value: function deleteSelectedBlocks(event) { + var _this$props2 = this.props, + selectedBlockClientIds = _this$props2.selectedBlockClientIds, + hasMultiSelection = _this$props2.hasMultiSelection, + onRemove = _this$props2.onRemove, + isLocked = _this$props2.isLocked; + + if (hasMultiSelection) { + event.preventDefault(); + + if (!isLocked) { + onRemove(selectedBlockClientIds); + } + } + } + /** + * Clears current multi-selection, if one exists. + */ + + }, { + key: "clearMultiSelection", + value: function clearMultiSelection() { + var _this$props3 = this.props, + hasMultiSelection = _this$props3.hasMultiSelection, + clearSelectedBlock = _this$props3.clearSelectedBlock; + + if (hasMultiSelection) { + clearSelectedBlock(); + window.getSelection().removeAllRanges(); + } + } + }, { + key: "render", + value: function render() { + var _ref; + + var selectedBlockClientIds = this.props.selectedBlockClientIds; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], 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('a'), this.selectAll), Object(defineProperty["a" /* default */])(_ref, "backspace", this.deleteSelectedBlocks), Object(defineProperty["a" /* default */])(_ref, "del", this.deleteSelectedBlocks), Object(defineProperty["a" /* default */])(_ref, "escape", this.clearMultiSelection), _ref) + }), selectedBlockClientIds.length > 0 && Object(external_this_wp_element_["createElement"])(block_actions, { + clientIds: selectedBlockClientIds + }, function (_ref2) { + var _ref3; + + var onDuplicate = _ref2.onDuplicate, + onRemove = _ref2.onRemove, + onInsertAfter = _ref2.onInsertAfter, + onInsertBefore = _ref2.onInsertBefore; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["KeyboardShortcuts"], { + bindGlobal: true, + shortcuts: (_ref3 = {}, Object(defineProperty["a" /* default */])(_ref3, shortcuts.duplicate.raw, Object(external_lodash_["flow"])(preventDefault, onDuplicate)), Object(defineProperty["a" /* default */])(_ref3, shortcuts.removeBlock.raw, Object(external_lodash_["flow"])(preventDefault, onRemove)), Object(defineProperty["a" /* default */])(_ref3, shortcuts.insertBefore.raw, Object(external_lodash_["flow"])(preventDefault, onInsertBefore)), Object(defineProperty["a" /* default */])(_ref3, shortcuts.insertAfter.raw, Object(external_lodash_["flow"])(preventDefault, onInsertAfter)), _ref3) + }); + })); + } + }]); + + return BlockEditorKeyboardShortcuts; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var block_editor_keyboard_shortcuts = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getBlockOrder = _select.getBlockOrder, + getSelectedBlockClientIds = _select.getSelectedBlockClientIds, + hasMultiSelection = _select.hasMultiSelection, + getBlockRootClientId = _select.getBlockRootClientId, + getTemplateLock = _select.getTemplateLock; + + var selectedBlockClientIds = getSelectedBlockClientIds(); + return { + rootBlocksClientIds: getBlockOrder(), + hasMultiSelection: hasMultiSelection(), + isLocked: Object(external_lodash_["some"])(selectedBlockClientIds, function (clientId) { + return !!getTemplateLock(getBlockRootClientId(clientId)); + }), + selectedBlockClientIds: selectedBlockClientIds + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/block-editor'), + clearSelectedBlock = _dispatch.clearSelectedBlock, + multiSelect = _dispatch.multiSelect, + removeBlocks = _dispatch.removeBlocks; + + return { + clearSelectedBlock: clearSelectedBlock, + onMultiSelect: multiSelect, + onRemove: removeBlocks + }; +})])(block_editor_keyboard_shortcuts_BlockEditorKeyboardShortcuts)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/skip-to-selected-block/index.js + + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + +var skip_to_selected_block_SkipToSelectedBlock = function SkipToSelectedBlock(_ref) { + var selectedBlockClientId = _ref.selectedBlockClientId; + + var onClick = function onClick() { + var selectedBlockElement = getBlockFocusableWrapper(selectedBlockClientId); + selectedBlockElement.focus(); + }; + + return selectedBlockClientId && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Button"], { + isDefault: true, + type: "button", + className: "editor-skip-to-selected-block block-editor-skip-to-selected-block", + onClick: onClick + }, Object(external_this_wp_i18n_["__"])('Skip to the selected block')); +}; + +/* harmony default export */ var skip_to_selected_block = (Object(external_this_wp_data_["withSelect"])(function (select) { + return { + selectedBlockClientId: select('core/block-editor').getBlockSelectionStart() + }; +})(skip_to_selected_block_SkipToSelectedBlock)); + +// EXTERNAL MODULE: external {"this":["wp","tokenList"]} +var external_this_wp_tokenList_ = __webpack_require__(143); +var external_this_wp_tokenList_default = /*#__PURE__*/__webpack_require__.n(external_this_wp_tokenList_); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-styles/index.js + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + + + +/** + * Internal dependencies + */ + + +/** + * Returns the active style from the given className. + * + * @param {Array} styles Block style variations. + * @param {string} className Class name + * + * @return {Object?} The active style. + */ + +function getActiveStyle(styles, className) { + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = undefined; + + try { + for (var _iterator = new external_this_wp_tokenList_default.a(className).values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var style = _step.value; + + if (style.indexOf('is-style-') === -1) { + continue; + } + + var potentialStyleName = style.substring(9); + var activeStyle = Object(external_lodash_["find"])(styles, { + name: potentialStyleName + }); + + if (activeStyle) { + return activeStyle; + } + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return != null) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + + return Object(external_lodash_["find"])(styles, 'isDefault'); +} +/** + * Replaces the active style in the block's className. + * + * @param {string} className Class name. + * @param {Object?} activeStyle The replaced style. + * @param {Object} newStyle The replacing style. + * + * @return {string} The updated className. + */ + +function replaceActiveStyle(className, activeStyle, newStyle) { + var list = new external_this_wp_tokenList_default.a(className); + + if (activeStyle) { + list.remove('is-style-' + activeStyle.name); + } + + list.add('is-style-' + newStyle.name); + return list.value; +} + +function BlockStyles(_ref) { + var styles = _ref.styles, + className = _ref.className, + onChangeClassName = _ref.onChangeClassName, + type = _ref.type, + block = _ref.block, + _ref$onSwitch = _ref.onSwitch, + onSwitch = _ref$onSwitch === void 0 ? external_lodash_["noop"] : _ref$onSwitch, + _ref$onHoverClassName = _ref.onHoverClassName, + onHoverClassName = _ref$onHoverClassName === void 0 ? external_lodash_["noop"] : _ref$onHoverClassName; + + if (!styles || styles.length === 0) { + return null; + } + + if (!type.styles && !Object(external_lodash_["find"])(styles, 'isDefault')) { + styles = [{ + name: 'default', + label: Object(external_this_wp_i18n_["_x"])('Default', 'block style'), + isDefault: true + }].concat(Object(toConsumableArray["a" /* default */])(styles)); + } + + var activeStyle = getActiveStyle(styles, className); + + function updateClassName(style) { + var updatedClassName = replaceActiveStyle(className, activeStyle, style); + onChangeClassName(updatedClassName); + onHoverClassName(null); + onSwitch(); + } + + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-styles block-editor-block-styles" + }, styles.map(function (style) { + var styleClassName = replaceActiveStyle(className, activeStyle, style); + return Object(external_this_wp_element_["createElement"])("div", { + key: style.name, + className: classnames_default()('editor-block-styles__item block-editor-block-styles__item', { + 'is-active': activeStyle === style + }), + onClick: function onClick() { + return updateClassName(style); + }, + onKeyDown: function onKeyDown(event) { + if (external_this_wp_keycodes_["ENTER"] === event.keyCode || external_this_wp_keycodes_["SPACE"] === event.keyCode) { + event.preventDefault(); + updateClassName(style); + } + }, + onMouseEnter: function onMouseEnter() { + return onHoverClassName(styleClassName); + }, + onMouseLeave: function onMouseLeave() { + return onHoverClassName(null); + }, + role: "button", + tabIndex: "0", + "aria-label": style.label || style.name + }, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-styles__item-preview block-editor-block-styles__item-preview" + }, Object(external_this_wp_element_["createElement"])(block_preview, { + viewportWidth: 500, + blocks: type.example ? Object(external_this_wp_blocks_["getBlockFromExample"])(block.name, { + attributes: Object(objectSpread["a" /* default */])({}, type.example.attributes, { + className: styleClassName + }), + innerBlocks: type.example.innerBlocks + }) : Object(external_this_wp_blocks_["cloneBlock"])(block, { + className: styleClassName + }) + })), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-styles__item-label block-editor-block-styles__item-label" + }, style.label || style.name)); + })); +} + +/* harmony default export */ var block_styles = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { + var clientId = _ref2.clientId; + + var _select = select('core/block-editor'), + getBlock = _select.getBlock; + + var _select2 = select('core/blocks'), + getBlockStyles = _select2.getBlockStyles; + + var block = getBlock(clientId); + var blockType = Object(external_this_wp_blocks_["getBlockType"])(block.name); + return { + block: block, + className: block.attributes.className || '', + styles: getBlockStyles(block.name), + type: blockType + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref3) { + var clientId = _ref3.clientId; + return { + onChangeClassName: function onChangeClassName(newClassName) { + dispatch('core/block-editor').updateBlockAttributes(clientId, { + className: newClassName + }); + } + }; +})])(BlockStyles)); + +// EXTERNAL MODULE: external {"this":["wp","wordcount"]} +var external_this_wp_wordcount_ = __webpack_require__(97); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/multi-selection-inspector/index.js + + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + + +function MultiSelectionInspector(_ref) { + var blocks = _ref.blocks; + var words = Object(external_this_wp_wordcount_["count"])(Object(external_this_wp_blocks_["serialize"])(blocks), 'words'); + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-multi-selection-inspector__card block-editor-multi-selection-inspector__card" + }, Object(external_this_wp_element_["createElement"])(BlockIcon, { + icon: Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 24 24" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + d: "M3 5H1v16c0 1.1.9 2 2 2h16v-2H3V5zm18-4H7c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 16H7V3h14v14z" + })), + showColors: true + }), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-multi-selection-inspector__card-content block-editor-multi-selection-inspector__card-content" + }, Object(external_this_wp_element_["createElement"])("div", { + className: "editor-multi-selection-inspector__card-title block-editor-multi-selection-inspector__card-title" + }, + /* translators: %d: number of blocks */ + Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('%d block', '%d blocks', blocks.length), blocks.length)), Object(external_this_wp_element_["createElement"])("div", { + className: "editor-multi-selection-inspector__card-description block-editor-multi-selection-inspector__card-description" + }, + /* translators: %d: number of words */ + Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('%d word', '%d words', words), words)))); +} + +/* harmony default export */ var multi_selection_inspector = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getMultiSelectedBlocks = _select.getMultiSelectedBlocks; + + return { + blocks: getMultiSelectedBlocks() + }; +})(MultiSelectionInspector)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/default-style-picker/index.js + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +function DefaultStylePicker(_ref) { + var blockName = _ref.blockName; + + var _useSelect = Object(external_this_wp_data_["useSelect"])(function (select) { + var settings = select('core/block-editor').getSettings(); + var preferredStyleVariations = settings.__experimentalPreferredStyleVariations; + return { + preferredStyle: Object(external_lodash_["get"])(preferredStyleVariations, ['value', blockName]), + onUpdatePreferredStyleVariations: Object(external_lodash_["get"])(preferredStyleVariations, ['onChange'], null), + styles: select('core/blocks').getBlockStyles(blockName) + }; + }, [blockName]), + preferredStyle = _useSelect.preferredStyle, + onUpdatePreferredStyleVariations = _useSelect.onUpdatePreferredStyleVariations, + styles = _useSelect.styles; + + var selectOptions = Object(external_this_wp_element_["useMemo"])(function () { + return [{ + label: Object(external_this_wp_i18n_["__"])('Not set'), + value: '' + }].concat(Object(toConsumableArray["a" /* default */])(styles.map(function (_ref2) { + var label = _ref2.label, + name = _ref2.name; + return { + label: label, + value: name + }; + }))); + }, [styles]); + var selectOnChange = Object(external_this_wp_element_["useCallback"])(function (blockStyle) { + onUpdatePreferredStyleVariations(blockName, blockStyle); + }, [blockName, onUpdatePreferredStyleVariations]); + return onUpdatePreferredStyleVariations && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SelectControl"], { + options: selectOptions, + value: preferredStyle || '', + label: Object(external_this_wp_i18n_["__"])('Default Style'), + onChange: selectOnChange + }); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-inspector/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + + + + + + + + +var block_inspector_BlockInspector = function BlockInspector(_ref) { + var blockType = _ref.blockType, + count = _ref.count, + hasBlockStyles = _ref.hasBlockStyles, + selectedBlockClientId = _ref.selectedBlockClientId, + selectedBlockName = _ref.selectedBlockName, + _ref$showNoBlockSelec = _ref.showNoBlockSelectedMessage, + showNoBlockSelectedMessage = _ref$showNoBlockSelec === void 0 ? true : _ref$showNoBlockSelec; + + if (count > 1) { + return Object(external_this_wp_element_["createElement"])(multi_selection_inspector, null); + } + + var isSelectedBlockUnregistered = selectedBlockName === Object(external_this_wp_blocks_["getUnregisteredTypeHandlerName"])(); + /* + * If the selected block is of an unregistered type, avoid showing it as an actual selection + * because we want the user to focus on the unregistered block warning, not block settings. + */ + + if (!blockType || !selectedBlockClientId || isSelectedBlockUnregistered) { + if (showNoBlockSelectedMessage) { + return Object(external_this_wp_element_["createElement"])("span", { + className: "editor-block-inspector__no-blocks block-editor-block-inspector__no-blocks" + }, Object(external_this_wp_i18n_["__"])('No block selected.')); + } + + return null; + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(block_card, { + blockType: blockType + }), hasBlockStyles && Object(external_this_wp_element_["createElement"])("div", null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + title: Object(external_this_wp_i18n_["__"])('Styles'), + initialOpen: false + }, Object(external_this_wp_element_["createElement"])(block_styles, { + clientId: selectedBlockClientId + }), Object(external_this_wp_element_["createElement"])(DefaultStylePicker, { + blockName: blockType.name + }))), Object(external_this_wp_element_["createElement"])("div", null, Object(external_this_wp_element_["createElement"])(inspector_controls.Slot, null)), Object(external_this_wp_element_["createElement"])("div", null, Object(external_this_wp_element_["createElement"])(inspector_advanced_controls.Slot, null, function (fills) { + return !Object(external_lodash_["isEmpty"])(fills) && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + className: "editor-block-inspector__advanced block-editor-block-inspector__advanced", + title: Object(external_this_wp_i18n_["__"])('Advanced'), + initialOpen: false + }, fills); + })), Object(external_this_wp_element_["createElement"])(skip_to_selected_block, { + key: "back" + })); +}; + +/* harmony default export */ var block_inspector = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getSelectedBlockClientId = _select.getSelectedBlockClientId, + getSelectedBlockCount = _select.getSelectedBlockCount, + getBlockName = _select.getBlockName; + + var _select2 = select('core/blocks'), + getBlockStyles = _select2.getBlockStyles; + + var selectedBlockClientId = getSelectedBlockClientId(); + var selectedBlockName = selectedBlockClientId && getBlockName(selectedBlockClientId); + var blockType = selectedBlockClientId && Object(external_this_wp_blocks_["getBlockType"])(selectedBlockName); + var blockStyles = selectedBlockClientId && getBlockStyles(selectedBlockName); + return { + count: getSelectedBlockCount(), + hasBlockStyles: blockStyles && blockStyles.length > 0, + selectedBlockName: selectedBlockName, + selectedBlockClientId: selectedBlockClientId, + blockType: blockType + }; +})(block_inspector_BlockInspector)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-selection-clearer/index.js + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + +var block_selection_clearer_BlockSelectionClearer = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockSelectionClearer, _Component); + + function BlockSelectionClearer() { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockSelectionClearer); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockSelectionClearer).apply(this, arguments)); + _this.bindContainer = _this.bindContainer.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.clearSelectionIfFocusTarget = _this.clearSelectionIfFocusTarget.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(BlockSelectionClearer, [{ + key: "bindContainer", + value: function bindContainer(ref) { + this.container = ref; + } + /** + * Clears the selected block on focus if the container is the target of the + * focus. This assumes no other descendents have received focus until event + * has bubbled to the container. + * + * @param {FocusEvent} event Focus event. + */ + + }, { + key: "clearSelectionIfFocusTarget", + value: function clearSelectionIfFocusTarget(event) { + var _this$props = this.props, + hasSelectedBlock = _this$props.hasSelectedBlock, + hasMultiSelection = _this$props.hasMultiSelection, + clearSelectedBlock = _this$props.clearSelectedBlock; + var hasSelection = hasSelectedBlock || hasMultiSelection; + + if (event.target === this.container && hasSelection) { + clearSelectedBlock(); + } + } + }, { + key: "render", + value: function render() { + return Object(external_this_wp_element_["createElement"])("div", Object(esm_extends["a" /* default */])({ + tabIndex: -1, + onFocus: this.clearSelectionIfFocusTarget, + ref: this.bindContainer + }, Object(external_lodash_["omit"])(this.props, ['clearSelectedBlock', 'hasSelectedBlock', 'hasMultiSelection']))); + } + }]); + + return BlockSelectionClearer; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var block_selection_clearer = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + hasSelectedBlock = _select.hasSelectedBlock, + hasMultiSelection = _select.hasMultiSelection; + + return { + hasSelectedBlock: hasSelectedBlock(), + hasMultiSelection: hasMultiSelection() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/block-editor'), + clearSelectedBlock = _dispatch.clearSelectedBlock; + + return { + clearSelectedBlock: clearSelectedBlock + }; +})])(block_selection_clearer_BlockSelectionClearer)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-mode-toggle.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +function BlockModeToggle(_ref) { + var blockType = _ref.blockType, + mode = _ref.mode, + onToggleMode = _ref.onToggleMode, + _ref$small = _ref.small, + small = _ref$small === void 0 ? false : _ref$small, + _ref$isCodeEditingEna = _ref.isCodeEditingEnabled, + isCodeEditingEnabled = _ref$isCodeEditingEna === void 0 ? true : _ref$isCodeEditingEna; + + if (!Object(external_this_wp_blocks_["hasBlockSupport"])(blockType, 'html', true) || !isCodeEditingEnabled) { + return null; + } + + var label = mode === 'visual' ? Object(external_this_wp_i18n_["__"])('Edit as HTML') : Object(external_this_wp_i18n_["__"])('Edit visually'); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuItem"], { + className: "editor-block-settings-menu__control block-editor-block-settings-menu__control", + onClick: onToggleMode, + icon: "html" + }, !small && label); +} +/* harmony default export */ var block_mode_toggle = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select, _ref2) { + var clientId = _ref2.clientId; + + var _select = select('core/block-editor'), + getBlock = _select.getBlock, + getBlockMode = _select.getBlockMode, + getSettings = _select.getSettings; + + var block = getBlock(clientId); + var isCodeEditingEnabled = getSettings().codeEditingEnabled; + return { + mode: getBlockMode(clientId), + blockType: block ? Object(external_this_wp_blocks_["getBlockType"])(block.name) : null, + isCodeEditingEnabled: isCodeEditingEnabled + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref3) { + var _ref3$onToggle = _ref3.onToggle, + onToggle = _ref3$onToggle === void 0 ? external_lodash_["noop"] : _ref3$onToggle, + clientId = _ref3.clientId; + return { + onToggleMode: function onToggleMode() { + dispatch('core/block-editor').toggleBlockMode(clientId); + onToggle(); + } + }; +})])(BlockModeToggle)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-convert-button.js + + +/** + * WordPress dependencies + */ + + +function BlockConvertButton(_ref) { + var shouldRender = _ref.shouldRender, + onClick = _ref.onClick, + small = _ref.small; + + if (!shouldRender) { + return null; + } + + var label = Object(external_this_wp_i18n_["__"])('Convert to Blocks'); + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuItem"], { + className: "editor-block-settings-menu__control block-editor-block-settings-menu__control", + onClick: onClick, + icon: "screenoptions" + }, !small && label); +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-html-convert-button.js +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + +/* harmony default export */ var block_html_convert_button = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select, _ref) { + var clientId = _ref.clientId; + var block = select('core/block-editor').getBlock(clientId); + return { + block: block, + shouldRender: block && block.name === 'core/html' + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref2) { + var block = _ref2.block; + return { + onClick: function onClick() { + return dispatch('core/block-editor').replaceBlocks(block.clientId, Object(external_this_wp_blocks_["rawHandler"])({ + HTML: Object(external_this_wp_blocks_["getBlockContent"])(block) + })); + } + }; +}))(BlockConvertButton)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/block-unknown-convert-button.js +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + +/* harmony default export */ var block_unknown_convert_button = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select, _ref) { + var clientId = _ref.clientId; + var block = select('core/block-editor').getBlock(clientId); + return { + block: block, + shouldRender: block && block.name === Object(external_this_wp_blocks_["getFreeformContentHandlerName"])() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, _ref2) { + var block = _ref2.block; + return { + onClick: function onClick() { + return dispatch('core/block-editor').replaceBlocks(block.clientId, Object(external_this_wp_blocks_["rawHandler"])({ + HTML: Object(external_this_wp_blocks_["serialize"])(block) + })); + } + }; +}))(BlockConvertButton)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-settings-menu/index.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + + + + + +var block_settings_menu_POPOVER_PROPS = { + className: 'block-editor-block-settings-menu__popover editor-block-settings-menu__popover', + position: 'bottom right' +}; +function BlockSettingsMenu(_ref) { + var clientIds = _ref.clientIds; + var blockClientIds = Object(external_lodash_["castArray"])(clientIds); + var count = blockClientIds.length; + var firstBlockClientId = blockClientIds[0]; + return Object(external_this_wp_element_["createElement"])(block_actions, { + clientIds: clientIds + }, function (_ref2) { + var canDuplicate = _ref2.canDuplicate, + canInsertDefaultBlock = _ref2.canInsertDefaultBlock, + isLocked = _ref2.isLocked, + onDuplicate = _ref2.onDuplicate, + onInsertAfter = _ref2.onInsertAfter, + onInsertBefore = _ref2.onInsertBefore, + onRemove = _ref2.onRemove; + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Toolbar"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["DropdownMenu"], { + icon: "ellipsis", + label: Object(external_this_wp_i18n_["__"])('More options'), + className: "block-editor-block-settings-menu", + popoverProps: block_settings_menu_POPOVER_PROPS + }, function (_ref3) { + var onClose = _ref3.onClose; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuGroup"], null, Object(external_this_wp_element_["createElement"])(block_settings_menu_first_item.Slot, { + fillProps: { + onClose: onClose + } + }), count === 1 && Object(external_this_wp_element_["createElement"])(block_unknown_convert_button, { + clientId: firstBlockClientId + }), count === 1 && Object(external_this_wp_element_["createElement"])(block_html_convert_button, { + clientId: firstBlockClientId + }), canDuplicate && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuItem"], { + className: "editor-block-settings-menu__control block-editor-block-settings-menu__control", + onClick: Object(external_lodash_["flow"])(onClose, onDuplicate), + icon: "admin-page", + shortcut: shortcuts.duplicate.display + }, Object(external_this_wp_i18n_["__"])('Duplicate')), canInsertDefaultBlock && Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuItem"], { + className: "editor-block-settings-menu__control block-editor-block-settings-menu__control", + onClick: Object(external_lodash_["flow"])(onClose, onInsertBefore), + icon: "insert-before", + shortcut: shortcuts.insertBefore.display + }, Object(external_this_wp_i18n_["__"])('Insert Before')), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuItem"], { + className: "editor-block-settings-menu__control block-editor-block-settings-menu__control", + onClick: Object(external_lodash_["flow"])(onClose, onInsertAfter), + icon: "insert-after", + shortcut: shortcuts.insertAfter.display + }, Object(external_this_wp_i18n_["__"])('Insert After'))), count === 1 && Object(external_this_wp_element_["createElement"])(block_mode_toggle, { + clientId: firstBlockClientId, + onToggle: onClose + }), Object(external_this_wp_element_["createElement"])(block_settings_menu_plugins_extension.Slot, { + fillProps: { + clientIds: clientIds, + onClose: onClose + } + })), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuGroup"], null, !isLocked && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["MenuItem"], { + className: "editor-block-settings-menu__control block-editor-block-settings-menu__control", + onClick: Object(external_lodash_["flow"])(onClose, onRemove), + icon: "trash", + shortcut: shortcuts.removeBlock.display + }, Object(external_this_wp_i18n_["_n"])('Remove Block', 'Remove Blocks', count)))); + })); + }); +} +/* harmony default export */ var block_settings_menu = (BlockSettingsMenu); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/index.js + + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + + + +/** + * Internal dependencies + */ + + + + + +var block_switcher_BlockSwitcher = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(BlockSwitcher, _Component); + + function BlockSwitcher() { + var _this; + + Object(classCallCheck["a" /* default */])(this, BlockSwitcher); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(BlockSwitcher).apply(this, arguments)); + _this.state = { + hoveredClassName: null + }; + _this.onHoverClassName = _this.onHoverClassName.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(BlockSwitcher, [{ + key: "onHoverClassName", + value: function onHoverClassName(className) { + this.setState({ + hoveredClassName: className + }); + } + }, { + key: "render", + value: function render() { + var _this2 = this; + + var _this$props = this.props, + blocks = _this$props.blocks, + onTransform = _this$props.onTransform, + inserterItems = _this$props.inserterItems, + hasBlockStyles = _this$props.hasBlockStyles; + var hoveredClassName = this.state.hoveredClassName; + + if (!blocks || !blocks.length) { + return null; + } + + var hoveredBlock = hoveredClassName ? blocks[0] : null; + var hoveredBlockType = hoveredClassName ? Object(external_this_wp_blocks_["getBlockType"])(hoveredBlock.name) : null; + var itemsByName = Object(external_lodash_["mapKeys"])(inserterItems, function (_ref) { + var name = _ref.name; + return name; + }); + var possibleBlockTransformations = Object(external_lodash_["orderBy"])(Object(external_lodash_["filter"])(Object(external_this_wp_blocks_["getPossibleBlockTransformations"])(blocks), function (block) { + return block && !!itemsByName[block.name]; + }), function (block) { + return itemsByName[block.name].frecency; + }, 'desc'); // When selection consists of blocks of multiple types, display an + // appropriate icon to communicate the non-uniformity. + + var isSelectionOfSameType = Object(external_lodash_["uniq"])(Object(external_lodash_["map"])(blocks, 'name')).length === 1; + var icon; + + if (isSelectionOfSameType) { + var sourceBlockName = blocks[0].name; + var blockType = Object(external_this_wp_blocks_["getBlockType"])(sourceBlockName); + icon = blockType.icon; + } else { + icon = 'layout'; + } + + if (!hasBlockStyles && !possibleBlockTransformations.length) { + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Toolbar"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + disabled: true, + className: "editor-block-switcher__no-switcher-icon block-editor-block-switcher__no-switcher-icon", + label: Object(external_this_wp_i18n_["__"])('Block icon'), + icon: Object(external_this_wp_element_["createElement"])(BlockIcon, { + icon: icon, + showColors: true + }) + })); + } + + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Dropdown"], { + position: "bottom right", + className: "editor-block-switcher block-editor-block-switcher", + contentClassName: "editor-block-switcher__popover block-editor-block-switcher__popover", + renderToggle: function renderToggle(_ref2) { + var onToggle = _ref2.onToggle, + isOpen = _ref2.isOpen; + + var openOnArrowDown = function openOnArrowDown(event) { + if (!isOpen && event.keyCode === external_this_wp_keycodes_["DOWN"]) { + event.preventDefault(); + event.stopPropagation(); + onToggle(); + } + }; + + var label = 1 === blocks.length ? Object(external_this_wp_i18n_["__"])('Change block type or style') : Object(external_this_wp_i18n_["sprintf"])(Object(external_this_wp_i18n_["_n"])('Change type of %d block', 'Change type of %d blocks', blocks.length), blocks.length); + return Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Toolbar"], null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["IconButton"], { + className: "editor-block-switcher__toggle block-editor-block-switcher__toggle", + onClick: onToggle, + "aria-haspopup": "true", + "aria-expanded": isOpen, + label: label, + tooltip: label, + onKeyDown: openOnArrowDown, + icon: Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(BlockIcon, { + icon: icon, + showColors: true + }), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["SVG"], { + className: "editor-block-switcher__transform block-editor-block-switcher__transform", + xmlns: "http://www.w3.org/2000/svg", + viewBox: "0 0 24 24" + }, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["Path"], { + d: "M6.5 8.9c.6-.6 1.4-.9 2.2-.9h6.9l-1.3 1.3 1.4 1.4L19.4 7l-3.7-3.7-1.4 1.4L15.6 6H8.7c-1.4 0-2.6.5-3.6 1.5l-2.8 2.8 1.4 1.4 2.8-2.8zm13.8 2.4l-2.8 2.8c-.6.6-1.3.9-2.1.9h-7l1.3-1.3-1.4-1.4L4.6 16l3.7 3.7 1.4-1.4L8.4 17h6.9c1.3 0 2.6-.5 3.5-1.5l2.8-2.8-1.3-1.4z" + }))) + })); + }, + renderContent: function renderContent(_ref3) { + var onClose = _ref3.onClose; + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, (hasBlockStyles || possibleBlockTransformations.length !== 0) && Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-block-switcher__container" + }, hasBlockStyles && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + title: Object(external_this_wp_i18n_["__"])('Block Styles'), + initialOpen: true + }, Object(external_this_wp_element_["createElement"])(block_styles, { + clientId: blocks[0].clientId, + onSwitch: onClose, + onHoverClassName: _this2.onHoverClassName + })), possibleBlockTransformations.length !== 0 && Object(external_this_wp_element_["createElement"])(external_this_wp_components_["PanelBody"], { + title: Object(external_this_wp_i18n_["__"])('Transform To:'), + initialOpen: true + }, Object(external_this_wp_element_["createElement"])(block_types_list, { + items: possibleBlockTransformations.map(function (destinationBlockType) { + return { + id: destinationBlockType.name, + icon: destinationBlockType.icon, + title: destinationBlockType.title + }; + }), + onSelect: function onSelect(item) { + onTransform(blocks, item.id); + onClose(); + } + }))), hoveredClassName !== null && Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-block-switcher__preview" + }, Object(external_this_wp_element_["createElement"])("div", { + className: "block-editor-block-switcher__preview-title" + }, Object(external_this_wp_i18n_["__"])('Preview')), Object(external_this_wp_element_["createElement"])(block_preview, { + viewportWidth: 500, + blocks: hoveredBlockType.example ? Object(external_this_wp_blocks_["getBlockFromExample"])(hoveredBlock.name, { + attributes: Object(objectSpread["a" /* default */])({}, hoveredBlockType.example.attributes, { + className: hoveredClassName + }), + innerBlocks: hoveredBlockType.example.innerBlocks + }) : Object(external_this_wp_blocks_["cloneBlock"])(hoveredBlock, { + className: hoveredClassName + }) + }))); + } + }); + } + }]); + + return BlockSwitcher; +}(external_this_wp_element_["Component"]); +/* harmony default export */ var block_switcher = (Object(external_this_wp_compose_["compose"])(Object(external_this_wp_data_["withSelect"])(function (select, _ref4) { + var clientIds = _ref4.clientIds; + + var _select = select('core/block-editor'), + getBlocksByClientId = _select.getBlocksByClientId, + getBlockRootClientId = _select.getBlockRootClientId, + getInserterItems = _select.getInserterItems; + + var _select2 = select('core/blocks'), + getBlockStyles = _select2.getBlockStyles; + + var rootClientId = getBlockRootClientId(Object(external_lodash_["first"])(Object(external_lodash_["castArray"])(clientIds))); + var blocks = getBlocksByClientId(clientIds); + var firstBlock = blocks && blocks.length === 1 ? blocks[0] : null; + var styles = firstBlock && getBlockStyles(firstBlock.name); + return { + blocks: blocks, + inserterItems: getInserterItems(rootClientId), + hasBlockStyles: styles && styles.length > 0 + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch, ownProps) { + return { + onTransform: function onTransform(blocks, name) { + dispatch('core/block-editor').replaceBlocks(ownProps.clientIds, Object(external_this_wp_blocks_["switchToBlockType"])(blocks, name)); + } + }; +}))(block_switcher_BlockSwitcher)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-switcher/multi-blocks-switcher.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + +function MultiBlocksSwitcher(_ref) { + var isMultiBlockSelection = _ref.isMultiBlockSelection, + selectedBlockClientIds = _ref.selectedBlockClientIds; + + if (!isMultiBlockSelection) { + return null; + } + + return Object(external_this_wp_element_["createElement"])(block_switcher, { + key: "switcher", + clientIds: selectedBlockClientIds + }); +} +/* harmony default export */ var multi_blocks_switcher = (Object(external_this_wp_data_["withSelect"])(function (select) { + var selectedBlockClientIds = select('core/block-editor').getMultiSelectedBlockClientIds(); + return { + isMultiBlockSelection: selectedBlockClientIds.length > 1, + selectedBlockClientIds: selectedBlockClientIds + }; +})(MultiBlocksSwitcher)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/block-toolbar/index.js + + +/** + * WordPress dependencies + */ + +/** + * Internal dependencies + */ + + + + + + + +function BlockToolbar(_ref) { + var blockClientIds = _ref.blockClientIds, + isValid = _ref.isValid, + mode = _ref.mode; + + if (blockClientIds.length === 0) { + return null; + } + + if (blockClientIds.length > 1) { + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-toolbar block-editor-block-toolbar" + }, Object(external_this_wp_element_["createElement"])(multi_blocks_switcher, null), Object(external_this_wp_element_["createElement"])(block_settings_menu, { + clientIds: blockClientIds + })); + } + + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-block-toolbar block-editor-block-toolbar" + }, mode === 'visual' && isValid && Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(block_switcher, { + clientIds: blockClientIds + }), Object(external_this_wp_element_["createElement"])(block_controls.Slot, { + bubblesVirtually: true, + className: "block-editor-block-toolbar__slot" + }), Object(external_this_wp_element_["createElement"])(block_format_controls.Slot, { + bubblesVirtually: true, + className: "block-editor-block-toolbar__slot" + })), Object(external_this_wp_element_["createElement"])(block_settings_menu, { + clientIds: blockClientIds + })); +} + +/* harmony default export */ var block_toolbar = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getBlockMode = _select.getBlockMode, + getSelectedBlockClientIds = _select.getSelectedBlockClientIds, + isBlockValid = _select.isBlockValid; + + var blockClientIds = getSelectedBlockClientIds(); + return { + blockClientIds: blockClientIds, + isValid: blockClientIds.length === 1 ? isBlockValid(blockClientIds[0]) : null, + mode: blockClientIds.length === 1 ? getBlockMode(blockClientIds[0]) : null + }; +})(BlockToolbar)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/copy-handler/index.js + + +/** + * WordPress dependencies + */ + + + + + +function CopyHandler(_ref) { + var children = _ref.children, + onCopy = _ref.onCopy, + onCut = _ref.onCut; + return Object(external_this_wp_element_["createElement"])("div", { + onCopy: onCopy, + onCut: onCut + }, children); +} + +/* harmony default export */ var copy_handler = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withDispatch"])(function (dispatch, ownProps, _ref2) { + var select = _ref2.select; + + var _select = select('core/block-editor'), + getBlocksByClientId = _select.getBlocksByClientId, + getSelectedBlockClientIds = _select.getSelectedBlockClientIds, + hasMultiSelection = _select.hasMultiSelection; + + var _dispatch = dispatch('core/block-editor'), + removeBlocks = _dispatch.removeBlocks; + + var onCopy = function onCopy(event) { + var selectedBlockClientIds = getSelectedBlockClientIds(); + + if (selectedBlockClientIds.length === 0) { + return; + } // Let native copy behaviour take over in input fields. + + + if (!hasMultiSelection() && Object(external_this_wp_dom_["documentHasSelection"])()) { + return; + } + + var serialized = Object(external_this_wp_blocks_["serialize"])(getBlocksByClientId(selectedBlockClientIds)); + event.clipboardData.setData('text/plain', serialized); + event.clipboardData.setData('text/html', serialized); + event.preventDefault(); + }; + + return { + onCopy: onCopy, + onCut: function onCut(event) { + onCopy(event); + + if (hasMultiSelection()) { + var selectedBlockClientIds = getSelectedBlockClientIds(); + removeBlocks(selectedBlockClientIds); + } + } + }; +})])(CopyHandler)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/multi-select-scroll-into-view/index.js + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + +/** + * Internal dependencies + */ + + + +var multi_select_scroll_into_view_MultiSelectScrollIntoView = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(MultiSelectScrollIntoView, _Component); + + function MultiSelectScrollIntoView() { + Object(classCallCheck["a" /* default */])(this, MultiSelectScrollIntoView); + + return Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(MultiSelectScrollIntoView).apply(this, arguments)); + } + + Object(createClass["a" /* default */])(MultiSelectScrollIntoView, [{ + key: "componentDidUpdate", + value: function componentDidUpdate() { + // Relies on expectation that `componentDidUpdate` will only be called + // if value of `extentClientId` changes. + this.scrollIntoView(); + } + /** + * Ensures that if a multi-selection exists, the extent of the selection is + * visible within the nearest scrollable container. + */ + + }, { + key: "scrollIntoView", + value: function scrollIntoView() { + var extentClientId = this.props.extentClientId; + + if (!extentClientId) { + return; + } + + var extentNode = getBlockDOMNode(extentClientId); + + if (!extentNode) { + return; + } + + var scrollContainer = Object(external_this_wp_dom_["getScrollContainer"])(extentNode); // If there's no scroll container, it follows that there's no scrollbar + // and thus there's no need to try to scroll into view. + + if (!scrollContainer) { + return; + } + + lib_default()(extentNode, scrollContainer, { + onlyScrollIfNeeded: true + }); + } + }, { + key: "render", + value: function render() { + return null; + } + }]); + + return MultiSelectScrollIntoView; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var multi_select_scroll_into_view = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getLastMultiSelectedBlockClientId = _select.getLastMultiSelectedBlockClientId; + + return { + extentClientId: getLastMultiSelectedBlockClientId() + }; +})(multi_select_scroll_into_view_MultiSelectScrollIntoView)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/observe-typing/index.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Set of key codes upon which typing is to be initiated on a keydown event. + * + * @type {number[]} + */ + +var KEY_DOWN_ELIGIBLE_KEY_CODES = [external_this_wp_keycodes_["UP"], external_this_wp_keycodes_["RIGHT"], external_this_wp_keycodes_["DOWN"], external_this_wp_keycodes_["LEFT"], external_this_wp_keycodes_["ENTER"], external_this_wp_keycodes_["BACKSPACE"]]; +/** + * Returns true if a given keydown event can be inferred as intent to start + * typing, or false otherwise. A keydown is considered eligible if it is a + * text navigation without shift active. + * + * @param {KeyboardEvent} event Keydown event to test. + * + * @return {boolean} Whether event is eligible to start typing. + */ + +function isKeyDownEligibleForStartTyping(event) { + var keyCode = event.keyCode, + shiftKey = event.shiftKey; + return !shiftKey && Object(external_lodash_["includes"])(KEY_DOWN_ELIGIBLE_KEY_CODES, keyCode); +} + +var observe_typing_ObserveTyping = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(ObserveTyping, _Component); + + function ObserveTyping() { + var _this; + + Object(classCallCheck["a" /* default */])(this, ObserveTyping); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(ObserveTyping).apply(this, arguments)); + _this.stopTypingOnSelectionUncollapse = _this.stopTypingOnSelectionUncollapse.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.stopTypingOnMouseMove = _this.stopTypingOnMouseMove.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.startTypingInTextField = _this.startTypingInTextField.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.stopTypingOnNonTextField = _this.stopTypingOnNonTextField.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.stopTypingOnEscapeKey = _this.stopTypingOnEscapeKey.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onKeyDown = Object(external_lodash_["over"])([_this.startTypingInTextField, _this.stopTypingOnEscapeKey]); + _this.lastMouseMove = null; + return _this; + } + + Object(createClass["a" /* default */])(ObserveTyping, [{ + key: "componentDidMount", + value: function componentDidMount() { + this.toggleEventBindings(this.props.isTyping); + } + }, { + key: "componentDidUpdate", + value: function componentDidUpdate(prevProps) { + if (this.props.isTyping !== prevProps.isTyping) { + this.toggleEventBindings(this.props.isTyping); + } + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + this.toggleEventBindings(false); + } + /** + * Bind or unbind events to the document when typing has started or stopped + * respectively, or when component has become unmounted. + * + * @param {boolean} isBound Whether event bindings should be applied. + */ + + }, { + key: "toggleEventBindings", + value: function toggleEventBindings(isBound) { + var bindFn = isBound ? 'addEventListener' : 'removeEventListener'; + document[bindFn]('selectionchange', this.stopTypingOnSelectionUncollapse); + document[bindFn]('mousemove', this.stopTypingOnMouseMove); + } + /** + * On mouse move, unset typing flag if user has moved cursor. + * + * @param {MouseEvent} event Mousemove event. + */ + + }, { + key: "stopTypingOnMouseMove", + value: function stopTypingOnMouseMove(event) { + var clientX = event.clientX, + clientY = event.clientY; // We need to check that the mouse really moved because Safari triggers + // mousemove events when shift or ctrl are pressed. + + if (this.lastMouseMove) { + var _this$lastMouseMove = this.lastMouseMove, + lastClientX = _this$lastMouseMove.clientX, + lastClientY = _this$lastMouseMove.clientY; + + if (lastClientX !== clientX || lastClientY !== clientY) { + this.props.onStopTyping(); + } + } + + this.lastMouseMove = { + clientX: clientX, + clientY: clientY + }; + } + /** + * On selection change, unset typing flag if user has made an uncollapsed + * (shift) selection. + */ + + }, { + key: "stopTypingOnSelectionUncollapse", + value: function stopTypingOnSelectionUncollapse() { + var selection = window.getSelection(); + var isCollapsed = selection.rangeCount > 0 && selection.getRangeAt(0).collapsed; + + if (!isCollapsed) { + this.props.onStopTyping(); + } + } + /** + * Unsets typing flag if user presses Escape while typing flag is active. + * + * @param {KeyboardEvent} event Keypress or keydown event to interpret. + */ + + }, { + key: "stopTypingOnEscapeKey", + value: function stopTypingOnEscapeKey(event) { + if (this.props.isTyping && event.keyCode === external_this_wp_keycodes_["ESCAPE"]) { + this.props.onStopTyping(); + } + } + /** + * Handles a keypress or keydown event to infer intention to start typing. + * + * @param {KeyboardEvent} event Keypress or keydown event to interpret. + */ + + }, { + key: "startTypingInTextField", + value: function startTypingInTextField(event) { + var _this$props = this.props, + isTyping = _this$props.isTyping, + onStartTyping = _this$props.onStartTyping; + var type = event.type, + target = event.target; // Abort early if already typing, or key press is incurred outside a + // text field (e.g. arrow-ing through toolbar buttons). + // Ignore typing in a block toolbar + + if (isTyping || !Object(external_this_wp_dom_["isTextField"])(target) || target.closest('.block-editor-block-toolbar')) { + return; + } // Special-case keydown because certain keys do not emit a keypress + // event. Conversely avoid keydown as the canonical event since there + // are many keydown which are explicitly not targeted for typing. + + + if (type === 'keydown' && !isKeyDownEligibleForStartTyping(event)) { + return; + } + + onStartTyping(); + } + /** + * Stops typing when focus transitions to a non-text field element. + * + * @param {FocusEvent} event Focus event. + */ + + }, { + key: "stopTypingOnNonTextField", + value: function stopTypingOnNonTextField(event) { + var _this2 = this; + + event.persist(); // Since focus to a non-text field via arrow key will trigger before + // the keydown event, wait until after current stack before evaluating + // whether typing is to be stopped. Otherwise, typing will re-start. + + this.props.setTimeout(function () { + var _this2$props = _this2.props, + isTyping = _this2$props.isTyping, + onStopTyping = _this2$props.onStopTyping; + var target = event.target; + + if (isTyping && !Object(external_this_wp_dom_["isTextField"])(target)) { + onStopTyping(); + } + }); + } + }, { + key: "render", + value: function render() { + var children = this.props.children; // Disable reason: This component is responsible for capturing bubbled + // keyboard events which are interpreted as typing intent. + + /* eslint-disable jsx-a11y/no-static-element-interactions */ + + return Object(external_this_wp_element_["createElement"])("div", { + onFocus: this.stopTypingOnNonTextField, + onKeyPress: this.startTypingInTextField, + onKeyDown: this.onKeyDown + }, children); + /* eslint-enable jsx-a11y/no-static-element-interactions */ + } + }]); + + return ObserveTyping; +}(external_this_wp_element_["Component"]); +/** + * @see https://github.com/WordPress/gutenberg/blob/master/packages/block-editor/src/components/observe-typing/README.md + */ + + +/* harmony default export */ var observe_typing = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + isTyping = _select.isTyping; + + return { + isTyping: isTyping() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/block-editor'), + startTyping = _dispatch.startTyping, + stopTyping = _dispatch.stopTyping; + + return { + onStartTyping: startTyping, + onStopTyping: stopTyping + }; +}), external_this_wp_compose_["withSafeTimeout"]])(observe_typing_ObserveTyping)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/preserve-scroll-in-reorder/index.js +/** + * WordPress dependencies + */ + +function PreserveScrollInReorder() { + external_this_wp_deprecated_default()('PreserveScrollInReorder component', { + hint: 'This behavior is now built-in the block list' + }); + return null; +} + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/typewriter/index.js + + + + + + + + +/** + * WordPress dependencies + */ + + + + +var isIE = window.navigator.userAgent.indexOf('Trident') !== -1; +var arrowKeyCodes = new Set([external_this_wp_keycodes_["UP"], external_this_wp_keycodes_["DOWN"], external_this_wp_keycodes_["LEFT"], external_this_wp_keycodes_["RIGHT"]]); +var initialTriggerPercentage = 0.75; + +var typewriter_Typewriter = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(Typewriter, _Component); + + function Typewriter() { + var _this; + + Object(classCallCheck["a" /* default */])(this, Typewriter); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(Typewriter).apply(this, arguments)); + _this.ref = Object(external_this_wp_element_["createRef"])(); + _this.onKeyDown = _this.onKeyDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.addSelectionChangeListener = _this.addSelectionChangeListener.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.computeCaretRectOnSelectionChange = _this.computeCaretRectOnSelectionChange.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.maintainCaretPosition = _this.maintainCaretPosition.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.computeCaretRect = _this.computeCaretRect.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onScrollResize = _this.onScrollResize.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.isSelectionEligibleForScroll = _this.isSelectionEligibleForScroll.bind(Object(assertThisInitialized["a" /* default */])(_this)); + return _this; + } + + Object(createClass["a" /* default */])(Typewriter, [{ + key: "componentDidMount", + value: function componentDidMount() { + // When the user scrolls or resizes, the scroll position should be + // reset. + window.addEventListener('scroll', this.onScrollResize, true); + window.addEventListener('resize', this.onScrollResize, true); + } + }, { + key: "componentWillUnmount", + value: function componentWillUnmount() { + window.removeEventListener('scroll', this.onScrollResize, true); + window.removeEventListener('resize', this.onScrollResize, true); + document.removeEventListener('selectionchange', this.computeCaretRectOnSelectionChange); + + if (this.onScrollResize.rafId) { + window.cancelAnimationFrame(this.onScrollResize.rafId); + } + + if (this.onKeyDown.rafId) { + window.cancelAnimationFrame(this.onKeyDown.rafId); + } + } + /** + * Resets the scroll position to be maintained. + */ + + }, { + key: "computeCaretRect", + value: function computeCaretRect() { + if (this.isSelectionEligibleForScroll()) { + this.caretRect = Object(external_this_wp_dom_["computeCaretRect"])(); + } + } + /** + * Resets the scroll position to be maintained during a `selectionchange` + * event. Also removes the listener, so it acts as a one-time listener. + */ + + }, { + key: "computeCaretRectOnSelectionChange", + value: function computeCaretRectOnSelectionChange() { + document.removeEventListener('selectionchange', this.computeCaretRectOnSelectionChange); + this.computeCaretRect(); + } + }, { + key: "onScrollResize", + value: function onScrollResize() { + var _this2 = this; + + if (this.onScrollResize.rafId) { + return; + } + + this.onScrollResize.rafId = window.requestAnimationFrame(function () { + _this2.computeCaretRect(); + + delete _this2.onScrollResize.rafId; + }); + } + /** + * Checks if the current situation is elegible for scroll: + * - There should be one and only one block selected. + * - The component must contain the selection. + * - The active element must be contenteditable. + */ + + }, { + key: "isSelectionEligibleForScroll", + value: function isSelectionEligibleForScroll() { + return this.props.selectedBlockClientId && this.ref.current.contains(document.activeElement) && document.activeElement.isContentEditable; + } + }, { + key: "isLastEditableNode", + value: function isLastEditableNode() { + var editableNodes = this.ref.current.querySelectorAll('[contenteditable="true"]'); + var lastEditableNode = editableNodes[editableNodes.length - 1]; + return lastEditableNode === document.activeElement; + } + /** + * Maintains the scroll position after a selection change caused by a + * keyboard event. + * + * @param {SyntheticEvent} event Synthetic keyboard event. + */ + + }, { + key: "maintainCaretPosition", + value: function maintainCaretPosition(_ref) { + var keyCode = _ref.keyCode; + + if (!this.isSelectionEligibleForScroll()) { + return; + } + + var currentCaretRect = Object(external_this_wp_dom_["computeCaretRect"])(); + + if (!currentCaretRect) { + return; + } // If for some reason there is no position set to be scrolled to, let + // this be the position to be scrolled to in the future. + + + if (!this.caretRect) { + this.caretRect = currentCaretRect; + return; + } // Even though enabling the typewriter effect for arrow keys results in + // a pleasant experience, it may not be the case for everyone, so, for + // now, let's disable it. + + + if (arrowKeyCodes.has(keyCode)) { + // Reset the caret position to maintain. + this.caretRect = currentCaretRect; + return; + } + + var diff = currentCaretRect.top - this.caretRect.top; + + if (diff === 0) { + return; + } + + var scrollContainer = Object(external_this_wp_dom_["getScrollContainer"])(this.ref.current); // The page must be scrollable. + + if (!scrollContainer) { + return; + } + + var windowScroll = scrollContainer === document.body; + var scrollY = windowScroll ? window.scrollY : scrollContainer.scrollTop; + var scrollContainerY = windowScroll ? 0 : scrollContainer.getBoundingClientRect().top; + var relativeScrollPosition = windowScroll ? this.caretRect.top / window.innerHeight : (this.caretRect.top - scrollContainerY) / (window.innerHeight - scrollContainerY); // If the scroll position is at the start, the active editable element + // is the last one, and the caret is positioned within the initial + // trigger percentage of the page, do not scroll the page. + // The typewriter effect should not kick in until an empty page has been + // filled with the initial trigger percentage or the user scrolls + // intentionally down. + + if (scrollY === 0 && relativeScrollPosition < initialTriggerPercentage && this.isLastEditableNode()) { + // Reset the caret position to maintain. + this.caretRect = currentCaretRect; + return; + } + + var scrollContainerHeight = windowScroll ? window.innerHeight : scrollContainer.clientHeight; // Abort if the target scroll position would scroll the caret out of + // view. + + if ( // The caret is under the lower fold. + this.caretRect.top + this.caretRect.height > scrollContainerY + scrollContainerHeight || // The caret is above the upper fold. + this.caretRect.top < scrollContainerY) { + // Reset the caret position to maintain. + this.caretRect = currentCaretRect; + return; + } + + if (windowScroll) { + window.scrollBy(0, diff); + } else { + scrollContainer.scrollTop += diff; + } + } + /** + * Adds a `selectionchange` listener to reset the scroll position to be + * maintained. + */ + + }, { + key: "addSelectionChangeListener", + value: function addSelectionChangeListener() { + document.addEventListener('selectionchange', this.computeCaretRectOnSelectionChange); + } + }, { + key: "onKeyDown", + value: function onKeyDown(event) { + var _this3 = this; + + event.persist(); // Ensure the any remaining request is cancelled. + + if (this.onKeyDown.rafId) { + window.cancelAnimationFrame(this.onKeyDown.rafId); + } // Use an animation frame for a smooth result. + + + this.onKeyDown.rafId = window.requestAnimationFrame(function () { + _this3.maintainCaretPosition(event); + + delete _this3.onKeyDown.rafId; + }); + } + }, { + key: "render", + value: function render() { + // There are some issues with Internet Explorer, which are probably not + // worth spending time on. Let's disable it. + if (isIE) { + return this.props.children; + } // Disable reason: Wrapper itself is non-interactive, but must capture + // bubbling events from children to determine focus transition intents. + + /* eslint-disable jsx-a11y/no-static-element-interactions */ + + + return Object(external_this_wp_element_["createElement"])("div", { + ref: this.ref, + onKeyDown: this.onKeyDown, + onKeyUp: this.maintainCaretPosition, + onMouseDown: this.addSelectionChangeListener, + onTouchStart: this.addSelectionChangeListener + }, this.props.children); + /* eslint-enable jsx-a11y/no-static-element-interactions */ + } + }]); + + return Typewriter; +}(external_this_wp_element_["Component"]); +/** + * Ensures that the text selection keeps the same vertical distance from the + * viewport during keyboard events within this component. The vertical distance + * can vary. It is the last clicked or scrolled to position. + */ + + +/* harmony default export */ var typewriter = (Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getSelectedBlockClientId = _select.getSelectedBlockClientId; + + return { + selectedBlockClientId: getSelectedBlockClientId() + }; +})(typewriter_Typewriter)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/writing-flow/index.js + + + + + + + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + +/** + * Browser constants + */ + +var _window = window, + getSelection = _window.getSelection, + getComputedStyle = _window.getComputedStyle; +/** + * Given an element, returns true if the element is a tabbable text field, or + * false otherwise. + * + * @param {Element} element Element to test. + * + * @return {boolean} Whether element is a tabbable text field. + */ + +var isTabbableTextField = Object(external_lodash_["overEvery"])([external_this_wp_dom_["isTextField"], external_this_wp_dom_["focus"].tabbable.isTabbableIndex]); +/** + * Returns true if the element should consider edge navigation upon a keyboard + * event of the given directional key code, or false otherwise. + * + * @param {Element} element HTML element to test. + * @param {number} keyCode KeyboardEvent keyCode to test. + * @param {boolean} hasModifier Whether a modifier is pressed. + * + * @return {boolean} Whether element should consider edge navigation. + */ + +function isNavigationCandidate(element, keyCode, hasModifier) { + var isVertical = keyCode === external_this_wp_keycodes_["UP"] || keyCode === external_this_wp_keycodes_["DOWN"]; // Currently, all elements support unmodified vertical navigation. + + if (isVertical && !hasModifier) { + return true; + } // Native inputs should not navigate horizontally. + + + var tagName = element.tagName; + return tagName !== 'INPUT' && tagName !== 'TEXTAREA'; +} + +var writing_flow_WritingFlow = +/*#__PURE__*/ +function (_Component) { + Object(inherits["a" /* default */])(WritingFlow, _Component); + + function WritingFlow() { + var _this; + + Object(classCallCheck["a" /* default */])(this, WritingFlow); + + _this = Object(possibleConstructorReturn["a" /* default */])(this, Object(getPrototypeOf["a" /* default */])(WritingFlow).apply(this, arguments)); + _this.onKeyDown = _this.onKeyDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.bindContainer = _this.bindContainer.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.onMouseDown = _this.onMouseDown.bind(Object(assertThisInitialized["a" /* default */])(_this)); + _this.focusLastTextField = _this.focusLastTextField.bind(Object(assertThisInitialized["a" /* default */])(_this)); + /** + * Here a rectangle is stored while moving the caret vertically so + * vertical position of the start position can be restored. + * This is to recreate browser behaviour across blocks. + * + * @type {?DOMRect} + */ + + _this.verticalRect = null; + /** + * Reference of the writing flow appender element. + * The reference is used to focus the first tabbable element after the block list + * once we hit `tab` on the last block in navigation mode. + */ + + _this.appender = Object(external_this_wp_element_["createRef"])(); + return _this; + } + + Object(createClass["a" /* default */])(WritingFlow, [{ + key: "bindContainer", + value: function bindContainer(ref) { + this.container = ref; + } + }, { + key: "onMouseDown", + value: function onMouseDown() { + this.verticalRect = null; + this.disableNavigationMode(); + } + }, { + key: "disableNavigationMode", + value: function disableNavigationMode() { + if (this.props.isNavigationMode) { + this.props.disableNavigationMode(); + } + } + /** + * Returns the optimal tab target from the given focused element in the + * desired direction. A preference is made toward text fields, falling back + * to the block focus stop if no other candidates exist for the block. + * + * @param {Element} target Currently focused text field. + * @param {boolean} isReverse True if considering as the first field. + * + * @return {?Element} Optimal tab target, if one exists. + */ + + }, { + key: "getClosestTabbable", + value: function getClosestTabbable(target, isReverse) { + // Since the current focus target is not guaranteed to be a text field, + // find all focusables. Tabbability is considered later. + var focusableNodes = external_this_wp_dom_["focus"].focusable.find(this.container); + + if (isReverse) { + focusableNodes = Object(external_lodash_["reverse"])(focusableNodes); + } // Consider as candidates those focusables after the current target. + // It's assumed this can only be reached if the target is focusable + // (on its keydown event), so no need to verify it exists in the set. + + + focusableNodes = focusableNodes.slice(focusableNodes.indexOf(target) + 1); + + function isTabCandidate(node, i, array) { + // Not a candidate if the node is not tabbable. + if (!external_this_wp_dom_["focus"].tabbable.isTabbableIndex(node)) { + return false; + } // Prefer text fields... + + + if (Object(external_this_wp_dom_["isTextField"])(node)) { + return true; + } // ...but settle for block focus stop. + + + if (!isBlockFocusStop(node)) { + return false; + } // If element contains inner blocks, stop immediately at its focus + // wrapper. + + + if (hasInnerBlocksContext(node)) { + return true; + } // If navigating out of a block (in reverse), don't consider its + // block focus stop. + + + if (node.contains(target)) { + return false; + } // In case of block focus stop, check to see if there's a better + // text field candidate within. + + + for (var offset = 1, nextNode; nextNode = array[i + offset]; offset++) { + // Abort if no longer testing descendents of focus stop. + if (!node.contains(nextNode)) { + break; + } // Apply same tests by recursion. This is important to consider + // nestable blocks where we don't want to settle for the inner + // block focus stop. + + + if (isTabCandidate(nextNode, i + offset, array)) { + return false; + } + } + + return true; + } + + return Object(external_lodash_["find"])(focusableNodes, isTabCandidate); + } + }, { + key: "expandSelection", + value: function expandSelection(isReverse) { + var _this$props = this.props, + selectedBlockClientId = _this$props.selectedBlockClientId, + selectionStartClientId = _this$props.selectionStartClientId, + selectionBeforeEndClientId = _this$props.selectionBeforeEndClientId, + selectionAfterEndClientId = _this$props.selectionAfterEndClientId; + var nextSelectionEndClientId = isReverse ? selectionBeforeEndClientId : selectionAfterEndClientId; + + if (nextSelectionEndClientId) { + this.props.onMultiSelect(selectionStartClientId || selectedBlockClientId, nextSelectionEndClientId); + } + } + }, { + key: "moveSelection", + value: function moveSelection(isReverse) { + var _this$props2 = this.props, + selectedFirstClientId = _this$props2.selectedFirstClientId, + selectedLastClientId = _this$props2.selectedLastClientId; + var focusedBlockClientId = isReverse ? selectedFirstClientId : selectedLastClientId; + + if (focusedBlockClientId) { + this.props.onSelectBlock(focusedBlockClientId); + } + } + /** + * Returns true if the given target field is the last in its block which + * can be considered for tab transition. For example, in a block with two + * text fields, this would return true when reversing from the first of the + * two fields, but false when reversing from the second. + * + * @param {Element} target Currently focused text field. + * @param {boolean} isReverse True if considering as the first field. + * + * @return {boolean} Whether field is at edge for tab transition. + */ + + }, { + key: "isTabbableEdge", + value: function isTabbableEdge(target, isReverse) { + var closestTabbable = this.getClosestTabbable(target, isReverse); + return !closestTabbable || !isInSameBlock(target, closestTabbable); + } + }, { + key: "onKeyDown", + value: function onKeyDown(event) { + var _this$props3 = this.props, + hasMultiSelection = _this$props3.hasMultiSelection, + onMultiSelect = _this$props3.onMultiSelect, + blocks = _this$props3.blocks, + selectedBlockClientId = _this$props3.selectedBlockClientId, + selectionBeforeEndClientId = _this$props3.selectionBeforeEndClientId, + selectionAfterEndClientId = _this$props3.selectionAfterEndClientId, + isNavigationMode = _this$props3.isNavigationMode; + var keyCode = event.keyCode, + target = event.target; + var isUp = keyCode === external_this_wp_keycodes_["UP"]; + var isDown = keyCode === external_this_wp_keycodes_["DOWN"]; + var isLeft = keyCode === external_this_wp_keycodes_["LEFT"]; + var isRight = keyCode === external_this_wp_keycodes_["RIGHT"]; + var isTab = keyCode === external_this_wp_keycodes_["TAB"]; + var isReverse = isUp || isLeft; + var isHorizontal = isLeft || isRight; + var isVertical = isUp || isDown; + var isNav = isHorizontal || isVertical; + var isShift = event.shiftKey; + var hasModifier = isShift || event.ctrlKey || event.altKey || event.metaKey; + var isNavEdge = isVertical ? external_this_wp_dom_["isVerticalEdge"] : external_this_wp_dom_["isHorizontalEdge"]; // In navigation mode, tab and arrows navigate from block to block. + + if (isNavigationMode) { + var navigateUp = isTab && isShift || isUp; + var navigateDown = isTab && !isShift || isDown; + var focusedBlockUid = navigateUp ? selectionBeforeEndClientId : selectionAfterEndClientId; + + if ((navigateDown || navigateUp) && focusedBlockUid) { + event.preventDefault(); + this.props.onSelectBlock(focusedBlockUid); + } // Special case when reaching the end of the blocks (navigate to the next tabbable outside of the writing flow) + + + if (navigateDown && selectedBlockClientId && !selectionAfterEndClientId && [external_this_wp_keycodes_["UP"], external_this_wp_keycodes_["DOWN"]].indexOf(keyCode) === -1) { + this.props.clearSelectedBlock(); + this.appender.current.focus(); + } + + return; + } // When presing any key other than up or down, the initial vertical + // position must ALWAYS be reset. The vertical position is saved so it + // can be restored as well as possible on sebsequent vertical arrow key + // presses. It may not always be possible to restore the exact same + // position (such as at an empty line), so it wouldn't be good to + // compute the position right before any vertical arrow key press. + + + if (!isVertical) { + this.verticalRect = null; + } else if (!this.verticalRect) { + this.verticalRect = Object(external_this_wp_dom_["computeCaretRect"])(); + } // This logic inside this condition needs to be checked before + // the check for event.nativeEvent.defaultPrevented. + // The logic handles meta+a keypress and this event is default prevented + // by RichText. + + + if (!isNav) { + // Set immediately before the meta+a combination can be pressed. + if (external_this_wp_keycodes_["isKeyboardEvent"].primary(event)) { + this.isEntirelySelected = Object(external_this_wp_dom_["isEntirelySelected"])(target); + } + + if (external_this_wp_keycodes_["isKeyboardEvent"].primary(event, 'a')) { + // When the target is contentEditable, selection will already + // have been set by the browser earlier in this call stack. We + // need check the previous result, otherwise all blocks will be + // selected right away. + if (target.isContentEditable ? this.isEntirelySelected : Object(external_this_wp_dom_["isEntirelySelected"])(target)) { + onMultiSelect(Object(external_lodash_["first"])(blocks), Object(external_lodash_["last"])(blocks)); + event.preventDefault(); + } // After pressing primary + A we can assume isEntirelySelected is true. + // Calling right away isEntirelySelected after primary + A may still return false on some browsers. + + + this.isEntirelySelected = true; + } + + return; + } // Abort if navigation has already been handled (e.g. RichText inline + // boundaries). + + + if (event.nativeEvent.defaultPrevented) { + return; + } // Abort if our current target is not a candidate for navigation (e.g. + // preserve native input behaviors). + + + if (!isNavigationCandidate(target, keyCode, hasModifier)) { + return; + } // In the case of RTL scripts, right means previous and left means next, + // which is the exact reverse of LTR. + + + var _getComputedStyle = getComputedStyle(target), + direction = _getComputedStyle.direction; + + var isReverseDir = direction === 'rtl' ? !isReverse : isReverse; + + if (isShift) { + if (( // Ensure that there is a target block. + isReverse && selectionBeforeEndClientId || !isReverse && selectionAfterEndClientId) && (hasMultiSelection || this.isTabbableEdge(target, isReverse) && isNavEdge(target, isReverse))) { + // Shift key is down, and there is multi selection or we're at + // the end of the current block. + this.expandSelection(isReverse); + event.preventDefault(); + } + } else if (hasMultiSelection) { + // Moving from block multi-selection to single block selection + this.moveSelection(isReverse); + event.preventDefault(); + } else if (isVertical && Object(external_this_wp_dom_["isVerticalEdge"])(target, isReverse)) { + var closestTabbable = this.getClosestTabbable(target, isReverse); + + if (closestTabbable) { + Object(external_this_wp_dom_["placeCaretAtVerticalEdge"])(closestTabbable, isReverse, this.verticalRect); + event.preventDefault(); + } + } else if (isHorizontal && getSelection().isCollapsed && Object(external_this_wp_dom_["isHorizontalEdge"])(target, isReverseDir)) { + var _closestTabbable = this.getClosestTabbable(target, isReverseDir); + + Object(external_this_wp_dom_["placeCaretAtHorizontalEdge"])(_closestTabbable, isReverseDir); + event.preventDefault(); + } + } + /** + * Sets focus to the end of the last tabbable text field, if one exists. + */ + + }, { + key: "focusLastTextField", + value: function focusLastTextField() { + this.disableNavigationMode(); + var focusableNodes = external_this_wp_dom_["focus"].focusable.find(this.container); + var target = Object(external_lodash_["findLast"])(focusableNodes, isTabbableTextField); + + if (target) { + Object(external_this_wp_dom_["placeCaretAtHorizontalEdge"])(target, true); + } + } + }, { + key: "render", + value: function render() { + var children = this.props.children; // Disable reason: Wrapper itself is non-interactive, but must capture + // bubbling events from children to determine focus transition intents. + + /* eslint-disable jsx-a11y/no-static-element-interactions */ + + return Object(external_this_wp_element_["createElement"])("div", { + className: "editor-writing-flow block-editor-writing-flow" + }, Object(external_this_wp_element_["createElement"])("div", { + ref: this.bindContainer, + onKeyDown: this.onKeyDown, + onMouseDown: this.onMouseDown + }, children), Object(external_this_wp_element_["createElement"])("div", { + ref: this.appender, + "aria-hidden": true, + tabIndex: -1, + onClick: this.focusLastTextField, + className: "editor-writing-flow__click-redirect block-editor-writing-flow__click-redirect" + })); + /* eslint-enable jsx-a11y/no-static-element-interactions */ + } + }]); + + return WritingFlow; +}(external_this_wp_element_["Component"]); + +/* harmony default export */ var writing_flow = (Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getSelectedBlockClientId = _select.getSelectedBlockClientId, + getMultiSelectedBlocksStartClientId = _select.getMultiSelectedBlocksStartClientId, + getMultiSelectedBlocksEndClientId = _select.getMultiSelectedBlocksEndClientId, + getPreviousBlockClientId = _select.getPreviousBlockClientId, + getNextBlockClientId = _select.getNextBlockClientId, + getFirstMultiSelectedBlockClientId = _select.getFirstMultiSelectedBlockClientId, + getLastMultiSelectedBlockClientId = _select.getLastMultiSelectedBlockClientId, + hasMultiSelection = _select.hasMultiSelection, + getBlockOrder = _select.getBlockOrder, + isNavigationMode = _select.isNavigationMode; + + var selectedBlockClientId = getSelectedBlockClientId(); + var selectionStartClientId = getMultiSelectedBlocksStartClientId(); + var selectionEndClientId = getMultiSelectedBlocksEndClientId(); + return { + selectedBlockClientId: selectedBlockClientId, + selectionStartClientId: selectionStartClientId, + selectionBeforeEndClientId: getPreviousBlockClientId(selectionEndClientId || selectedBlockClientId), + selectionAfterEndClientId: getNextBlockClientId(selectionEndClientId || selectedBlockClientId), + selectedFirstClientId: getFirstMultiSelectedBlockClientId(), + selectedLastClientId: getLastMultiSelectedBlockClientId(), + hasMultiSelection: hasMultiSelection(), + blocks: getBlockOrder(), + isNavigationMode: isNavigationMode() + }; +}), Object(external_this_wp_data_["withDispatch"])(function (dispatch) { + var _dispatch = dispatch('core/block-editor'), + multiSelect = _dispatch.multiSelect, + selectBlock = _dispatch.selectBlock, + setNavigationMode = _dispatch.setNavigationMode, + clearSelectedBlock = _dispatch.clearSelectedBlock; + + return { + onMultiSelect: multiSelect, + onSelectBlock: selectBlock, + disableNavigationMode: function disableNavigationMode() { + return setNavigationMode(false); + }, + clearSelectedBlock: clearSelectedBlock + }; +})])(writing_flow_WritingFlow)); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/components/index.js +/* + * Block Creation Components + */ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +/* + * Content Related Components + */ + + + + + + + + + + + + + + + + + + + + + + + + + +/* + * State Related Components + */ + + + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/hooks/align.js + + + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + +/** + * Internal dependencies + */ + + +/** + * An array which includes all possible valid alignments, + * used to validate if an alignment is valid or not. + * + * @constant + * @type {string[]} + */ + +var ALL_ALIGNMENTS = ['left', 'center', 'right', 'wide', 'full']; +/** + * An array which includes all wide alignments. + * In order for this alignments to be valid they need to be supported by the block, + * and by the theme. + * + * @constant + * @type {string[]} + */ + +var WIDE_ALIGNMENTS = ['wide', 'full']; +/** + * Returns the valid alignments. + * Takes into consideration the aligns supported by a block, if the block supports wide controls or not and if theme supports wide controls or not. + * Exported just for testing purposes, not exported outside the module. + * + * @param {?boolean|string[]} blockAlign Aligns supported by the block. + * @param {?boolean} hasWideBlockSupport True if block supports wide alignments. And False otherwise. + * @param {?boolean} hasWideEnabled True if theme supports wide alignments. And False otherwise. + * + * @return {string[]} Valid alignments. + */ + +function getValidAlignments(blockAlign) { + var hasWideBlockSupport = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + var hasWideEnabled = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + var validAlignments; + + if (Array.isArray(blockAlign)) { + validAlignments = blockAlign; + } else if (blockAlign === true) { + // `true` includes all alignments... + validAlignments = ALL_ALIGNMENTS; + } else { + validAlignments = []; + } + + if (!hasWideEnabled || blockAlign === true && !hasWideBlockSupport) { + return external_lodash_["without"].apply(void 0, [validAlignments].concat(WIDE_ALIGNMENTS)); + } + + return validAlignments; +} +/** + * Filters registered block settings, extending attributes to include `align`. + * + * @param {Object} settings Original block settings + * @return {Object} Filtered block settings + */ + +function addAttribute(settings) { + // allow blocks to specify their own attribute definition with default values if needed. + if (Object(external_lodash_["has"])(settings.attributes, ['align', 'type'])) { + return settings; + } + + if (Object(external_this_wp_blocks_["hasBlockSupport"])(settings, 'align')) { + // Use Lodash's assign to gracefully handle if attributes are undefined + settings.attributes = Object(external_lodash_["assign"])(settings.attributes, { + align: { + type: 'string' + } + }); + } + + return settings; +} +/** + * Override the default edit UI to include new toolbar controls for block + * alignment, if block defines support. + * + * @param {Function} BlockEdit Original component + * @return {Function} Wrapped component + */ + +var withToolbarControls = Object(external_this_wp_compose_["createHigherOrderComponent"])(function (BlockEdit) { + return function (props) { + var blockName = props.name; // Compute valid alignments without taking into account, + // if the theme supports wide alignments or not. + // BlockAlignmentToolbar takes into account the theme support. + + var validAlignments = getValidAlignments(Object(external_this_wp_blocks_["getBlockSupport"])(blockName, 'align'), Object(external_this_wp_blocks_["hasBlockSupport"])(blockName, 'alignWide', true)); + + var updateAlignment = function updateAlignment(nextAlign) { + if (!nextAlign) { + var blockType = Object(external_this_wp_blocks_["getBlockType"])(props.name); + var blockDefaultAlign = Object(external_lodash_["get"])(blockType, ['attributes', 'align', 'default']); + + if (blockDefaultAlign) { + nextAlign = ''; + } + } + + props.setAttributes({ + align: nextAlign + }); + }; + + return [validAlignments.length > 0 && props.isSelected && Object(external_this_wp_element_["createElement"])(block_controls, { + key: "align-controls" + }, Object(external_this_wp_element_["createElement"])(block_alignment_toolbar, { + value: props.attributes.align, + onChange: updateAlignment, + controls: validAlignments + })), Object(external_this_wp_element_["createElement"])(BlockEdit, Object(esm_extends["a" /* default */])({ + key: "edit" + }, props))]; + }; +}, 'withToolbarControls'); // Exported just for testing purposes, not exported outside the module. + +var align_insideSelectWithDataAlign = function insideSelectWithDataAlign(BlockListBlock) { + return function (props) { + var name = props.name, + attributes = props.attributes, + hasWideEnabled = props.hasWideEnabled; + var align = attributes.align; + var validAlignments = getValidAlignments(Object(external_this_wp_blocks_["getBlockSupport"])(name, 'align'), Object(external_this_wp_blocks_["hasBlockSupport"])(name, 'alignWide', true), hasWideEnabled); + var wrapperProps = props.wrapperProps; + + if (Object(external_lodash_["includes"])(validAlignments, align)) { + wrapperProps = Object(objectSpread["a" /* default */])({}, wrapperProps, { + 'data-align': align + }); + } + + return Object(external_this_wp_element_["createElement"])(BlockListBlock, Object(esm_extends["a" /* default */])({}, props, { + wrapperProps: wrapperProps + })); + }; +}; +/** + * Override the default block element to add alignment wrapper props. + * + * @param {Function} BlockListBlock Original component + * @return {Function} Wrapped component + */ + +var withDataAlign = Object(external_this_wp_compose_["createHigherOrderComponent"])(Object(external_this_wp_compose_["compose"])([Object(external_this_wp_data_["withSelect"])(function (select) { + var _select = select('core/block-editor'), + getSettings = _select.getSettings; + + return { + hasWideEnabled: !!getSettings().alignWide + }; +}), align_insideSelectWithDataAlign])); +/** + * Override props assigned to save component to inject alignment class name if + * block supports it. + * + * @param {Object} props Additional props applied to save element + * @param {Object} blockType Block type + * @param {Object} attributes Block attributes + * @return {Object} Filtered props applied to save element + */ + +function addAssignedAlign(props, blockType, attributes) { + var align = attributes.align; + var blockAlign = Object(external_this_wp_blocks_["getBlockSupport"])(blockType, 'align'); + var hasWideBlockSupport = Object(external_this_wp_blocks_["hasBlockSupport"])(blockType, 'alignWide', true); + var isAlignValid = Object(external_lodash_["includes"])( // Compute valid alignments without taking into account, + // if the theme supports wide alignments or not. + // This way changing themes does not impacts the block save. + getValidAlignments(blockAlign, hasWideBlockSupport), align); + + if (isAlignValid) { + props.className = classnames_default()("align".concat(align), props.className); + } + + return props; +} +Object(external_this_wp_hooks_["addFilter"])('blocks.registerBlockType', 'core/align/addAttribute', addAttribute); +Object(external_this_wp_hooks_["addFilter"])('editor.BlockListBlock', 'core/editor/align/with-data-align', withDataAlign); +Object(external_this_wp_hooks_["addFilter"])('editor.BlockEdit', 'core/editor/align/with-toolbar-controls', withToolbarControls); +Object(external_this_wp_hooks_["addFilter"])('blocks.getSaveContent.extraProps', 'core/align/addAssignedAlign', addAssignedAlign); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/hooks/anchor.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + +/** + * Regular expression matching invalid anchor characters for replacement. + * + * @type {RegExp} + */ + +var ANCHOR_REGEX = /[\s#]/g; +/** + * Filters registered block settings, extending attributes with anchor using ID + * of the first node. + * + * @param {Object} settings Original block settings. + * + * @return {Object} Filtered block settings. + */ + +function anchor_addAttribute(settings) { + // allow blocks to specify their own attribute definition with default values if needed. + if (Object(external_lodash_["has"])(settings.attributes, ['anchor', 'type'])) { + return settings; + } + + if (Object(external_this_wp_blocks_["hasBlockSupport"])(settings, 'anchor')) { + // Use Lodash's assign to gracefully handle if attributes are undefined + settings.attributes = Object(external_lodash_["assign"])(settings.attributes, { + anchor: { + type: 'string', + source: 'attribute', + attribute: 'id', + selector: '*' + } + }); + } + + return settings; +} +/** + * Override the default edit UI to include a new block inspector control for + * assigning the anchor ID, if block supports anchor. + * + * @param {Function|Component} BlockEdit Original component. + * + * @return {string} Wrapped component. + */ + +var withInspectorControl = Object(external_this_wp_compose_["createHigherOrderComponent"])(function (BlockEdit) { + return function (props) { + var hasAnchor = Object(external_this_wp_blocks_["hasBlockSupport"])(props.name, 'anchor'); + + if (hasAnchor && props.isSelected) { + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(BlockEdit, props), Object(external_this_wp_element_["createElement"])(inspector_advanced_controls, null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["TextControl"], { + className: "html-anchor-control", + label: Object(external_this_wp_i18n_["__"])('HTML Anchor'), + help: Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_i18n_["__"])('Enter a word or two — without spaces — to make a unique web address just for this heading, called an “anchor.” Then, you’ll be able to link directly to this section of your page.'), Object(external_this_wp_element_["createElement"])(external_this_wp_components_["ExternalLink"], { + href: 'https://wordpress.org/support/article/page-jumps/' + }, Object(external_this_wp_i18n_["__"])('Learn more about anchors'))), + value: props.attributes.anchor || '', + onChange: function onChange(nextValue) { + nextValue = nextValue.replace(ANCHOR_REGEX, '-'); + props.setAttributes({ + anchor: nextValue + }); + } + }))); + } + + return Object(external_this_wp_element_["createElement"])(BlockEdit, props); + }; +}, 'withInspectorControl'); +/** + * Override props assigned to save component to inject anchor ID, if block + * supports anchor. This is only applied if the block's save result is an + * element and not a markup string. + * + * @param {Object} extraProps Additional props applied to save element. + * @param {Object} blockType Block type. + * @param {Object} attributes Current block attributes. + * + * @return {Object} Filtered props applied to save element. + */ + +function addSaveProps(extraProps, blockType, attributes) { + if (Object(external_this_wp_blocks_["hasBlockSupport"])(blockType, 'anchor')) { + extraProps.id = attributes.anchor === '' ? null : attributes.anchor; + } + + return extraProps; +} +Object(external_this_wp_hooks_["addFilter"])('blocks.registerBlockType', 'core/anchor/attribute', anchor_addAttribute); +Object(external_this_wp_hooks_["addFilter"])('editor.BlockEdit', 'core/editor/anchor/with-inspector-control', withInspectorControl); +Object(external_this_wp_hooks_["addFilter"])('blocks.getSaveContent.extraProps', 'core/anchor/save-props', addSaveProps); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/hooks/custom-class-name.js + + +/** + * External dependencies + */ + + +/** + * WordPress dependencies + */ + + + + + + +/** + * Internal dependencies + */ + + +/** + * Filters registered block settings, extending attributes with anchor using ID + * of the first node. + * + * @param {Object} settings Original block settings. + * + * @return {Object} Filtered block settings. + */ + +function custom_class_name_addAttribute(settings) { + if (Object(external_this_wp_blocks_["hasBlockSupport"])(settings, 'customClassName', true)) { + // Use Lodash's assign to gracefully handle if attributes are undefined + settings.attributes = Object(external_lodash_["assign"])(settings.attributes, { + className: { + type: 'string' + } + }); + } + + return settings; +} +/** + * Override the default edit UI to include a new block inspector control for + * assigning the custom class name, if block supports custom class name. + * + * @param {Function|Component} BlockEdit Original component. + * + * @return {string} Wrapped component. + */ + +var custom_class_name_withInspectorControl = Object(external_this_wp_compose_["createHigherOrderComponent"])(function (BlockEdit) { + return function (props) { + var hasCustomClassName = Object(external_this_wp_blocks_["hasBlockSupport"])(props.name, 'customClassName', true); + + if (hasCustomClassName && props.isSelected) { + return Object(external_this_wp_element_["createElement"])(external_this_wp_element_["Fragment"], null, Object(external_this_wp_element_["createElement"])(BlockEdit, props), Object(external_this_wp_element_["createElement"])(inspector_advanced_controls, null, Object(external_this_wp_element_["createElement"])(external_this_wp_components_["TextControl"], { + label: Object(external_this_wp_i18n_["__"])('Additional CSS Class(es)'), + value: props.attributes.className || '', + onChange: function onChange(nextValue) { + props.setAttributes({ + className: nextValue !== '' ? nextValue : undefined + }); + }, + help: Object(external_this_wp_i18n_["__"])('Separate multiple classes with spaces.') + }))); + } + + return Object(external_this_wp_element_["createElement"])(BlockEdit, props); + }; +}, 'withInspectorControl'); +/** + * Override props assigned to save component to inject anchor ID, if block + * supports anchor. This is only applied if the block's save result is an + * element and not a markup string. + * + * @param {Object} extraProps Additional props applied to save element. + * @param {Object} blockType Block type. + * @param {Object} attributes Current block attributes. + * + * @return {Object} Filtered props applied to save element. + */ + +function custom_class_name_addSaveProps(extraProps, blockType, attributes) { + if (Object(external_this_wp_blocks_["hasBlockSupport"])(blockType, 'customClassName', true) && attributes.className) { + extraProps.className = classnames_default()(extraProps.className, attributes.className); + } + + return extraProps; +} +/** + * Given an HTML string, returns an array of class names assigned to the root + * element in the markup. + * + * @param {string} innerHTML Markup string from which to extract classes. + * + * @return {string[]} Array of class names assigned to the root element. + */ + +function getHTMLRootElementClasses(innerHTML) { + innerHTML = "<div data-custom-class-name>".concat(innerHTML, "</div>"); + var parsed = Object(external_this_wp_blocks_["parseWithAttributeSchema"])(innerHTML, { + type: 'string', + source: 'attribute', + selector: '[data-custom-class-name] > *', + attribute: 'class' + }); + return parsed ? parsed.trim().split(/\s+/) : []; +} +/** + * Given a parsed set of block attributes, if the block supports custom class + * names and an unknown class (per the block's serialization behavior) is + * found, the unknown classes are treated as custom classes. This prevents the + * block from being considered as invalid. + * + * @param {Object} blockAttributes Original block attributes. + * @param {Object} blockType Block type settings. + * @param {string} innerHTML Original block markup. + * + * @return {Object} Filtered block attributes. + */ + +function addParsedDifference(blockAttributes, blockType, innerHTML) { + if (Object(external_this_wp_blocks_["hasBlockSupport"])(blockType, 'customClassName', true)) { + // To determine difference, serialize block given the known set of + // attributes, with the exception of `className`. This will determine + // the default set of classes. From there, any difference in innerHTML + // can be considered as custom classes. + var attributesSansClassName = Object(external_lodash_["omit"])(blockAttributes, ['className']); + var serialized = Object(external_this_wp_blocks_["getSaveContent"])(blockType, attributesSansClassName); + var defaultClasses = getHTMLRootElementClasses(serialized); + var actualClasses = getHTMLRootElementClasses(innerHTML); + var customClasses = Object(external_lodash_["difference"])(actualClasses, defaultClasses); + + if (customClasses.length) { + blockAttributes.className = customClasses.join(' '); + } else if (serialized) { + delete blockAttributes.className; + } + } + + return blockAttributes; +} +Object(external_this_wp_hooks_["addFilter"])('blocks.registerBlockType', 'core/custom-class-name/attribute', custom_class_name_addAttribute); +Object(external_this_wp_hooks_["addFilter"])('editor.BlockEdit', 'core/editor/custom-class-name/with-inspector-control', custom_class_name_withInspectorControl); +Object(external_this_wp_hooks_["addFilter"])('blocks.getSaveContent.extraProps', 'core/custom-class-name/save-props', custom_class_name_addSaveProps); +Object(external_this_wp_hooks_["addFilter"])('blocks.getBlockAttributes', 'core/custom-class-name/addParsedDifference', addParsedDifference); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/hooks/generated-class-name.js + + +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + + +/** + * Override props assigned to save component to inject generated className if + * block supports it. This is only applied if the block's save result is an + * element and not a markup string. + * + * @param {Object} extraProps Additional props applied to save element. + * @param {Object} blockType Block type. + * + * @return {Object} Filtered props applied to save element. + */ + +function addGeneratedClassName(extraProps, blockType) { + // Adding the generated className + if (Object(external_this_wp_blocks_["hasBlockSupport"])(blockType, 'className', true)) { + if (typeof extraProps.className === 'string') { + // We have some extra classes and want to add the default classname + // We use uniq to prevent duplicate classnames + extraProps.className = Object(external_lodash_["uniq"])([Object(external_this_wp_blocks_["getBlockDefaultClassName"])(blockType.name)].concat(Object(toConsumableArray["a" /* default */])(extraProps.className.split(' ')))).join(' ').trim(); + } else { + // There is no string in the className variable, + // so we just dump the default name in there + extraProps.className = Object(external_this_wp_blocks_["getBlockDefaultClassName"])(blockType.name); + } + } + + return extraProps; +} +Object(external_this_wp_hooks_["addFilter"])('blocks.getSaveContent.extraProps', 'core/generated-class-name/save-props', addGeneratedClassName); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/hooks/index.js +/** + * Internal dependencies + */ + + + + + +// EXTERNAL MODULE: ./node_modules/traverse/index.js +var traverse = __webpack_require__(220); +var traverse_default = /*#__PURE__*/__webpack_require__.n(traverse); + +// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js +var esm_typeof = __webpack_require__(31); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/utils/transform-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; + } // FIXME: 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; +} +/* eslint-enable @wordpress/no-unused-vars-before-return */ + +// EXTERNAL MODULE: ./node_modules/inherits/inherits_browser.js +var inherits_browser = __webpack_require__(112); +var inherits_browser_default = /*#__PURE__*/__webpack_require__.n(inherits_browser); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/utils/transform-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. + */ + +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/block-editor/build-module/utils/transform-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/block-editor/build-module/utils/transform-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 || ' '); +}; +/* eslint-enable @wordpress/no-unused-vars-before-return */ + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/utils/transform-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} + */ + +/* 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/block-editor/build-module/utils/transform-styles/ast/index.js +// Adapted from https://github.com/reworkcss/css +// because we needed to remove source map support. + + + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/utils/transform-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 transform_styles_traverse = (traverseCSS); + +// EXTERNAL MODULE: ./node_modules/url/url.js +var url_url = __webpack_require__(82); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/utils/transform-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 + * + * @return {string} the full path to the file + */ + + +function getResourcePath(str, baseURL) { + var pathname = Object(url_url["parse"])(str).pathname; + var filePath = Object(url_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/block-editor/build-module/utils/transform-styles/transforms/wrap.js + + +/** + * External dependencies + */ + +/** + * @constant 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/block-editor/build-module/utils/transform-styles/index.js +/** + * External dependencies + */ + +/** + * WordPress dependencies + */ + + +/** + * Internal dependencies + */ + + + + +/** + * Applies a series of CSS rule transforms to wrap selectors inside a given class and/or rewrite URLs depending on the parameters passed. + * + * @param {Array} styles CSS rules. + * @param {string} wrapperClassName Wrapper Class Name. + * @return {Array} converted rules. + */ + +var transform_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 transform_styles_traverse(css, Object(external_this_wp_compose_["compose"])(transforms)); + } + + return css; + }); +}; + +/* harmony default export */ var transform_styles = (transform_styles_transformStyles); + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/utils/index.js + + +// CONCATENATED MODULE: ./node_modules/@wordpress/block-editor/build-module/index.js +/* concated harmony reexport AlignmentToolbar */__webpack_require__.d(__webpack_exports__, "AlignmentToolbar", function() { return alignment_toolbar; }); +/* concated harmony reexport Autocomplete */__webpack_require__.d(__webpack_exports__, "Autocomplete", function() { return autocomplete; }); +/* concated harmony reexport BlockAlignmentToolbar */__webpack_require__.d(__webpack_exports__, "BlockAlignmentToolbar", function() { return block_alignment_toolbar; }); +/* concated harmony reexport BlockControls */__webpack_require__.d(__webpack_exports__, "BlockControls", function() { return block_controls; }); +/* concated harmony reexport BlockEdit */__webpack_require__.d(__webpack_exports__, "BlockEdit", function() { return block_edit; }); +/* concated harmony reexport BlockFormatControls */__webpack_require__.d(__webpack_exports__, "BlockFormatControls", function() { return block_format_controls; }); +/* concated harmony reexport BlockIcon */__webpack_require__.d(__webpack_exports__, "BlockIcon", function() { return BlockIcon; }); +/* concated harmony reexport BlockNavigationDropdown */__webpack_require__.d(__webpack_exports__, "BlockNavigationDropdown", function() { return dropdown; }); +/* concated harmony reexport __experimentalBlockNavigationList */__webpack_require__.d(__webpack_exports__, "__experimentalBlockNavigationList", function() { return BlockNavigationList; }); +/* concated harmony reexport BlockVerticalAlignmentToolbar */__webpack_require__.d(__webpack_exports__, "BlockVerticalAlignmentToolbar", function() { return block_vertical_alignment_toolbar; }); +/* concated harmony reexport ButtonBlockerAppender */__webpack_require__.d(__webpack_exports__, "ButtonBlockerAppender", function() { return button_block_appender; }); +/* concated harmony reexport ColorPalette */__webpack_require__.d(__webpack_exports__, "ColorPalette", function() { return color_palette; }); +/* concated harmony reexport ContrastChecker */__webpack_require__.d(__webpack_exports__, "ContrastChecker", function() { return contrast_checker; }); +/* concated harmony reexport InnerBlocks */__webpack_require__.d(__webpack_exports__, "InnerBlocks", function() { return inner_blocks; }); +/* concated harmony reexport InspectorAdvancedControls */__webpack_require__.d(__webpack_exports__, "InspectorAdvancedControls", function() { return inspector_advanced_controls; }); +/* concated harmony reexport InspectorControls */__webpack_require__.d(__webpack_exports__, "InspectorControls", function() { return inspector_controls; }); +/* concated harmony reexport MediaPlaceholder */__webpack_require__.d(__webpack_exports__, "MediaPlaceholder", function() { return media_placeholder; }); +/* concated harmony reexport MediaUpload */__webpack_require__.d(__webpack_exports__, "MediaUpload", function() { return media_upload; }); +/* concated harmony reexport MediaUploadCheck */__webpack_require__.d(__webpack_exports__, "MediaUploadCheck", function() { return check; }); +/* concated harmony reexport PanelColorSettings */__webpack_require__.d(__webpack_exports__, "PanelColorSettings", function() { return panel_color_settings; }); +/* concated harmony reexport PlainText */__webpack_require__.d(__webpack_exports__, "PlainText", function() { return plain_text; }); +/* concated harmony reexport RichText */__webpack_require__.d(__webpack_exports__, "RichText", function() { return rich_text; }); +/* concated harmony reexport RichTextShortcut */__webpack_require__.d(__webpack_exports__, "RichTextShortcut", function() { return shortcut_RichTextShortcut; }); +/* concated harmony reexport RichTextToolbarButton */__webpack_require__.d(__webpack_exports__, "RichTextToolbarButton", function() { return RichTextToolbarButton; }); +/* concated harmony reexport __unstableRichTextInputEvent */__webpack_require__.d(__webpack_exports__, "__unstableRichTextInputEvent", function() { return input_event_unstableRichTextInputEvent; }); +/* concated harmony reexport URLInput */__webpack_require__.d(__webpack_exports__, "URLInput", function() { return url_input; }); +/* concated harmony reexport URLInputButton */__webpack_require__.d(__webpack_exports__, "URLInputButton", function() { return url_input_button; }); +/* concated harmony reexport URLPopover */__webpack_require__.d(__webpack_exports__, "URLPopover", function() { return url_popover; }); +/* concated harmony reexport withColorContext */__webpack_require__.d(__webpack_exports__, "withColorContext", function() { return with_color_context; }); +/* concated harmony reexport __experimentalBlockSettingsMenuFirstItem */__webpack_require__.d(__webpack_exports__, "__experimentalBlockSettingsMenuFirstItem", function() { return block_settings_menu_first_item; }); +/* concated harmony reexport __experimentalBlockSettingsMenuPluginsExtension */__webpack_require__.d(__webpack_exports__, "__experimentalBlockSettingsMenuPluginsExtension", function() { return block_settings_menu_plugins_extension; }); +/* concated harmony reexport __experimentalInserterMenuExtension */__webpack_require__.d(__webpack_exports__, "__experimentalInserterMenuExtension", function() { return inserter_menu_extension; }); +/* concated harmony reexport BlockEditorKeyboardShortcuts */__webpack_require__.d(__webpack_exports__, "BlockEditorKeyboardShortcuts", function() { return block_editor_keyboard_shortcuts; }); +/* concated harmony reexport BlockInspector */__webpack_require__.d(__webpack_exports__, "BlockInspector", function() { return block_inspector; }); +/* concated harmony reexport BlockList */__webpack_require__.d(__webpack_exports__, "BlockList", function() { return block_list; }); +/* concated harmony reexport BlockMover */__webpack_require__.d(__webpack_exports__, "BlockMover", function() { return block_mover; }); +/* concated harmony reexport BlockPreview */__webpack_require__.d(__webpack_exports__, "BlockPreview", function() { return block_preview; }); +/* concated harmony reexport BlockSelectionClearer */__webpack_require__.d(__webpack_exports__, "BlockSelectionClearer", function() { return block_selection_clearer; }); +/* concated harmony reexport BlockSettingsMenu */__webpack_require__.d(__webpack_exports__, "BlockSettingsMenu", function() { return block_settings_menu; }); +/* concated harmony reexport BlockTitle */__webpack_require__.d(__webpack_exports__, "BlockTitle", function() { return block_title; }); +/* concated harmony reexport BlockToolbar */__webpack_require__.d(__webpack_exports__, "BlockToolbar", function() { return block_toolbar; }); +/* concated harmony reexport CopyHandler */__webpack_require__.d(__webpack_exports__, "CopyHandler", function() { return copy_handler; }); +/* concated harmony reexport DefaultBlockAppender */__webpack_require__.d(__webpack_exports__, "DefaultBlockAppender", function() { return default_block_appender; }); +/* concated harmony reexport Inserter */__webpack_require__.d(__webpack_exports__, "Inserter", function() { return inserter; }); +/* concated harmony reexport MultiBlocksSwitcher */__webpack_require__.d(__webpack_exports__, "MultiBlocksSwitcher", function() { return multi_blocks_switcher; }); +/* concated harmony reexport MultiSelectScrollIntoView */__webpack_require__.d(__webpack_exports__, "MultiSelectScrollIntoView", function() { return multi_select_scroll_into_view; }); +/* concated harmony reexport NavigableToolbar */__webpack_require__.d(__webpack_exports__, "NavigableToolbar", function() { return navigable_toolbar; }); +/* concated harmony reexport ObserveTyping */__webpack_require__.d(__webpack_exports__, "ObserveTyping", function() { return observe_typing; }); +/* concated harmony reexport PreserveScrollInReorder */__webpack_require__.d(__webpack_exports__, "PreserveScrollInReorder", function() { return PreserveScrollInReorder; }); +/* concated harmony reexport SkipToSelectedBlock */__webpack_require__.d(__webpack_exports__, "SkipToSelectedBlock", function() { return skip_to_selected_block; }); +/* concated harmony reexport Typewriter */__webpack_require__.d(__webpack_exports__, "Typewriter", function() { return typewriter; }); +/* concated harmony reexport Warning */__webpack_require__.d(__webpack_exports__, "Warning", function() { return warning; }); +/* concated harmony reexport WritingFlow */__webpack_require__.d(__webpack_exports__, "WritingFlow", function() { return writing_flow; }); +/* concated harmony reexport BlockEditorProvider */__webpack_require__.d(__webpack_exports__, "BlockEditorProvider", function() { return provider; }); +/* concated harmony reexport getColorClassName */__webpack_require__.d(__webpack_exports__, "getColorClassName", function() { return getColorClassName; }); +/* concated harmony reexport getColorObjectByAttributeValues */__webpack_require__.d(__webpack_exports__, "getColorObjectByAttributeValues", function() { return utils_getColorObjectByAttributeValues; }); +/* concated harmony reexport getColorObjectByColorValue */__webpack_require__.d(__webpack_exports__, "getColorObjectByColorValue", function() { return utils_getColorObjectByColorValue; }); +/* concated harmony reexport createCustomColorsHOC */__webpack_require__.d(__webpack_exports__, "createCustomColorsHOC", function() { return createCustomColorsHOC; }); +/* concated harmony reexport withColors */__webpack_require__.d(__webpack_exports__, "withColors", function() { return withColors; }); +/* concated harmony reexport getFontSize */__webpack_require__.d(__webpack_exports__, "getFontSize", function() { return utils_getFontSize; }); +/* concated harmony reexport getFontSizeClass */__webpack_require__.d(__webpack_exports__, "getFontSizeClass", function() { return getFontSizeClass; }); +/* concated harmony reexport FontSizePicker */__webpack_require__.d(__webpack_exports__, "FontSizePicker", function() { return font_size_picker; }); +/* concated harmony reexport withFontSizes */__webpack_require__.d(__webpack_exports__, "withFontSizes", function() { return with_font_sizes; }); +/* concated harmony reexport transformStyles */__webpack_require__.d(__webpack_exports__, "transformStyles", function() { return transform_styles; }); +/* concated harmony reexport storeConfig */__webpack_require__.d(__webpack_exports__, "storeConfig", function() { return storeConfig; }); +/* concated harmony reexport SETTINGS_DEFAULTS */__webpack_require__.d(__webpack_exports__, "SETTINGS_DEFAULTS", function() { return SETTINGS_DEFAULTS; }); +/** + * WordPress dependencies + */ + + + +/** + * Internal dependencies + */ + + + + + + + + +/***/ }), + +/***/ 35: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["blob"]; }()); + +/***/ }), + +/***/ 36: +/***/ (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; +}); + + +/***/ }), + +/***/ 37: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["deprecated"]; }()); + +/***/ }), + +/***/ 38: +/***/ (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; +} + +/***/ }), + +/***/ 39: +/***/ (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"]["data"]; }()); + +/***/ }), + +/***/ 41: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["isShallowEqual"]; }()); + +/***/ }), + +/***/ 42: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["viewport"]; }()); + +/***/ }), + +/***/ 44: +/***/ (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; +}; + + +/***/ }), + +/***/ 45: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["a11y"]; }()); + +/***/ }), + +/***/ 47: +/***/ (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. + */ + +var runtime = (function (exports) { + "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"; + + 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; + } + exports.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); + }; + }); + } + + exports.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; + }; + + exports.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. + exports.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; + }; + exports.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. + exports.async = function(innerFn, outerFn, self, tryLocsList) { + var iter = new AsyncIterator( + wrap(innerFn, outerFn, self, tryLocsList) + ); + + return exports.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") { + // Note: ["return"] must be used for ES3 parsing compatibility. + 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); + } + + exports.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 }; + } + exports.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; + } + }; + + // Regardless of whether this script is executing as a CommonJS module + // or not, return the runtime object so that we can declare the variable + // regeneratorRuntime in the outer scope, which allows this module to be + // injected easily by `bin/regenerator --include-runtime script.js`. + return exports; + +}( + // If this script is executing as a CommonJS module, use module.exports + // as the regeneratorRuntime namespace. Otherwise create a new empty + // object. Either way, the resulting object will be used to initialize + // the regeneratorRuntime variable at the top of this file. + true ? module.exports : undefined +)); + +try { + regeneratorRuntime = runtime; +} catch (accidentalStrictMode) { + // This module should not be running in strict mode, so the above + // assignment should always work unless something is misconfigured. Just + // in case runtime.js accidentally runs in strict mode, we can escape + // strict mode using a global Function call. This could conceivably fail + // if a Content Security Policy forbids using Function, but in that case + // the proper solution is to fix the accidental strict mode problem. If + // you've misconfigured your bundler to force strict mode and applied a + // CSP to forbid Function, and you're not willing to fix either of those + // problems, please detail your unique predicament in a GitHub issue. + Function("r", "regeneratorRuntime = r")(runtime); +} + + +/***/ }), + +/***/ 48: +/***/ (function(module, exports, __webpack_require__) { + +var __WEBPACK_AMD_DEFINE_RESULT__;// TinyColor v1.4.1 +// https://github.com/bgrins/TinyColor +// Brian Grinstead, MIT License + +(function(Math) { + +var trimLeft = /^\s+/, + trimRight = /\s+$/, + tinyCounter = 0, + mathRound = Math.round, + mathMin = Math.min, + mathMax = Math.max, + mathRandom = Math.random; + +function tinycolor (color, opts) { + + color = (color) ? color : ''; + opts = opts || { }; + + // If input is already a tinycolor, return itself + if (color instanceof tinycolor) { + return color; + } + // If we are called as a function, call using new instead + if (!(this instanceof tinycolor)) { + return new tinycolor(color, opts); + } + + var rgb = inputToRGB(color); + this._originalInput = color, + this._r = rgb.r, + this._g = rgb.g, + this._b = rgb.b, + this._a = rgb.a, + this._roundA = mathRound(100*this._a) / 100, + this._format = opts.format || rgb.format; + this._gradientType = opts.gradientType; + + // Don't let the range of [0,255] come back in [0,1]. + // Potentially lose a little bit of precision here, but will fix issues where + // .5 gets interpreted as half of the total, instead of half of 1 + // If it was supposed to be 128, this was already taken care of by `inputToRgb` + if (this._r < 1) { this._r = mathRound(this._r); } + if (this._g < 1) { this._g = mathRound(this._g); } + if (this._b < 1) { this._b = mathRound(this._b); } + + this._ok = rgb.ok; + this._tc_id = tinyCounter++; +} + +tinycolor.prototype = { + isDark: function() { + return this.getBrightness() < 128; + }, + isLight: function() { + return !this.isDark(); + }, + isValid: function() { + return this._ok; + }, + getOriginalInput: function() { + return this._originalInput; + }, + getFormat: function() { + return this._format; + }, + getAlpha: function() { + return this._a; + }, + getBrightness: function() { + //http://www.w3.org/TR/AERT#color-contrast + var rgb = this.toRgb(); + return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000; + }, + getLuminance: function() { + //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef + var rgb = this.toRgb(); + var RsRGB, GsRGB, BsRGB, R, G, B; + RsRGB = rgb.r/255; + GsRGB = rgb.g/255; + BsRGB = rgb.b/255; + + if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);} + if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);} + if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);} + return (0.2126 * R) + (0.7152 * G) + (0.0722 * B); + }, + setAlpha: function(value) { + this._a = boundAlpha(value); + this._roundA = mathRound(100*this._a) / 100; + return this; + }, + toHsv: function() { + var hsv = rgbToHsv(this._r, this._g, this._b); + return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a }; + }, + toHsvString: function() { + var hsv = rgbToHsv(this._r, this._g, this._b); + var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100); + return (this._a == 1) ? + "hsv(" + h + ", " + s + "%, " + v + "%)" : + "hsva(" + h + ", " + s + "%, " + v + "%, "+ this._roundA + ")"; + }, + toHsl: function() { + var hsl = rgbToHsl(this._r, this._g, this._b); + return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a }; + }, + toHslString: function() { + var hsl = rgbToHsl(this._r, this._g, this._b); + var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100); + return (this._a == 1) ? + "hsl(" + h + ", " + s + "%, " + l + "%)" : + "hsla(" + h + ", " + s + "%, " + l + "%, "+ this._roundA + ")"; + }, + toHex: function(allow3Char) { + return rgbToHex(this._r, this._g, this._b, allow3Char); + }, + toHexString: function(allow3Char) { + return '#' + this.toHex(allow3Char); + }, + toHex8: function(allow4Char) { + return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char); + }, + toHex8String: function(allow4Char) { + return '#' + this.toHex8(allow4Char); + }, + toRgb: function() { + return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a }; + }, + toRgbString: function() { + return (this._a == 1) ? + "rgb(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ")" : + "rgba(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ", " + this._roundA + ")"; + }, + toPercentageRgb: function() { + return { r: mathRound(bound01(this._r, 255) * 100) + "%", g: mathRound(bound01(this._g, 255) * 100) + "%", b: mathRound(bound01(this._b, 255) * 100) + "%", a: this._a }; + }, + toPercentageRgbString: function() { + return (this._a == 1) ? + "rgb(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%)" : + "rgba(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")"; + }, + toName: function() { + if (this._a === 0) { + return "transparent"; + } + + if (this._a < 1) { + return false; + } + + return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false; + }, + toFilter: function(secondColor) { + var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a); + var secondHex8String = hex8String; + var gradientType = this._gradientType ? "GradientType = 1, " : ""; + + if (secondColor) { + var s = tinycolor(secondColor); + secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a); + } + + return "progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr="+hex8String+",endColorstr="+secondHex8String+")"; + }, + toString: function(format) { + var formatSet = !!format; + format = format || this._format; + + var formattedString = false; + var hasAlpha = this._a < 1 && this._a >= 0; + var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name"); + + if (needsAlphaFormat) { + // Special case for "transparent", all other non-alpha formats + // will return rgba when there is transparency. + if (format === "name" && this._a === 0) { + return this.toName(); + } + return this.toRgbString(); + } + if (format === "rgb") { + formattedString = this.toRgbString(); + } + if (format === "prgb") { + formattedString = this.toPercentageRgbString(); + } + if (format === "hex" || format === "hex6") { + formattedString = this.toHexString(); + } + if (format === "hex3") { + formattedString = this.toHexString(true); + } + if (format === "hex4") { + formattedString = this.toHex8String(true); + } + if (format === "hex8") { + formattedString = this.toHex8String(); + } + if (format === "name") { + formattedString = this.toName(); + } + if (format === "hsl") { + formattedString = this.toHslString(); + } + if (format === "hsv") { + formattedString = this.toHsvString(); + } + + return formattedString || this.toHexString(); + }, + clone: function() { + return tinycolor(this.toString()); + }, + + _applyModification: function(fn, args) { + var color = fn.apply(null, [this].concat([].slice.call(args))); + this._r = color._r; + this._g = color._g; + this._b = color._b; + this.setAlpha(color._a); + return this; + }, + lighten: function() { + return this._applyModification(lighten, arguments); + }, + brighten: function() { + return this._applyModification(brighten, arguments); + }, + darken: function() { + return this._applyModification(darken, arguments); + }, + desaturate: function() { + return this._applyModification(desaturate, arguments); + }, + saturate: function() { + return this._applyModification(saturate, arguments); + }, + greyscale: function() { + return this._applyModification(greyscale, arguments); + }, + spin: function() { + return this._applyModification(spin, arguments); + }, + + _applyCombination: function(fn, args) { + return fn.apply(null, [this].concat([].slice.call(args))); + }, + analogous: function() { + return this._applyCombination(analogous, arguments); + }, + complement: function() { + return this._applyCombination(complement, arguments); + }, + monochromatic: function() { + return this._applyCombination(monochromatic, arguments); + }, + splitcomplement: function() { + return this._applyCombination(splitcomplement, arguments); + }, + triad: function() { + return this._applyCombination(triad, arguments); + }, + tetrad: function() { + return this._applyCombination(tetrad, arguments); + } +}; + +// If input is an object, force 1 into "1.0" to handle ratios properly +// String input requires "1.0" as input, so 1 will be treated as 1 +tinycolor.fromRatio = function(color, opts) { + if (typeof color == "object") { + var newColor = {}; + for (var i in color) { + if (color.hasOwnProperty(i)) { + if (i === "a") { + newColor[i] = color[i]; + } + else { + newColor[i] = convertToPercentage(color[i]); + } + } + } + color = newColor; + } + + return tinycolor(color, opts); +}; + +// Given a string or object, convert that input to RGB +// Possible string inputs: +// +// "red" +// "#f00" or "f00" +// "#ff0000" or "ff0000" +// "#ff000000" or "ff000000" +// "rgb 255 0 0" or "rgb (255, 0, 0)" +// "rgb 1.0 0 0" or "rgb (1, 0, 0)" +// "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1" +// "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1" +// "hsl(0, 100%, 50%)" or "hsl 0 100% 50%" +// "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1" +// "hsv(0, 100%, 100%)" or "hsv 0 100% 100%" +// +function inputToRGB(color) { + + var rgb = { r: 0, g: 0, b: 0 }; + var a = 1; + var s = null; + var v = null; + var l = null; + var ok = false; + var format = false; + + if (typeof color == "string") { + color = stringInputToObject(color); + } + + if (typeof color == "object") { + if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) { + rgb = rgbToRgb(color.r, color.g, color.b); + ok = true; + format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb"; + } + else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) { + s = convertToPercentage(color.s); + v = convertToPercentage(color.v); + rgb = hsvToRgb(color.h, s, v); + ok = true; + format = "hsv"; + } + else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) { + s = convertToPercentage(color.s); + l = convertToPercentage(color.l); + rgb = hslToRgb(color.h, s, l); + ok = true; + format = "hsl"; + } + + if (color.hasOwnProperty("a")) { + a = color.a; + } + } + + a = boundAlpha(a); + + return { + ok: ok, + format: color.format || format, + r: mathMin(255, mathMax(rgb.r, 0)), + g: mathMin(255, mathMax(rgb.g, 0)), + b: mathMin(255, mathMax(rgb.b, 0)), + a: a + }; +} + + +// Conversion Functions +// -------------------- + +// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from: +// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript> + +// `rgbToRgb` +// Handle bounds / percentage checking to conform to CSS color spec +// <http://www.w3.org/TR/css3-color/> +// *Assumes:* r, g, b in [0, 255] or [0, 1] +// *Returns:* { r, g, b } in [0, 255] +function rgbToRgb(r, g, b){ + return { + r: bound01(r, 255) * 255, + g: bound01(g, 255) * 255, + b: bound01(b, 255) * 255 + }; +} + +// `rgbToHsl` +// Converts an RGB color value to HSL. +// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1] +// *Returns:* { h, s, l } in [0,1] +function rgbToHsl(r, g, b) { + + r = bound01(r, 255); + g = bound01(g, 255); + b = bound01(b, 255); + + var max = mathMax(r, g, b), min = mathMin(r, g, b); + var h, s, l = (max + min) / 2; + + if(max == min) { + h = s = 0; // achromatic + } + else { + var d = max - min; + s = l > 0.5 ? d / (2 - max - min) : d / (max + min); + switch(max) { + case r: h = (g - b) / d + (g < b ? 6 : 0); break; + case g: h = (b - r) / d + 2; break; + case b: h = (r - g) / d + 4; break; + } + + h /= 6; + } + + return { h: h, s: s, l: l }; +} + +// `hslToRgb` +// Converts an HSL color value to RGB. +// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100] +// *Returns:* { r, g, b } in the set [0, 255] +function hslToRgb(h, s, l) { + var r, g, b; + + h = bound01(h, 360); + s = bound01(s, 100); + l = bound01(l, 100); + + function hue2rgb(p, q, t) { + if(t < 0) t += 1; + if(t > 1) t -= 1; + if(t < 1/6) return p + (q - p) * 6 * t; + if(t < 1/2) return q; + if(t < 2/3) return p + (q - p) * (2/3 - t) * 6; + return p; + } + + if(s === 0) { + r = g = b = l; // achromatic + } + else { + var q = l < 0.5 ? l * (1 + s) : l + s - l * s; + var p = 2 * l - q; + r = hue2rgb(p, q, h + 1/3); + g = hue2rgb(p, q, h); + b = hue2rgb(p, q, h - 1/3); + } + + return { r: r * 255, g: g * 255, b: b * 255 }; +} + +// `rgbToHsv` +// Converts an RGB color value to HSV +// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1] +// *Returns:* { h, s, v } in [0,1] +function rgbToHsv(r, g, b) { + + r = bound01(r, 255); + g = bound01(g, 255); + b = bound01(b, 255); + + var max = mathMax(r, g, b), min = mathMin(r, g, b); + var h, s, v = max; + + var d = max - min; + s = max === 0 ? 0 : d / max; + + if(max == min) { + h = 0; // achromatic + } + else { + switch(max) { + case r: h = (g - b) / d + (g < b ? 6 : 0); break; + case g: h = (b - r) / d + 2; break; + case b: h = (r - g) / d + 4; break; + } + h /= 6; + } + return { h: h, s: s, v: v }; +} + +// `hsvToRgb` +// Converts an HSV color value to RGB. +// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100] +// *Returns:* { r, g, b } in the set [0, 255] + function hsvToRgb(h, s, v) { + + h = bound01(h, 360) * 6; + s = bound01(s, 100); + v = bound01(v, 100); + + var i = Math.floor(h), + f = h - i, + p = v * (1 - s), + q = v * (1 - f * s), + t = v * (1 - (1 - f) * s), + mod = i % 6, + r = [v, q, p, p, t, v][mod], + g = [t, v, v, q, p, p][mod], + b = [p, p, t, v, v, q][mod]; + + return { r: r * 255, g: g * 255, b: b * 255 }; +} + +// `rgbToHex` +// Converts an RGB color to hex +// Assumes r, g, and b are contained in the set [0, 255] +// Returns a 3 or 6 character hex +function rgbToHex(r, g, b, allow3Char) { + + var hex = [ + pad2(mathRound(r).toString(16)), + pad2(mathRound(g).toString(16)), + pad2(mathRound(b).toString(16)) + ]; + + // Return a 3 character hex if possible + if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) { + return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0); + } + + return hex.join(""); +} + +// `rgbaToHex` +// Converts an RGBA color plus alpha transparency to hex +// Assumes r, g, b are contained in the set [0, 255] and +// a in [0, 1]. Returns a 4 or 8 character rgba hex +function rgbaToHex(r, g, b, a, allow4Char) { + + var hex = [ + pad2(mathRound(r).toString(16)), + pad2(mathRound(g).toString(16)), + pad2(mathRound(b).toString(16)), + pad2(convertDecimalToHex(a)) + ]; + + // Return a 4 character hex if possible + if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) { + return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0); + } + + return hex.join(""); +} + +// `rgbaToArgbHex` +// Converts an RGBA color to an ARGB Hex8 string +// Rarely used, but required for "toFilter()" +function rgbaToArgbHex(r, g, b, a) { + + var hex = [ + pad2(convertDecimalToHex(a)), + pad2(mathRound(r).toString(16)), + pad2(mathRound(g).toString(16)), + pad2(mathRound(b).toString(16)) + ]; + + return hex.join(""); +} + +// `equals` +// Can be called with any tinycolor input +tinycolor.equals = function (color1, color2) { + if (!color1 || !color2) { return false; } + return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString(); +}; + +tinycolor.random = function() { + return tinycolor.fromRatio({ + r: mathRandom(), + g: mathRandom(), + b: mathRandom() + }); +}; + + +// Modification Functions +// ---------------------- +// Thanks to less.js for some of the basics here +// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js> + +function desaturate(color, amount) { + amount = (amount === 0) ? 0 : (amount || 10); + var hsl = tinycolor(color).toHsl(); + hsl.s -= amount / 100; + hsl.s = clamp01(hsl.s); + return tinycolor(hsl); +} + +function saturate(color, amount) { + amount = (amount === 0) ? 0 : (amount || 10); + var hsl = tinycolor(color).toHsl(); + hsl.s += amount / 100; + hsl.s = clamp01(hsl.s); + return tinycolor(hsl); +} + +function greyscale(color) { + return tinycolor(color).desaturate(100); +} + +function lighten (color, amount) { + amount = (amount === 0) ? 0 : (amount || 10); + var hsl = tinycolor(color).toHsl(); + hsl.l += amount / 100; + hsl.l = clamp01(hsl.l); + return tinycolor(hsl); +} + +function brighten(color, amount) { + amount = (amount === 0) ? 0 : (amount || 10); + var rgb = tinycolor(color).toRgb(); + rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100)))); + rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100)))); + rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100)))); + return tinycolor(rgb); +} + +function darken (color, amount) { + amount = (amount === 0) ? 0 : (amount || 10); + var hsl = tinycolor(color).toHsl(); + hsl.l -= amount / 100; + hsl.l = clamp01(hsl.l); + return tinycolor(hsl); +} + +// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue. +// Values outside of this range will be wrapped into this range. +function spin(color, amount) { + var hsl = tinycolor(color).toHsl(); + var hue = (hsl.h + amount) % 360; + hsl.h = hue < 0 ? 360 + hue : hue; + return tinycolor(hsl); +} + +// Combination Functions +// --------------------- +// Thanks to jQuery xColor for some of the ideas behind these +// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js> + +function complement(color) { + var hsl = tinycolor(color).toHsl(); + hsl.h = (hsl.h + 180) % 360; + return tinycolor(hsl); +} + +function triad(color) { + var hsl = tinycolor(color).toHsl(); + var h = hsl.h; + return [ + tinycolor(color), + tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }), + tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l }) + ]; +} + +function tetrad(color) { + var hsl = tinycolor(color).toHsl(); + var h = hsl.h; + return [ + tinycolor(color), + tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }), + tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }), + tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l }) + ]; +} + +function splitcomplement(color) { + var hsl = tinycolor(color).toHsl(); + var h = hsl.h; + return [ + tinycolor(color), + tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}), + tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l}) + ]; +} + +function analogous(color, results, slices) { + results = results || 6; + slices = slices || 30; + + var hsl = tinycolor(color).toHsl(); + var part = 360 / slices; + var ret = [tinycolor(color)]; + + for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) { + hsl.h = (hsl.h + part) % 360; + ret.push(tinycolor(hsl)); + } + return ret; +} + +function monochromatic(color, results) { + results = results || 6; + var hsv = tinycolor(color).toHsv(); + var h = hsv.h, s = hsv.s, v = hsv.v; + var ret = []; + var modification = 1 / results; + + while (results--) { + ret.push(tinycolor({ h: h, s: s, v: v})); + v = (v + modification) % 1; + } + + return ret; +} + +// Utility Functions +// --------------------- + +tinycolor.mix = function(color1, color2, amount) { + amount = (amount === 0) ? 0 : (amount || 50); + + var rgb1 = tinycolor(color1).toRgb(); + var rgb2 = tinycolor(color2).toRgb(); + + var p = amount / 100; + + var rgba = { + r: ((rgb2.r - rgb1.r) * p) + rgb1.r, + g: ((rgb2.g - rgb1.g) * p) + rgb1.g, + b: ((rgb2.b - rgb1.b) * p) + rgb1.b, + a: ((rgb2.a - rgb1.a) * p) + rgb1.a + }; + + return tinycolor(rgba); +}; + + +// Readability Functions +// --------------------- +// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2) + +// `contrast` +// Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2) +tinycolor.readability = function(color1, color2) { + var c1 = tinycolor(color1); + var c2 = tinycolor(color2); + return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05); +}; + +// `isReadable` +// Ensure that foreground and background color combinations meet WCAG2 guidelines. +// The third argument is an optional Object. +// the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA'; +// the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'. +// If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}. + +// *Example* +// tinycolor.isReadable("#000", "#111") => false +// tinycolor.isReadable("#000", "#111",{level:"AA",size:"large"}) => false +tinycolor.isReadable = function(color1, color2, wcag2) { + var readability = tinycolor.readability(color1, color2); + var wcag2Parms, out; + + out = false; + + wcag2Parms = validateWCAG2Parms(wcag2); + switch (wcag2Parms.level + wcag2Parms.size) { + case "AAsmall": + case "AAAlarge": + out = readability >= 4.5; + break; + case "AAlarge": + out = readability >= 3; + break; + case "AAAsmall": + out = readability >= 7; + break; + } + return out; + +}; + +// `mostReadable` +// Given a base color and a list of possible foreground or background +// colors for that base, returns the most readable color. +// Optionally returns Black or White if the most readable color is unreadable. +// *Example* +// tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:false}).toHexString(); // "#112255" +// tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:true}).toHexString(); // "#ffffff" +// tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"large"}).toHexString(); // "#faf3f3" +// tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"small"}).toHexString(); // "#ffffff" +tinycolor.mostReadable = function(baseColor, colorList, args) { + var bestColor = null; + var bestScore = 0; + var readability; + var includeFallbackColors, level, size ; + args = args || {}; + includeFallbackColors = args.includeFallbackColors ; + level = args.level; + size = args.size; + + for (var i= 0; i < colorList.length ; i++) { + readability = tinycolor.readability(baseColor, colorList[i]); + if (readability > bestScore) { + bestScore = readability; + bestColor = tinycolor(colorList[i]); + } + } + + if (tinycolor.isReadable(baseColor, bestColor, {"level":level,"size":size}) || !includeFallbackColors) { + return bestColor; + } + else { + args.includeFallbackColors=false; + return tinycolor.mostReadable(baseColor,["#fff", "#000"],args); + } +}; + + +// Big List of Colors +// ------------------ +// <http://www.w3.org/TR/css3-color/#svg-color> +var names = tinycolor.names = { + aliceblue: "f0f8ff", + antiquewhite: "faebd7", + aqua: "0ff", + aquamarine: "7fffd4", + azure: "f0ffff", + beige: "f5f5dc", + bisque: "ffe4c4", + black: "000", + blanchedalmond: "ffebcd", + blue: "00f", + blueviolet: "8a2be2", + brown: "a52a2a", + burlywood: "deb887", + burntsienna: "ea7e5d", + cadetblue: "5f9ea0", + chartreuse: "7fff00", + chocolate: "d2691e", + coral: "ff7f50", + cornflowerblue: "6495ed", + cornsilk: "fff8dc", + crimson: "dc143c", + cyan: "0ff", + darkblue: "00008b", + darkcyan: "008b8b", + darkgoldenrod: "b8860b", + darkgray: "a9a9a9", + darkgreen: "006400", + darkgrey: "a9a9a9", + darkkhaki: "bdb76b", + darkmagenta: "8b008b", + darkolivegreen: "556b2f", + darkorange: "ff8c00", + darkorchid: "9932cc", + darkred: "8b0000", + darksalmon: "e9967a", + darkseagreen: "8fbc8f", + darkslateblue: "483d8b", + darkslategray: "2f4f4f", + darkslategrey: "2f4f4f", + darkturquoise: "00ced1", + darkviolet: "9400d3", + deeppink: "ff1493", + deepskyblue: "00bfff", + dimgray: "696969", + dimgrey: "696969", + dodgerblue: "1e90ff", + firebrick: "b22222", + floralwhite: "fffaf0", + forestgreen: "228b22", + fuchsia: "f0f", + gainsboro: "dcdcdc", + ghostwhite: "f8f8ff", + gold: "ffd700", + goldenrod: "daa520", + gray: "808080", + green: "008000", + greenyellow: "adff2f", + grey: "808080", + honeydew: "f0fff0", + hotpink: "ff69b4", + indianred: "cd5c5c", + indigo: "4b0082", + ivory: "fffff0", + khaki: "f0e68c", + lavender: "e6e6fa", + lavenderblush: "fff0f5", + lawngreen: "7cfc00", + lemonchiffon: "fffacd", + lightblue: "add8e6", + lightcoral: "f08080", + lightcyan: "e0ffff", + lightgoldenrodyellow: "fafad2", + lightgray: "d3d3d3", + lightgreen: "90ee90", + lightgrey: "d3d3d3", + lightpink: "ffb6c1", + lightsalmon: "ffa07a", + lightseagreen: "20b2aa", + lightskyblue: "87cefa", + lightslategray: "789", + lightslategrey: "789", + lightsteelblue: "b0c4de", + lightyellow: "ffffe0", + lime: "0f0", + limegreen: "32cd32", + linen: "faf0e6", + magenta: "f0f", + maroon: "800000", + mediumaquamarine: "66cdaa", + mediumblue: "0000cd", + mediumorchid: "ba55d3", + mediumpurple: "9370db", + mediumseagreen: "3cb371", + mediumslateblue: "7b68ee", + mediumspringgreen: "00fa9a", + mediumturquoise: "48d1cc", + mediumvioletred: "c71585", + midnightblue: "191970", + mintcream: "f5fffa", + mistyrose: "ffe4e1", + moccasin: "ffe4b5", + navajowhite: "ffdead", + navy: "000080", + oldlace: "fdf5e6", + olive: "808000", + olivedrab: "6b8e23", + orange: "ffa500", + orangered: "ff4500", + orchid: "da70d6", + palegoldenrod: "eee8aa", + palegreen: "98fb98", + paleturquoise: "afeeee", + palevioletred: "db7093", + papayawhip: "ffefd5", + peachpuff: "ffdab9", + peru: "cd853f", + pink: "ffc0cb", + plum: "dda0dd", + powderblue: "b0e0e6", + purple: "800080", + rebeccapurple: "663399", + red: "f00", + rosybrown: "bc8f8f", + royalblue: "4169e1", + saddlebrown: "8b4513", + salmon: "fa8072", + sandybrown: "f4a460", + seagreen: "2e8b57", + seashell: "fff5ee", + sienna: "a0522d", + silver: "c0c0c0", + skyblue: "87ceeb", + slateblue: "6a5acd", + slategray: "708090", + slategrey: "708090", + snow: "fffafa", + springgreen: "00ff7f", + steelblue: "4682b4", + tan: "d2b48c", + teal: "008080", + thistle: "d8bfd8", + tomato: "ff6347", + turquoise: "40e0d0", + violet: "ee82ee", + wheat: "f5deb3", + white: "fff", + whitesmoke: "f5f5f5", + yellow: "ff0", + yellowgreen: "9acd32" +}; + +// Make it easy to access colors via `hexNames[hex]` +var hexNames = tinycolor.hexNames = flip(names); + + +// Utilities +// --------- + +// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }` +function flip(o) { + var flipped = { }; + for (var i in o) { + if (o.hasOwnProperty(i)) { + flipped[o[i]] = i; + } + } + return flipped; +} + +// Return a valid alpha value [0,1] with all invalid values being set to 1 +function boundAlpha(a) { + a = parseFloat(a); + + if (isNaN(a) || a < 0 || a > 1) { + a = 1; + } + + return a; +} + +// Take input from [0, n] and return it as [0, 1] +function bound01(n, max) { + if (isOnePointZero(n)) { n = "100%"; } + + var processPercent = isPercentage(n); + n = mathMin(max, mathMax(0, parseFloat(n))); + + // Automatically convert percentage into number + if (processPercent) { + n = parseInt(n * max, 10) / 100; + } + + // Handle floating point rounding errors + if ((Math.abs(n - max) < 0.000001)) { + return 1; + } + + // Convert into [0, 1] range if it isn't already + return (n % max) / parseFloat(max); +} + +// Force a number between 0 and 1 +function clamp01(val) { + return mathMin(1, mathMax(0, val)); +} + +// Parse a base-16 hex value into a base-10 integer +function parseIntFromHex(val) { + return parseInt(val, 16); +} + +// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1 +// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0> +function isOnePointZero(n) { + return typeof n == "string" && n.indexOf('.') != -1 && parseFloat(n) === 1; +} + +// Check to see if string passed in is a percentage +function isPercentage(n) { + return typeof n === "string" && n.indexOf('%') != -1; +} + +// Force a hex value to have 2 characters +function pad2(c) { + return c.length == 1 ? '0' + c : '' + c; +} + +// Replace a decimal with it's percentage value +function convertToPercentage(n) { + if (n <= 1) { + n = (n * 100) + "%"; + } + + return n; +} + +// Converts a decimal to a hex value +function convertDecimalToHex(d) { + return Math.round(parseFloat(d) * 255).toString(16); +} +// Converts a hex value to a decimal +function convertHexToDecimal(h) { + return (parseIntFromHex(h) / 255); +} + +var matchers = (function() { + + // <http://www.w3.org/TR/css3-values/#integers> + var CSS_INTEGER = "[-\\+]?\\d+%?"; + + // <http://www.w3.org/TR/css3-values/#number-value> + var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?"; + + // Allow positive/negative integer/number. Don't capture the either/or, just the entire outcome. + var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")"; + + // Actual matching. + // Parentheses and commas are optional, but not required. + // Whitespace can take the place of commas or opening paren + var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?"; + var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?"; + + return { + CSS_UNIT: new RegExp(CSS_UNIT), + rgb: new RegExp("rgb" + PERMISSIVE_MATCH3), + rgba: new RegExp("rgba" + PERMISSIVE_MATCH4), + hsl: new RegExp("hsl" + PERMISSIVE_MATCH3), + hsla: new RegExp("hsla" + PERMISSIVE_MATCH4), + hsv: new RegExp("hsv" + PERMISSIVE_MATCH3), + hsva: new RegExp("hsva" + PERMISSIVE_MATCH4), + hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, + hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/, + hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/, + hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/ + }; +})(); + +// `isValidCSSUnit` +// Take in a single string / number and check to see if it looks like a CSS unit +// (see `matchers` above for definition). +function isValidCSSUnit(color) { + return !!matchers.CSS_UNIT.exec(color); +} + +// `stringInputToObject` +// Permissive string parsing. Take in a number of formats, and output an object +// based on detected format. Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}` +function stringInputToObject(color) { + + color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase(); + var named = false; + if (names[color]) { + color = names[color]; + named = true; + } + else if (color == 'transparent') { + return { r: 0, g: 0, b: 0, a: 0, format: "name" }; + } + + // Try to match string input using regular expressions. + // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360] + // Just return an object and let the conversion functions handle that. + // This way the result will be the same whether the tinycolor is initialized with string or object. + var match; + if ((match = matchers.rgb.exec(color))) { + return { r: match[1], g: match[2], b: match[3] }; + } + if ((match = matchers.rgba.exec(color))) { + return { r: match[1], g: match[2], b: match[3], a: match[4] }; + } + if ((match = matchers.hsl.exec(color))) { + return { h: match[1], s: match[2], l: match[3] }; + } + if ((match = matchers.hsla.exec(color))) { + return { h: match[1], s: match[2], l: match[3], a: match[4] }; + } + if ((match = matchers.hsv.exec(color))) { + return { h: match[1], s: match[2], v: match[3] }; + } + if ((match = matchers.hsva.exec(color))) { + return { h: match[1], s: match[2], v: match[3], a: match[4] }; + } + if ((match = matchers.hex8.exec(color))) { + return { + r: parseIntFromHex(match[1]), + g: parseIntFromHex(match[2]), + b: parseIntFromHex(match[3]), + a: convertHexToDecimal(match[4]), + format: named ? "name" : "hex8" + }; + } + if ((match = matchers.hex6.exec(color))) { + return { + r: parseIntFromHex(match[1]), + g: parseIntFromHex(match[2]), + b: parseIntFromHex(match[3]), + format: named ? "name" : "hex" + }; + } + if ((match = matchers.hex4.exec(color))) { + return { + r: parseIntFromHex(match[1] + '' + match[1]), + g: parseIntFromHex(match[2] + '' + match[2]), + b: parseIntFromHex(match[3] + '' + match[3]), + a: convertHexToDecimal(match[4] + '' + match[4]), + format: named ? "name" : "hex8" + }; + } + if ((match = matchers.hex3.exec(color))) { + return { + r: parseIntFromHex(match[1] + '' + match[1]), + g: parseIntFromHex(match[2] + '' + match[2]), + b: parseIntFromHex(match[3] + '' + match[3]), + format: named ? "name" : "hex" + }; + } + + return false; +} + +function validateWCAG2Parms(parms) { + // return valid WCAG2 parms for isReadable. + // If input parms are invalid, return {"level":"AA", "size":"small"} + var level, size; + parms = parms || {"level":"AA", "size":"small"}; + level = (parms.level || "AA").toUpperCase(); + size = (parms.size || "small").toLowerCase(); + if (level !== "AA" && level !== "AAA") { + level = "AA"; + } + if (size !== "small" && size !== "large") { + size = "small"; + } + return {"level":level, "size":size}; +} + +// Node: Export function +if ( true && module.exports) { + module.exports = tinycolor; +} +// AMD/requirejs: Define the module +else if (true) { + !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {return tinycolor;}).call(exports, __webpack_require__, exports, module), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); +} +// Browser: Expose to window +else {} + +})(Math); + + +/***/ }), + +/***/ 5: +/***/ (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; +} + +/***/ }), + +/***/ 52: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["htmlEntities"]; }()); + +/***/ }), + +/***/ 62: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +exports.__esModule = true; +var TextareaAutosize_1 = __webpack_require__(115); +exports["default"] = TextareaAutosize_1["default"]; + + +/***/ }), + +/***/ 64: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, '__esModule', { value: true }); + +function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; } + +var _extends = _interopDefault(__webpack_require__(119)); +var _objectWithoutPropertiesLoose = _interopDefault(__webpack_require__(120)); +var React = __webpack_require__(28); +var React__default = _interopDefault(React); +var _inheritsLoose = _interopDefault(__webpack_require__(121)); +var _assertThisInitialized = _interopDefault(__webpack_require__(122)); + +var is = { + arr: Array.isArray, + obj: function obj(a) { + return Object.prototype.toString.call(a) === '[object Object]'; + }, + fun: function fun(a) { + return typeof a === 'function'; + }, + str: function str(a) { + return typeof a === 'string'; + }, + num: function num(a) { + return typeof a === 'number'; + }, + und: function und(a) { + return a === void 0; + }, + nul: function nul(a) { + return a === null; + }, + set: function set(a) { + return a instanceof Set; + }, + map: function map(a) { + return a instanceof Map; + }, + equ: function equ(a, b) { + if (typeof a !== typeof b) return false; + if (is.str(a) || is.num(a)) return a === b; + if (is.obj(a) && is.obj(b) && Object.keys(a).length + Object.keys(b).length === 0) return true; + var i; + + for (i in a) { + if (!(i in b)) return false; + } + + for (i in b) { + if (a[i] !== b[i]) return false; + } + + return is.und(i) ? a === b : true; + } +}; +function merge(target, lowercase) { + if (lowercase === void 0) { + lowercase = true; + } + + return function (object) { + return (is.arr(object) ? object : Object.keys(object)).reduce(function (acc, element) { + var key = lowercase ? element[0].toLowerCase() + element.substring(1) : element; + acc[key] = target(key); + return acc; + }, target); + }; +} +function useForceUpdate() { + var _useState = React.useState(false), + f = _useState[1]; + + var forceUpdate = React.useCallback(function () { + return f(function (v) { + return !v; + }); + }, []); + return forceUpdate; +} +function withDefault(value, defaultValue) { + return is.und(value) || is.nul(value) ? defaultValue : value; +} +function toArray(a) { + return !is.und(a) ? is.arr(a) ? a : [a] : []; +} +function callProp(obj) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return is.fun(obj) ? obj.apply(void 0, args) : obj; +} + +function getForwardProps(props) { + var to = props.to, + from = props.from, + config = props.config, + onStart = props.onStart, + onRest = props.onRest, + onFrame = props.onFrame, + children = props.children, + reset = props.reset, + reverse = props.reverse, + force = props.force, + immediate = props.immediate, + delay = props.delay, + attach = props.attach, + destroyed = props.destroyed, + interpolateTo = props.interpolateTo, + ref = props.ref, + lazy = props.lazy, + forward = _objectWithoutPropertiesLoose(props, ["to", "from", "config", "onStart", "onRest", "onFrame", "children", "reset", "reverse", "force", "immediate", "delay", "attach", "destroyed", "interpolateTo", "ref", "lazy"]); + + return forward; +} + +function interpolateTo(props) { + var forward = getForwardProps(props); + if (is.und(forward)) return _extends({ + to: forward + }, props); + var rest = Object.keys(props).reduce(function (a, k) { + var _extends2; + + return !is.und(forward[k]) ? a : _extends({}, a, (_extends2 = {}, _extends2[k] = props[k], _extends2)); + }, {}); + return _extends({ + to: forward + }, rest); +} +function handleRef(ref, forward) { + if (forward) { + // If it's a function, assume it's a ref callback + if (is.fun(forward)) forward(ref);else if (is.obj(forward)) { + forward.current = ref; + } + } + + return ref; +} + +var Animated = +/*#__PURE__*/ +function () { + function Animated() { + this.payload = void 0; + this.children = []; + } + + var _proto = Animated.prototype; + + _proto.getAnimatedValue = function getAnimatedValue() { + return this.getValue(); + }; + + _proto.getPayload = function getPayload() { + return this.payload || this; + }; + + _proto.attach = function attach() {}; + + _proto.detach = function detach() {}; + + _proto.getChildren = function getChildren() { + return this.children; + }; + + _proto.addChild = function addChild(child) { + if (this.children.length === 0) this.attach(); + this.children.push(child); + }; + + _proto.removeChild = function removeChild(child) { + var index = this.children.indexOf(child); + this.children.splice(index, 1); + if (this.children.length === 0) this.detach(); + }; + + return Animated; +}(); +var AnimatedArray = +/*#__PURE__*/ +function (_Animated) { + _inheritsLoose(AnimatedArray, _Animated); + + function AnimatedArray() { + var _this; + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _Animated.call.apply(_Animated, [this].concat(args)) || this; + _this.payload = []; + + _this.attach = function () { + return _this.payload.forEach(function (p) { + return p instanceof Animated && p.addChild(_assertThisInitialized(_this)); + }); + }; + + _this.detach = function () { + return _this.payload.forEach(function (p) { + return p instanceof Animated && p.removeChild(_assertThisInitialized(_this)); + }); + }; + + return _this; + } + + return AnimatedArray; +}(Animated); +var AnimatedObject = +/*#__PURE__*/ +function (_Animated2) { + _inheritsLoose(AnimatedObject, _Animated2); + + function AnimatedObject() { + var _this2; + + for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments[_key3]; + } + + _this2 = _Animated2.call.apply(_Animated2, [this].concat(args)) || this; + _this2.payload = {}; + + _this2.attach = function () { + return Object.values(_this2.payload).forEach(function (s) { + return s instanceof Animated && s.addChild(_assertThisInitialized(_this2)); + }); + }; + + _this2.detach = function () { + return Object.values(_this2.payload).forEach(function (s) { + return s instanceof Animated && s.removeChild(_assertThisInitialized(_this2)); + }); + }; + + return _this2; + } + + var _proto2 = AnimatedObject.prototype; + + _proto2.getValue = function getValue(animated) { + if (animated === void 0) { + animated = false; + } + + var payload = {}; + + for (var _key4 in this.payload) { + var value = this.payload[_key4]; + if (animated && !(value instanceof Animated)) continue; + payload[_key4] = value instanceof Animated ? value[animated ? 'getAnimatedValue' : 'getValue']() : value; + } + + return payload; + }; + + _proto2.getAnimatedValue = function getAnimatedValue() { + return this.getValue(true); + }; + + return AnimatedObject; +}(Animated); + +var applyAnimatedValues; +function injectApplyAnimatedValues(fn, transform) { + applyAnimatedValues = { + fn: fn, + transform: transform + }; +} +var colorNames; +function injectColorNames(names) { + colorNames = names; +} +var requestFrame = function requestFrame(cb) { + return typeof window !== 'undefined' ? window.requestAnimationFrame(cb) : -1; +}; +var cancelFrame = function cancelFrame(id) { + typeof window !== 'undefined' && window.cancelAnimationFrame(id); +}; +function injectFrame(raf, caf) { + requestFrame = raf; + cancelFrame = caf; +} +var interpolation; +function injectStringInterpolator(fn) { + interpolation = fn; +} +var now = function now() { + return Date.now(); +}; +function injectNow(nowFn) { + now = nowFn; +} +var defaultElement; +function injectDefaultElement(el) { + defaultElement = el; +} +var animatedApi = function animatedApi(node) { + return node.current; +}; +function injectAnimatedApi(fn) { + animatedApi = fn; +} +var createAnimatedStyle; +function injectCreateAnimatedStyle(factory) { + createAnimatedStyle = factory; +} +var manualFrameloop; +function injectManualFrameloop(callback) { + manualFrameloop = callback; +} + +var Globals = /*#__PURE__*/Object.freeze({ + get applyAnimatedValues () { return applyAnimatedValues; }, + injectApplyAnimatedValues: injectApplyAnimatedValues, + get colorNames () { return colorNames; }, + injectColorNames: injectColorNames, + get requestFrame () { return requestFrame; }, + get cancelFrame () { return cancelFrame; }, + injectFrame: injectFrame, + get interpolation () { return interpolation; }, + injectStringInterpolator: injectStringInterpolator, + get now () { return now; }, + injectNow: injectNow, + get defaultElement () { return defaultElement; }, + injectDefaultElement: injectDefaultElement, + get animatedApi () { return animatedApi; }, + injectAnimatedApi: injectAnimatedApi, + get createAnimatedStyle () { return createAnimatedStyle; }, + injectCreateAnimatedStyle: injectCreateAnimatedStyle, + get manualFrameloop () { return manualFrameloop; }, + injectManualFrameloop: injectManualFrameloop +}); + +/** + * Wraps the `style` property with `AnimatedStyle`. + */ + +var AnimatedProps = +/*#__PURE__*/ +function (_AnimatedObject) { + _inheritsLoose(AnimatedProps, _AnimatedObject); + + function AnimatedProps(props, callback) { + var _this; + + _this = _AnimatedObject.call(this) || this; + _this.update = void 0; + _this.payload = !props.style ? props : _extends({}, props, { + style: createAnimatedStyle(props.style) + }); + _this.update = callback; + + _this.attach(); + + return _this; + } + + return AnimatedProps; +}(AnimatedObject); + +var isFunctionComponent = function isFunctionComponent(val) { + return is.fun(val) && !(val.prototype instanceof React__default.Component); +}; + +var createAnimatedComponent = function createAnimatedComponent(Component) { + var AnimatedComponent = React.forwardRef(function (props, ref) { + var forceUpdate = useForceUpdate(); + var mounted = React.useRef(true); + var propsAnimated = React.useRef(null); + var node = React.useRef(null); + var attachProps = React.useCallback(function (props) { + var oldPropsAnimated = propsAnimated.current; + + var callback = function callback() { + var didUpdate = false; + + if (node.current) { + didUpdate = applyAnimatedValues.fn(node.current, propsAnimated.current.getAnimatedValue()); + } + + if (!node.current || didUpdate === false) { + // If no referenced node has been found, or the update target didn't have a + // native-responder, then forceUpdate the animation ... + forceUpdate(); + } + }; + + propsAnimated.current = new AnimatedProps(props, callback); + oldPropsAnimated && oldPropsAnimated.detach(); + }, []); + React.useEffect(function () { + return function () { + mounted.current = false; + propsAnimated.current && propsAnimated.current.detach(); + }; + }, []); + React.useImperativeHandle(ref, function () { + return animatedApi(node, mounted, forceUpdate); + }); + attachProps(props); + + var _getValue = propsAnimated.current.getValue(), + scrollTop = _getValue.scrollTop, + scrollLeft = _getValue.scrollLeft, + animatedProps = _objectWithoutPropertiesLoose(_getValue, ["scrollTop", "scrollLeft"]); // Functions cannot have refs, see: + // See: https://github.com/react-spring/react-spring/issues/569 + + + var refFn = isFunctionComponent(Component) ? undefined : function (childRef) { + return node.current = handleRef(childRef, ref); + }; + return React__default.createElement(Component, _extends({}, animatedProps, { + ref: refFn + })); + }); + return AnimatedComponent; +}; + +var active = false; +var controllers = new Set(); + +var update = function update() { + if (!active) return false; + var time = now(); + + for (var _iterator = controllers, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref; + + if (_isArray) { + if (_i >= _iterator.length) break; + _ref = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) break; + _ref = _i.value; + } + + var controller = _ref; + var isActive = false; + + for (var configIdx = 0; configIdx < controller.configs.length; configIdx++) { + var config = controller.configs[configIdx]; + var endOfAnimation = void 0, + lastTime = void 0; + + for (var valIdx = 0; valIdx < config.animatedValues.length; valIdx++) { + var animation = config.animatedValues[valIdx]; // If an animation is done, skip, until all of them conclude + + if (animation.done) continue; + var from = config.fromValues[valIdx]; + var to = config.toValues[valIdx]; + var position = animation.lastPosition; + var isAnimated = to instanceof Animated; + var velocity = Array.isArray(config.initialVelocity) ? config.initialVelocity[valIdx] : config.initialVelocity; + if (isAnimated) to = to.getValue(); // Conclude animation if it's either immediate, or from-values match end-state + + if (config.immediate) { + animation.setValue(to); + animation.done = true; + continue; + } // Break animation when string values are involved + + + if (typeof from === 'string' || typeof to === 'string') { + animation.setValue(to); + animation.done = true; + continue; + } + + if (config.duration !== void 0) { + /** Duration easing */ + position = from + config.easing((time - animation.startTime) / config.duration) * (to - from); + endOfAnimation = time >= animation.startTime + config.duration; + } else if (config.decay) { + /** Decay easing */ + position = from + velocity / (1 - 0.998) * (1 - Math.exp(-(1 - 0.998) * (time - animation.startTime))); + endOfAnimation = Math.abs(animation.lastPosition - position) < 0.1; + if (endOfAnimation) to = position; + } else { + /** Spring easing */ + lastTime = animation.lastTime !== void 0 ? animation.lastTime : time; + velocity = animation.lastVelocity !== void 0 ? animation.lastVelocity : config.initialVelocity; // If we lost a lot of frames just jump to the end. + + if (time > lastTime + 64) lastTime = time; // http://gafferongames.com/game-physics/fix-your-timestep/ + + var numSteps = Math.floor(time - lastTime); + + for (var i = 0; i < numSteps; ++i) { + var force = -config.tension * (position - to); + var damping = -config.friction * velocity; + var acceleration = (force + damping) / config.mass; + velocity = velocity + acceleration * 1 / 1000; + position = position + velocity * 1 / 1000; + } // Conditions for stopping the spring animation + + + var isOvershooting = config.clamp && config.tension !== 0 ? from < to ? position > to : position < to : false; + var isVelocity = Math.abs(velocity) <= config.precision; + var isDisplacement = config.tension !== 0 ? Math.abs(to - position) <= config.precision : true; + endOfAnimation = isOvershooting || isVelocity && isDisplacement; + animation.lastVelocity = velocity; + animation.lastTime = time; + } // Trails aren't done until their parents conclude + + + if (isAnimated && !config.toValues[valIdx].done) endOfAnimation = false; + + if (endOfAnimation) { + // Ensure that we end up with a round value + if (animation.value !== to) position = to; + animation.done = true; + } else isActive = true; + + animation.setValue(position); + animation.lastPosition = position; + } // Keep track of updated values only when necessary + + + if (controller.props.onFrame) controller.values[config.name] = config.interpolation.getValue(); + } // Update callbacks in the end of the frame + + + if (controller.props.onFrame) controller.props.onFrame(controller.values); // Either call onEnd or next frame + + if (!isActive) { + controllers.delete(controller); + controller.stop(true); + } + } // Loop over as long as there are controllers ... + + + if (controllers.size) { + if (manualFrameloop) manualFrameloop();else requestFrame(update); + } else { + active = false; + } + + return active; +}; + +var start = function start(controller) { + if (!controllers.has(controller)) controllers.add(controller); + + if (!active) { + active = true; + if (manualFrameloop) requestFrame(manualFrameloop);else requestFrame(update); + } +}; + +var stop = function stop(controller) { + if (controllers.has(controller)) controllers.delete(controller); +}; + +function createInterpolator(range, output, extrapolate) { + if (typeof range === 'function') { + return range; + } + + if (Array.isArray(range)) { + return createInterpolator({ + range: range, + output: output, + extrapolate: extrapolate + }); + } + + if (interpolation && typeof range.output[0] === 'string') { + return interpolation(range); + } + + var config = range; + var outputRange = config.output; + var inputRange = config.range || [0, 1]; + var extrapolateLeft = config.extrapolateLeft || config.extrapolate || 'extend'; + var extrapolateRight = config.extrapolateRight || config.extrapolate || 'extend'; + + var easing = config.easing || function (t) { + return t; + }; + + return function (input) { + var range = findRange(input, inputRange); + return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight, config.map); + }; +} + +function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight, map) { + var result = map ? map(input) : input; // Extrapolate + + if (result < inputMin) { + if (extrapolateLeft === 'identity') return result;else if (extrapolateLeft === 'clamp') result = inputMin; + } + + if (result > inputMax) { + if (extrapolateRight === 'identity') return result;else if (extrapolateRight === 'clamp') result = inputMax; + } + + if (outputMin === outputMax) return outputMin; + if (inputMin === inputMax) return input <= inputMin ? outputMin : outputMax; // Input Range + + if (inputMin === -Infinity) result = -result;else if (inputMax === Infinity) result = result - inputMin;else result = (result - inputMin) / (inputMax - inputMin); // Easing + + result = easing(result); // Output Range + + if (outputMin === -Infinity) result = -result;else if (outputMax === Infinity) result = result + outputMin;else result = result * (outputMax - outputMin) + outputMin; + return result; +} + +function findRange(input, inputRange) { + for (var i = 1; i < inputRange.length - 1; ++i) { + if (inputRange[i] >= input) break; + } + + return i - 1; +} + +var AnimatedInterpolation = +/*#__PURE__*/ +function (_AnimatedArray) { + _inheritsLoose(AnimatedInterpolation, _AnimatedArray); + + function AnimatedInterpolation(parents, range, output, extrapolate) { + var _this; + + _this = _AnimatedArray.call(this) || this; + _this.calc = void 0; + _this.payload = parents instanceof AnimatedArray && !(parents instanceof AnimatedInterpolation) ? parents.getPayload() : Array.isArray(parents) ? parents : [parents]; + _this.calc = createInterpolator(range, output, extrapolate); + return _this; + } + + var _proto = AnimatedInterpolation.prototype; + + _proto.getValue = function getValue() { + return this.calc.apply(this, this.payload.map(function (value) { + return value.getValue(); + })); + }; + + _proto.updateConfig = function updateConfig(range, output, extrapolate) { + this.calc = createInterpolator(range, output, extrapolate); + }; + + _proto.interpolate = function interpolate(range, output, extrapolate) { + return new AnimatedInterpolation(this, range, output, extrapolate); + }; + + return AnimatedInterpolation; +}(AnimatedArray); + +var interpolate$1 = function interpolate(parents, range, output) { + return parents && new AnimatedInterpolation(parents, range, output); +}; + +var config = { + default: { + tension: 170, + friction: 26 + }, + gentle: { + tension: 120, + friction: 14 + }, + wobbly: { + tension: 180, + friction: 12 + }, + stiff: { + tension: 210, + friction: 20 + }, + slow: { + tension: 280, + friction: 60 + }, + molasses: { + tension: 280, + friction: 120 + } +}; + +/** API + * useChain(references, timeSteps, timeFrame) + */ + +function useChain(refs, timeSteps, timeFrame) { + if (timeFrame === void 0) { + timeFrame = 1000; + } + + var previous = React.useRef(); + React.useEffect(function () { + if (is.equ(refs, previous.current)) refs.forEach(function (_ref) { + var current = _ref.current; + return current && current.start(); + });else if (timeSteps) { + refs.forEach(function (_ref2, index) { + var current = _ref2.current; + + if (current) { + var ctrls = current.controllers; + + if (ctrls.length) { + var t = timeFrame * timeSteps[index]; + ctrls.forEach(function (ctrl) { + ctrl.queue = ctrl.queue.map(function (e) { + return _extends({}, e, { + delay: e.delay + t + }); + }); + ctrl.start(); + }); + } + } + }); + } else refs.reduce(function (q, _ref3, rI) { + var current = _ref3.current; + return q = q.then(function () { + return current.start(); + }); + }, Promise.resolve()); + previous.current = refs; + }); +} + +/** + * Animated works by building a directed acyclic graph of dependencies + * transparently when you render your Animated components. + * + * new Animated.Value(0) + * .interpolate() .interpolate() new Animated.Value(1) + * opacity translateY scale + * style transform + * View#234 style + * View#123 + * + * A) Top Down phase + * When an AnimatedValue is updated, we recursively go down through this + * graph in order to find leaf nodes: the views that we flag as needing + * an update. + * + * B) Bottom Up phase + * When a view is flagged as needing an update, we recursively go back up + * in order to build the new value that it needs. The reason why we need + * this two-phases process is to deal with composite props such as + * transform which can receive values from multiple parents. + */ +function addAnimatedStyles(node, styles) { + if ('update' in node) { + styles.add(node); + } else { + node.getChildren().forEach(function (child) { + return addAnimatedStyles(child, styles); + }); + } +} + +var AnimatedValue = +/*#__PURE__*/ +function (_Animated) { + _inheritsLoose(AnimatedValue, _Animated); + + function AnimatedValue(_value) { + var _this; + + _this = _Animated.call(this) || this; + _this.animatedStyles = new Set(); + _this.value = void 0; + _this.startPosition = void 0; + _this.lastPosition = void 0; + _this.lastVelocity = void 0; + _this.startTime = void 0; + _this.lastTime = void 0; + _this.done = false; + + _this.setValue = function (value, flush) { + if (flush === void 0) { + flush = true; + } + + _this.value = value; + if (flush) _this.flush(); + }; + + _this.value = _value; + _this.startPosition = _value; + _this.lastPosition = _value; + return _this; + } + + var _proto = AnimatedValue.prototype; + + _proto.flush = function flush() { + if (this.animatedStyles.size === 0) { + addAnimatedStyles(this, this.animatedStyles); + } + + this.animatedStyles.forEach(function (animatedStyle) { + return animatedStyle.update(); + }); + }; + + _proto.clearStyles = function clearStyles() { + this.animatedStyles.clear(); + }; + + _proto.getValue = function getValue() { + return this.value; + }; + + _proto.interpolate = function interpolate(range, output, extrapolate) { + return new AnimatedInterpolation(this, range, output, extrapolate); + }; + + return AnimatedValue; +}(Animated); + +var AnimatedValueArray = +/*#__PURE__*/ +function (_AnimatedArray) { + _inheritsLoose(AnimatedValueArray, _AnimatedArray); + + function AnimatedValueArray(values) { + var _this; + + _this = _AnimatedArray.call(this) || this; + _this.payload = values.map(function (n) { + return new AnimatedValue(n); + }); + return _this; + } + + var _proto = AnimatedValueArray.prototype; + + _proto.setValue = function setValue(value, flush) { + var _this2 = this; + + if (flush === void 0) { + flush = true; + } + + if (Array.isArray(value)) { + if (value.length === this.payload.length) { + value.forEach(function (v, i) { + return _this2.payload[i].setValue(v, flush); + }); + } + } else { + this.payload.forEach(function (p) { + return p.setValue(value, flush); + }); + } + }; + + _proto.getValue = function getValue() { + return this.payload.map(function (v) { + return v.getValue(); + }); + }; + + _proto.interpolate = function interpolate(range, output) { + return new AnimatedInterpolation(this, range, output); + }; + + return AnimatedValueArray; +}(AnimatedArray); + +var G = 0; + +var Controller = +/*#__PURE__*/ +function () { + function Controller() { + var _this = this; + + this.id = void 0; + this.idle = true; + this.hasChanged = false; + this.guid = 0; + this.local = 0; + this.props = {}; + this.merged = {}; + this.animations = {}; + this.interpolations = {}; + this.values = {}; + this.configs = []; + this.listeners = []; + this.queue = []; + this.localQueue = void 0; + + this.getValues = function () { + return _this.interpolations; + }; + + this.id = G++; + } + /** update(props) + * This function filters input props and creates an array of tasks which are executed in .start() + * Each task is allowed to carry a delay, which means it can execute asnychroneously */ + + + var _proto = Controller.prototype; + + _proto.update = function update$$1(args) { + //this._id = n + this.id + if (!args) return this; // Extract delay and the to-prop from props + + var _ref = interpolateTo(args), + _ref$delay = _ref.delay, + delay = _ref$delay === void 0 ? 0 : _ref$delay, + to = _ref.to, + props = _objectWithoutPropertiesLoose(_ref, ["delay", "to"]); + + if (is.arr(to) || is.fun(to)) { + // If config is either a function or an array queue it up as is + this.queue.push(_extends({}, props, { + delay: delay, + to: to + })); + } else if (to) { + // Otherwise go through each key since it could be delayed individually + var ops = {}; + Object.entries(to).forEach(function (_ref2) { + var _to; + + var k = _ref2[0], + v = _ref2[1]; + + // Fetch delay and create an entry, consisting of the to-props, the delay, and basic props + var entry = _extends({ + to: (_to = {}, _to[k] = v, _to), + delay: callProp(delay, k) + }, props); + + var previous = ops[entry.delay] && ops[entry.delay].to; + ops[entry.delay] = _extends({}, ops[entry.delay], entry, { + to: _extends({}, previous, entry.to) + }); + }); + this.queue = Object.values(ops); + } // Sort queue, so that async calls go last + + + this.queue = this.queue.sort(function (a, b) { + return a.delay - b.delay; + }); // Diff the reduced props immediately (they'll contain the from-prop and some config) + + this.diff(props); + return this; + } + /** start(onEnd) + * This function either executes a queue, if present, or starts the frameloop, which animates */ + ; + + _proto.start = function start$$1(onEnd) { + var _this2 = this; + + // If a queue is present we must excecute it + if (this.queue.length) { + this.idle = false; // Updates can interrupt trailing queues, in that case we just merge values + + if (this.localQueue) { + this.localQueue.forEach(function (_ref3) { + var _ref3$from = _ref3.from, + from = _ref3$from === void 0 ? {} : _ref3$from, + _ref3$to = _ref3.to, + to = _ref3$to === void 0 ? {} : _ref3$to; + if (is.obj(from)) _this2.merged = _extends({}, from, _this2.merged); + if (is.obj(to)) _this2.merged = _extends({}, _this2.merged, to); + }); + } // The guid helps us tracking frames, a new queue over an old one means an override + // We discard async calls in that caseÍ + + + var local = this.local = ++this.guid; + var queue = this.localQueue = this.queue; + this.queue = []; // Go through each entry and execute it + + queue.forEach(function (_ref4, index) { + var delay = _ref4.delay, + props = _objectWithoutPropertiesLoose(_ref4, ["delay"]); + + var cb = function cb(finished) { + if (index === queue.length - 1 && local === _this2.guid && finished) { + _this2.idle = true; + if (_this2.props.onRest) _this2.props.onRest(_this2.merged); + } + + if (onEnd) onEnd(); + }; // Entries can be delayed, ansyc or immediate + + + var async = is.arr(props.to) || is.fun(props.to); + + if (delay) { + setTimeout(function () { + if (local === _this2.guid) { + if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb); + } + }, delay); + } else if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb); + }); + } // Otherwise we kick of the frameloop + else { + if (is.fun(onEnd)) this.listeners.push(onEnd); + if (this.props.onStart) this.props.onStart(); + + start(this); + } + + return this; + }; + + _proto.stop = function stop$$1(finished) { + this.listeners.forEach(function (onEnd) { + return onEnd(finished); + }); + this.listeners = []; + return this; + } + /** Pause sets onEnd listeners free, but also removes the controller from the frameloop */ + ; + + _proto.pause = function pause(finished) { + this.stop(true); + if (finished) stop(this); + return this; + }; + + _proto.runAsync = function runAsync(_ref5, onEnd) { + var _this3 = this; + + var delay = _ref5.delay, + props = _objectWithoutPropertiesLoose(_ref5, ["delay"]); + + var local = this.local; // If "to" is either a function or an array it will be processed async, therefor "to" should be empty right now + // If the view relies on certain values "from" has to be present + + var queue = Promise.resolve(undefined); + + if (is.arr(props.to)) { + var _loop = function _loop(i) { + var index = i; + + var fresh = _extends({}, props, interpolateTo(props.to[index])); + + if (is.arr(fresh.config)) fresh.config = fresh.config[index]; + queue = queue.then(function () { + //this.stop() + if (local === _this3.guid) return new Promise(function (r) { + return _this3.diff(fresh).start(r); + }); + }); + }; + + for (var i = 0; i < props.to.length; i++) { + _loop(i); + } + } else if (is.fun(props.to)) { + var index = 0; + var last; + queue = queue.then(function () { + return props.to( // next(props) + function (p) { + var fresh = _extends({}, props, interpolateTo(p)); + + if (is.arr(fresh.config)) fresh.config = fresh.config[index]; + index++; //this.stop() + + if (local === _this3.guid) return last = new Promise(function (r) { + return _this3.diff(fresh).start(r); + }); + return; + }, // cancel() + function (finished) { + if (finished === void 0) { + finished = true; + } + + return _this3.stop(finished); + }).then(function () { + return last; + }); + }); + } + + queue.then(onEnd); + }; + + _proto.diff = function diff(props) { + var _this4 = this; + + this.props = _extends({}, this.props, props); + var _this$props = this.props, + _this$props$from = _this$props.from, + from = _this$props$from === void 0 ? {} : _this$props$from, + _this$props$to = _this$props.to, + to = _this$props$to === void 0 ? {} : _this$props$to, + _this$props$config = _this$props.config, + config = _this$props$config === void 0 ? {} : _this$props$config, + reverse = _this$props.reverse, + attach = _this$props.attach, + reset = _this$props.reset, + immediate = _this$props.immediate; // Reverse values when requested + + if (reverse) { + var _ref6 = [to, from]; + from = _ref6[0]; + to = _ref6[1]; + } // This will collect all props that were ever set, reset merged props when necessary + + + this.merged = _extends({}, from, this.merged, to); + this.hasChanged = false; // Attachment handling, trailed springs can "attach" themselves to a previous spring + + var target = attach && attach(this); // Reduces input { name: value } pairs into animated values + + this.animations = Object.entries(this.merged).reduce(function (acc, _ref7) { + var name = _ref7[0], + value = _ref7[1]; + // Issue cached entries, except on reset + var entry = acc[name] || {}; // Figure out what the value is supposed to be + + var isNumber = is.num(value); + var isString = is.str(value) && !value.startsWith('#') && !/\d/.test(value) && !colorNames[value]; + var isArray = is.arr(value); + var isInterpolation = !isNumber && !isArray && !isString; + var fromValue = !is.und(from[name]) ? from[name] : value; + var toValue = isNumber || isArray ? value : isString ? value : 1; + var toConfig = callProp(config, name); + if (target) toValue = target.animations[name].parent; + var parent = entry.parent, + interpolation$$1 = entry.interpolation, + toValues = toArray(target ? toValue.getPayload() : toValue), + animatedValues; + var newValue = value; + if (isInterpolation) newValue = interpolation({ + range: [0, 1], + output: [value, value] + })(1); + var currentValue = interpolation$$1 && interpolation$$1.getValue(); // Change detection flags + + var isFirst = is.und(parent); + var isActive = !isFirst && entry.animatedValues.some(function (v) { + return !v.done; + }); + var currentValueDiffersFromGoal = !is.equ(newValue, currentValue); + var hasNewGoal = !is.equ(newValue, entry.previous); + var hasNewConfig = !is.equ(toConfig, entry.config); // Change animation props when props indicate a new goal (new value differs from previous one) + // and current values differ from it. Config changes trigger a new update as well (though probably shouldn't?) + + if (reset || hasNewGoal && currentValueDiffersFromGoal || hasNewConfig) { + var _extends2; + + // Convert regular values into animated values, ALWAYS re-use if possible + if (isNumber || isString) parent = interpolation$$1 = entry.parent || new AnimatedValue(fromValue);else if (isArray) parent = interpolation$$1 = entry.parent || new AnimatedValueArray(fromValue);else if (isInterpolation) { + var prev = entry.interpolation && entry.interpolation.calc(entry.parent.value); + prev = prev !== void 0 && !reset ? prev : fromValue; + + if (entry.parent) { + parent = entry.parent; + parent.setValue(0, false); + } else parent = new AnimatedValue(0); + + var range = { + output: [prev, value] + }; + + if (entry.interpolation) { + interpolation$$1 = entry.interpolation; + entry.interpolation.updateConfig(range); + } else interpolation$$1 = parent.interpolate(range); + } + toValues = toArray(target ? toValue.getPayload() : toValue); + animatedValues = toArray(parent.getPayload()); + if (reset && !isInterpolation) parent.setValue(fromValue, false); + _this4.hasChanged = true; // Reset animated values + + animatedValues.forEach(function (value) { + value.startPosition = value.value; + value.lastPosition = value.value; + value.lastVelocity = isActive ? value.lastVelocity : undefined; + value.lastTime = isActive ? value.lastTime : undefined; + value.startTime = now(); + value.done = false; + value.animatedStyles.clear(); + }); // Set immediate values + + if (callProp(immediate, name)) { + parent.setValue(isInterpolation ? toValue : value, false); + } + + return _extends({}, acc, (_extends2 = {}, _extends2[name] = _extends({}, entry, { + name: name, + parent: parent, + interpolation: interpolation$$1, + animatedValues: animatedValues, + toValues: toValues, + previous: newValue, + config: toConfig, + fromValues: toArray(parent.getValue()), + immediate: callProp(immediate, name), + initialVelocity: withDefault(toConfig.velocity, 0), + clamp: withDefault(toConfig.clamp, false), + precision: withDefault(toConfig.precision, 0.01), + tension: withDefault(toConfig.tension, 170), + friction: withDefault(toConfig.friction, 26), + mass: withDefault(toConfig.mass, 1), + duration: toConfig.duration, + easing: withDefault(toConfig.easing, function (t) { + return t; + }), + decay: toConfig.decay + }), _extends2)); + } else { + if (!currentValueDiffersFromGoal) { + var _extends3; + + // So ... the current target value (newValue) appears to be different from the previous value, + // which normally constitutes an update, but the actual value (currentValue) matches the target! + // In order to resolve this without causing an animation update we silently flag the animation as done, + // which it technically is. Interpolations also needs a config update with their target set to 1. + if (isInterpolation) { + parent.setValue(1, false); + interpolation$$1.updateConfig({ + output: [newValue, newValue] + }); + } + + parent.done = true; + _this4.hasChanged = true; + return _extends({}, acc, (_extends3 = {}, _extends3[name] = _extends({}, acc[name], { + previous: newValue + }), _extends3)); + } + + return acc; + } + }, this.animations); + + if (this.hasChanged) { + // Make animations available to frameloop + this.configs = Object.values(this.animations); + this.values = {}; + this.interpolations = {}; + + for (var key in this.animations) { + this.interpolations[key] = this.animations[key].interpolation; + this.values[key] = this.animations[key].interpolation.getValue(); + } + } + + return this; + }; + + _proto.destroy = function destroy() { + this.stop(); + this.props = {}; + this.merged = {}; + this.animations = {}; + this.interpolations = {}; + this.values = {}; + this.configs = []; + this.local = 0; + }; + + return Controller; +}(); + +/** API + * const props = useSprings(number, [{ ... }, { ... }, ...]) + * const [props, set] = useSprings(number, (i, controller) => ({ ... })) + */ + +var useSprings = function useSprings(length, props) { + var mounted = React.useRef(false); + var ctrl = React.useRef(); + var isFn = is.fun(props); // The controller maintains the animation values, starts and stops animations + + var _useMemo = React.useMemo(function () { + // Remove old controllers + if (ctrl.current) { + ctrl.current.map(function (c) { + return c.destroy(); + }); + ctrl.current = undefined; + } + + var ref; + return [new Array(length).fill().map(function (_, i) { + var ctrl = new Controller(); + var newProps = isFn ? callProp(props, i, ctrl) : props[i]; + if (i === 0) ref = newProps.ref; + ctrl.update(newProps); + if (!ref) ctrl.start(); + return ctrl; + }), ref]; + }, [length]), + controllers = _useMemo[0], + ref = _useMemo[1]; + + ctrl.current = controllers; // The hooks reference api gets defined here ... + + var api = React.useImperativeHandle(ref, function () { + return { + start: function start() { + return Promise.all(ctrl.current.map(function (c) { + return new Promise(function (r) { + return c.start(r); + }); + })); + }, + stop: function stop(finished) { + return ctrl.current.forEach(function (c) { + return c.stop(finished); + }); + }, + + get controllers() { + return ctrl.current; + } + + }; + }); // This function updates the controllers + + var updateCtrl = React.useMemo(function () { + return function (updateProps) { + return ctrl.current.map(function (c, i) { + c.update(isFn ? callProp(updateProps, i, c) : updateProps[i]); + if (!ref) c.start(); + }); + }; + }, [length]); // Update controller if props aren't functional + + React.useEffect(function () { + if (mounted.current) { + if (!isFn) updateCtrl(props); + } else if (!ref) ctrl.current.forEach(function (c) { + return c.start(); + }); + }); // Update mounted flag and destroy controller on unmount + + React.useEffect(function () { + return mounted.current = true, function () { + return ctrl.current.forEach(function (c) { + return c.destroy(); + }); + }; + }, []); // Return animated props, or, anim-props + the update-setter above + + var propValues = ctrl.current.map(function (c) { + return c.getValues(); + }); + return isFn ? [propValues, updateCtrl, function (finished) { + return ctrl.current.forEach(function (c) { + return c.pause(finished); + }); + }] : propValues; +}; + +/** API + * const props = useSpring({ ... }) + * const [props, set] = useSpring(() => ({ ... })) + */ + +var useSpring = function useSpring(props) { + var isFn = is.fun(props); + + var _useSprings = useSprings(1, isFn ? props : [props]), + result = _useSprings[0], + set = _useSprings[1], + pause = _useSprings[2]; + + return isFn ? [result[0], set, pause] : result; +}; + +/** API + * const trails = useTrail(number, { ... }) + * const [trails, set] = useTrail(number, () => ({ ... })) + */ + +var useTrail = function useTrail(length, props) { + var mounted = React.useRef(false); + var isFn = is.fun(props); + var updateProps = callProp(props); + var instances = React.useRef(); + + var _useSprings = useSprings(length, function (i, ctrl) { + if (i === 0) instances.current = []; + instances.current.push(ctrl); + return _extends({}, updateProps, { + config: callProp(updateProps.config, i), + attach: i > 0 && function () { + return instances.current[i - 1]; + } + }); + }), + result = _useSprings[0], + set = _useSprings[1], + pause = _useSprings[2]; // Set up function to update controller + + + var updateCtrl = React.useMemo(function () { + return function (props) { + return set(function (i, ctrl) { + var last = props.reverse ? i === 0 : length - 1 === i; + var attachIdx = props.reverse ? i + 1 : i - 1; + var attachController = instances.current[attachIdx]; + return _extends({}, props, { + config: callProp(props.config || updateProps.config, i), + attach: attachController && function () { + return attachController; + } + }); + }); + }; + }, [length, updateProps.reverse]); // Update controller if props aren't functional + + React.useEffect(function () { + return void (mounted.current && !isFn && updateCtrl(props)); + }); // Update mounted flag and destroy controller on unmount + + React.useEffect(function () { + return void (mounted.current = true); + }, []); + return isFn ? [result, updateCtrl, pause] : result; +}; + +/** API + * const transitions = useTransition(items, itemKeys, { ... }) + * const [transitions, update] = useTransition(items, itemKeys, () => ({ ... })) + */ + +var guid = 0; +var ENTER = 'enter'; +var LEAVE = 'leave'; +var UPDATE = 'update'; + +var mapKeys = function mapKeys(items, keys) { + return (typeof keys === 'function' ? items.map(keys) : toArray(keys)).map(String); +}; + +var get = function get(props) { + var items = props.items, + _props$keys = props.keys, + keys = _props$keys === void 0 ? function (item) { + return item; + } : _props$keys, + rest = _objectWithoutPropertiesLoose(props, ["items", "keys"]); + + items = toArray(items !== void 0 ? items : null); + return _extends({ + items: items, + keys: mapKeys(items, keys) + }, rest); +}; + +function useTransition(input, keyTransform, config) { + var props = _extends({ + items: input, + keys: keyTransform || function (i) { + return i; + } + }, config); + + var _get = get(props), + _get$lazy = _get.lazy, + lazy = _get$lazy === void 0 ? false : _get$lazy, + _get$unique = _get.unique, + _get$reset = _get.reset, + reset = _get$reset === void 0 ? false : _get$reset, + enter = _get.enter, + leave = _get.leave, + update = _get.update, + onDestroyed = _get.onDestroyed, + keys = _get.keys, + items = _get.items, + onFrame = _get.onFrame, + _onRest = _get.onRest, + onStart = _get.onStart, + ref = _get.ref, + extra = _objectWithoutPropertiesLoose(_get, ["lazy", "unique", "reset", "enter", "leave", "update", "onDestroyed", "keys", "items", "onFrame", "onRest", "onStart", "ref"]); + + var forceUpdate = useForceUpdate(); + var mounted = React.useRef(false); + var state = React.useRef({ + mounted: false, + first: true, + deleted: [], + current: {}, + transitions: [], + prevProps: {}, + paused: !!props.ref, + instances: !mounted.current && new Map(), + forceUpdate: forceUpdate + }); + React.useImperativeHandle(props.ref, function () { + return { + start: function start() { + return Promise.all(Array.from(state.current.instances).map(function (_ref) { + var c = _ref[1]; + return new Promise(function (r) { + return c.start(r); + }); + })); + }, + stop: function stop(finished) { + return Array.from(state.current.instances).forEach(function (_ref2) { + var c = _ref2[1]; + return c.stop(finished); + }); + }, + + get controllers() { + return Array.from(state.current.instances).map(function (_ref3) { + var c = _ref3[1]; + return c; + }); + } + + }; + }); // Update state + + state.current = diffItems(state.current, props); + + if (state.current.changed) { + // Update state + state.current.transitions.forEach(function (transition) { + var slot = transition.slot, + from = transition.from, + to = transition.to, + config = transition.config, + trail = transition.trail, + key = transition.key, + item = transition.item; + if (!state.current.instances.has(key)) state.current.instances.set(key, new Controller()); // update the map object + + var ctrl = state.current.instances.get(key); + + var newProps = _extends({}, extra, { + to: to, + from: from, + config: config, + ref: ref, + onRest: function onRest(values) { + if (state.current.mounted) { + if (transition.destroyed) { + // If no ref is given delete destroyed items immediately + if (!ref && !lazy) cleanUp(state, key); + if (onDestroyed) onDestroyed(item); + } // A transition comes to rest once all its springs conclude + + + var curInstances = Array.from(state.current.instances); + var active = curInstances.some(function (_ref4) { + var c = _ref4[1]; + return !c.idle; + }); + if (!active && (ref || lazy) && state.current.deleted.length > 0) cleanUp(state); + if (_onRest) _onRest(item, slot, values); + } + }, + onStart: onStart && function () { + return onStart(item, slot); + }, + onFrame: onFrame && function (values) { + return onFrame(item, slot, values); + }, + delay: trail, + reset: reset && slot === ENTER // Update controller + + }); + + ctrl.update(newProps); + if (!state.current.paused) ctrl.start(); + }); + } + + React.useEffect(function () { + state.current.mounted = mounted.current = true; + return function () { + state.current.mounted = mounted.current = false; + Array.from(state.current.instances).map(function (_ref5) { + var c = _ref5[1]; + return c.destroy(); + }); + state.current.instances.clear(); + }; + }, []); + return state.current.transitions.map(function (_ref6) { + var item = _ref6.item, + slot = _ref6.slot, + key = _ref6.key; + return { + item: item, + key: key, + state: slot, + props: state.current.instances.get(key).getValues() + }; + }); +} + +function cleanUp(state, filterKey) { + var deleted = state.current.deleted; + + var _loop = function _loop() { + if (_isArray) { + if (_i >= _iterator.length) return "break"; + _ref8 = _iterator[_i++]; + } else { + _i = _iterator.next(); + if (_i.done) return "break"; + _ref8 = _i.value; + } + + var _ref7 = _ref8; + var key = _ref7.key; + + var filter = function filter(t) { + return t.key !== key; + }; + + if (is.und(filterKey) || filterKey === key) { + state.current.instances.delete(key); + state.current.transitions = state.current.transitions.filter(filter); + state.current.deleted = state.current.deleted.filter(filter); + } + }; + + for (var _iterator = deleted, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) { + var _ref8; + + var _ret = _loop(); + + if (_ret === "break") break; + } + + state.current.forceUpdate(); +} + +function diffItems(_ref9, props) { + var first = _ref9.first, + prevProps = _ref9.prevProps, + state = _objectWithoutPropertiesLoose(_ref9, ["first", "prevProps"]); + + var _get2 = get(props), + items = _get2.items, + keys = _get2.keys, + initial = _get2.initial, + from = _get2.from, + enter = _get2.enter, + leave = _get2.leave, + update = _get2.update, + _get2$trail = _get2.trail, + trail = _get2$trail === void 0 ? 0 : _get2$trail, + unique = _get2.unique, + config = _get2.config, + _get2$order = _get2.order, + order = _get2$order === void 0 ? [ENTER, LEAVE, UPDATE] : _get2$order; + + var _get3 = get(prevProps), + _keys = _get3.keys, + _items = _get3.items; + + var current = _extends({}, state.current); + + var deleted = [].concat(state.deleted); // Compare next keys with current keys + + var currentKeys = Object.keys(current); + var currentSet = new Set(currentKeys); + var nextSet = new Set(keys); + var added = keys.filter(function (item) { + return !currentSet.has(item); + }); + var removed = state.transitions.filter(function (item) { + return !item.destroyed && !nextSet.has(item.originalKey); + }).map(function (i) { + return i.originalKey; + }); + var updated = keys.filter(function (item) { + return currentSet.has(item); + }); + var delay = -trail; + + while (order.length) { + var changeType = order.shift(); + + switch (changeType) { + case ENTER: + { + added.forEach(function (key, index) { + // In unique mode, remove fading out transitions if their key comes in again + if (unique && deleted.find(function (d) { + return d.originalKey === key; + })) deleted = deleted.filter(function (t) { + return t.originalKey !== key; + }); + var keyIndex = keys.indexOf(key); + var item = items[keyIndex]; + var slot = first && initial !== void 0 ? 'initial' : ENTER; + current[key] = { + slot: slot, + originalKey: key, + key: unique ? String(key) : guid++, + item: item, + trail: delay = delay + trail, + config: callProp(config, item, slot), + from: callProp(first ? initial !== void 0 ? initial || {} : from : from, item), + to: callProp(enter, item) + }; + }); + break; + } + + case LEAVE: + { + removed.forEach(function (key) { + var keyIndex = _keys.indexOf(key); + + var item = _items[keyIndex]; + var slot = LEAVE; + deleted.unshift(_extends({}, current[key], { + slot: slot, + destroyed: true, + left: _keys[Math.max(0, keyIndex - 1)], + right: _keys[Math.min(_keys.length, keyIndex + 1)], + trail: delay = delay + trail, + config: callProp(config, item, slot), + to: callProp(leave, item) + })); + delete current[key]; + }); + break; + } + + case UPDATE: + { + updated.forEach(function (key) { + var keyIndex = keys.indexOf(key); + var item = items[keyIndex]; + var slot = UPDATE; + current[key] = _extends({}, current[key], { + item: item, + slot: slot, + trail: delay = delay + trail, + config: callProp(config, item, slot), + to: callProp(update, item) + }); + }); + break; + } + } + } + + var out = keys.map(function (key) { + return current[key]; + }); // This tries to restore order for deleted items by finding their last known siblings + // only using the left sibling to keep order placement consistent for all deleted items + + deleted.forEach(function (_ref10) { + var left = _ref10.left, + right = _ref10.right, + item = _objectWithoutPropertiesLoose(_ref10, ["left", "right"]); + + var pos; // Was it the element on the left, if yes, move there ... + + if ((pos = out.findIndex(function (t) { + return t.originalKey === left; + })) !== -1) pos += 1; // And if nothing else helps, move it to the start ¯\_(ツ)_/¯ + + pos = Math.max(0, pos); + out = [].concat(out.slice(0, pos), [item], out.slice(pos)); + }); + return _extends({}, state, { + changed: added.length || removed.length || updated.length, + first: first && added.length === 0, + transitions: out, + current: current, + deleted: deleted, + prevProps: props + }); +} + +var AnimatedStyle = +/*#__PURE__*/ +function (_AnimatedObject) { + _inheritsLoose(AnimatedStyle, _AnimatedObject); + + function AnimatedStyle(style) { + var _this; + + if (style === void 0) { + style = {}; + } + + _this = _AnimatedObject.call(this) || this; + + if (style.transform && !(style.transform instanceof Animated)) { + style = applyAnimatedValues.transform(style); + } + + _this.payload = style; + return _this; + } + + return AnimatedStyle; +}(AnimatedObject); + +// http://www.w3.org/TR/css3-color/#svg-color +var colors = { + transparent: 0x00000000, + aliceblue: 0xf0f8ffff, + antiquewhite: 0xfaebd7ff, + aqua: 0x00ffffff, + aquamarine: 0x7fffd4ff, + azure: 0xf0ffffff, + beige: 0xf5f5dcff, + bisque: 0xffe4c4ff, + black: 0x000000ff, + blanchedalmond: 0xffebcdff, + blue: 0x0000ffff, + blueviolet: 0x8a2be2ff, + brown: 0xa52a2aff, + burlywood: 0xdeb887ff, + burntsienna: 0xea7e5dff, + cadetblue: 0x5f9ea0ff, + chartreuse: 0x7fff00ff, + chocolate: 0xd2691eff, + coral: 0xff7f50ff, + cornflowerblue: 0x6495edff, + cornsilk: 0xfff8dcff, + crimson: 0xdc143cff, + cyan: 0x00ffffff, + darkblue: 0x00008bff, + darkcyan: 0x008b8bff, + darkgoldenrod: 0xb8860bff, + darkgray: 0xa9a9a9ff, + darkgreen: 0x006400ff, + darkgrey: 0xa9a9a9ff, + darkkhaki: 0xbdb76bff, + darkmagenta: 0x8b008bff, + darkolivegreen: 0x556b2fff, + darkorange: 0xff8c00ff, + darkorchid: 0x9932ccff, + darkred: 0x8b0000ff, + darksalmon: 0xe9967aff, + darkseagreen: 0x8fbc8fff, + darkslateblue: 0x483d8bff, + darkslategray: 0x2f4f4fff, + darkslategrey: 0x2f4f4fff, + darkturquoise: 0x00ced1ff, + darkviolet: 0x9400d3ff, + deeppink: 0xff1493ff, + deepskyblue: 0x00bfffff, + dimgray: 0x696969ff, + dimgrey: 0x696969ff, + dodgerblue: 0x1e90ffff, + firebrick: 0xb22222ff, + floralwhite: 0xfffaf0ff, + forestgreen: 0x228b22ff, + fuchsia: 0xff00ffff, + gainsboro: 0xdcdcdcff, + ghostwhite: 0xf8f8ffff, + gold: 0xffd700ff, + goldenrod: 0xdaa520ff, + gray: 0x808080ff, + green: 0x008000ff, + greenyellow: 0xadff2fff, + grey: 0x808080ff, + honeydew: 0xf0fff0ff, + hotpink: 0xff69b4ff, + indianred: 0xcd5c5cff, + indigo: 0x4b0082ff, + ivory: 0xfffff0ff, + khaki: 0xf0e68cff, + lavender: 0xe6e6faff, + lavenderblush: 0xfff0f5ff, + lawngreen: 0x7cfc00ff, + lemonchiffon: 0xfffacdff, + lightblue: 0xadd8e6ff, + lightcoral: 0xf08080ff, + lightcyan: 0xe0ffffff, + lightgoldenrodyellow: 0xfafad2ff, + lightgray: 0xd3d3d3ff, + lightgreen: 0x90ee90ff, + lightgrey: 0xd3d3d3ff, + lightpink: 0xffb6c1ff, + lightsalmon: 0xffa07aff, + lightseagreen: 0x20b2aaff, + lightskyblue: 0x87cefaff, + lightslategray: 0x778899ff, + lightslategrey: 0x778899ff, + lightsteelblue: 0xb0c4deff, + lightyellow: 0xffffe0ff, + lime: 0x00ff00ff, + limegreen: 0x32cd32ff, + linen: 0xfaf0e6ff, + magenta: 0xff00ffff, + maroon: 0x800000ff, + mediumaquamarine: 0x66cdaaff, + mediumblue: 0x0000cdff, + mediumorchid: 0xba55d3ff, + mediumpurple: 0x9370dbff, + mediumseagreen: 0x3cb371ff, + mediumslateblue: 0x7b68eeff, + mediumspringgreen: 0x00fa9aff, + mediumturquoise: 0x48d1ccff, + mediumvioletred: 0xc71585ff, + midnightblue: 0x191970ff, + mintcream: 0xf5fffaff, + mistyrose: 0xffe4e1ff, + moccasin: 0xffe4b5ff, + navajowhite: 0xffdeadff, + navy: 0x000080ff, + oldlace: 0xfdf5e6ff, + olive: 0x808000ff, + olivedrab: 0x6b8e23ff, + orange: 0xffa500ff, + orangered: 0xff4500ff, + orchid: 0xda70d6ff, + palegoldenrod: 0xeee8aaff, + palegreen: 0x98fb98ff, + paleturquoise: 0xafeeeeff, + palevioletred: 0xdb7093ff, + papayawhip: 0xffefd5ff, + peachpuff: 0xffdab9ff, + peru: 0xcd853fff, + pink: 0xffc0cbff, + plum: 0xdda0ddff, + powderblue: 0xb0e0e6ff, + purple: 0x800080ff, + rebeccapurple: 0x663399ff, + red: 0xff0000ff, + rosybrown: 0xbc8f8fff, + royalblue: 0x4169e1ff, + saddlebrown: 0x8b4513ff, + salmon: 0xfa8072ff, + sandybrown: 0xf4a460ff, + seagreen: 0x2e8b57ff, + seashell: 0xfff5eeff, + sienna: 0xa0522dff, + silver: 0xc0c0c0ff, + skyblue: 0x87ceebff, + slateblue: 0x6a5acdff, + slategray: 0x708090ff, + slategrey: 0x708090ff, + snow: 0xfffafaff, + springgreen: 0x00ff7fff, + steelblue: 0x4682b4ff, + tan: 0xd2b48cff, + teal: 0x008080ff, + thistle: 0xd8bfd8ff, + tomato: 0xff6347ff, + turquoise: 0x40e0d0ff, + violet: 0xee82eeff, + wheat: 0xf5deb3ff, + white: 0xffffffff, + whitesmoke: 0xf5f5f5ff, + yellow: 0xffff00ff, + yellowgreen: 0x9acd32ff +}; + +// const INTEGER = '[-+]?\\d+'; +var NUMBER = '[-+]?\\d*\\.?\\d+'; +var PERCENTAGE = NUMBER + '%'; + +function call() { + for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) { + parts[_key] = arguments[_key]; + } + + return '\\(\\s*(' + parts.join(')\\s*,\\s*(') + ')\\s*\\)'; +} + +var rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER)); +var rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER)); +var hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE)); +var hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER)); +var hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/; +var hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/; +var hex6 = /^#([0-9a-fA-F]{6})$/; +var hex8 = /^#([0-9a-fA-F]{8})$/; + +/* +https://github.com/react-community/normalize-css-color + +BSD 3-Clause License + +Copyright (c) 2016, React Community +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +function normalizeColor(color) { + var match; + + if (typeof color === 'number') { + return color >>> 0 === color && color >= 0 && color <= 0xffffffff ? color : null; + } // Ordered based on occurrences on Facebook codebase + + + if (match = hex6.exec(color)) return parseInt(match[1] + 'ff', 16) >>> 0; + if (colors.hasOwnProperty(color)) return colors[color]; + + if (match = rgb.exec(color)) { + return (parse255(match[1]) << 24 | // r + parse255(match[2]) << 16 | // g + parse255(match[3]) << 8 | // b + 0x000000ff) >>> // a + 0; + } + + if (match = rgba.exec(color)) { + return (parse255(match[1]) << 24 | // r + parse255(match[2]) << 16 | // g + parse255(match[3]) << 8 | // b + parse1(match[4])) >>> // a + 0; + } + + if (match = hex3.exec(color)) { + return parseInt(match[1] + match[1] + // r + match[2] + match[2] + // g + match[3] + match[3] + // b + 'ff', // a + 16) >>> 0; + } // https://drafts.csswg.org/css-color-4/#hex-notation + + + if (match = hex8.exec(color)) return parseInt(match[1], 16) >>> 0; + + if (match = hex4.exec(color)) { + return parseInt(match[1] + match[1] + // r + match[2] + match[2] + // g + match[3] + match[3] + // b + match[4] + match[4], // a + 16) >>> 0; + } + + if (match = hsl.exec(color)) { + return (hslToRgb(parse360(match[1]), // h + parsePercentage(match[2]), // s + parsePercentage(match[3]) // l + ) | 0x000000ff) >>> // a + 0; + } + + if (match = hsla.exec(color)) { + return (hslToRgb(parse360(match[1]), // h + parsePercentage(match[2]), // s + parsePercentage(match[3]) // l + ) | parse1(match[4])) >>> // a + 0; + } + + return null; +} + +function hue2rgb(p, q, t) { + if (t < 0) t += 1; + if (t > 1) t -= 1; + if (t < 1 / 6) return p + (q - p) * 6 * t; + if (t < 1 / 2) return q; + if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6; + return p; +} + +function hslToRgb(h, s, l) { + var q = l < 0.5 ? l * (1 + s) : l + s - l * s; + var p = 2 * l - q; + var r = hue2rgb(p, q, h + 1 / 3); + var g = hue2rgb(p, q, h); + var b = hue2rgb(p, q, h - 1 / 3); + return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8; +} + +function parse255(str) { + var int = parseInt(str, 10); + if (int < 0) return 0; + if (int > 255) return 255; + return int; +} + +function parse360(str) { + var int = parseFloat(str); + return (int % 360 + 360) % 360 / 360; +} + +function parse1(str) { + var num = parseFloat(str); + if (num < 0) return 0; + if (num > 1) return 255; + return Math.round(num * 255); +} + +function parsePercentage(str) { + // parseFloat conveniently ignores the final % + var int = parseFloat(str); + if (int < 0) return 0; + if (int > 100) return 1; + return int / 100; +} + +function colorToRgba(input) { + var int32Color = normalizeColor(input); + if (int32Color === null) return input; + int32Color = int32Color || 0; + var r = (int32Color & 0xff000000) >>> 24; + var g = (int32Color & 0x00ff0000) >>> 16; + var b = (int32Color & 0x0000ff00) >>> 8; + var a = (int32Color & 0x000000ff) / 255; + return "rgba(" + r + ", " + g + ", " + b + ", " + a + ")"; +} // Problem: https://github.com/animatedjs/animated/pull/102 +// Solution: https://stackoverflow.com/questions/638565/parsing-scientific-notation-sensibly/658662 + + +var stringShapeRegex = /[+\-]?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/g; // Covers rgb, rgba, hsl, hsla +// Taken from https://gist.github.com/olmokramer/82ccce673f86db7cda5e + +var colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d\.]+%?\))/gi; // Covers color names (transparent, blue, etc.) + +var colorNamesRegex = new RegExp("(" + Object.keys(colors).join('|') + ")", 'g'); +/** + * Supports string shapes by extracting numbers so new values can be computed, + * and recombines those values into new strings of the same shape. Supports + * things like: + * + * rgba(123, 42, 99, 0.36) // colors + * -45deg // values with units + * 0 2px 2px 0px rgba(0, 0, 0, 0.12) // box shadows + */ + +var createStringInterpolator = function createStringInterpolator(config) { + // Replace colors with rgba + var outputRange = config.output.map(function (rangeValue) { + return rangeValue.replace(colorRegex, colorToRgba); + }).map(function (rangeValue) { + return rangeValue.replace(colorNamesRegex, colorToRgba); + }); + var outputRanges = outputRange[0].match(stringShapeRegex).map(function () { + return []; + }); + outputRange.forEach(function (value) { + value.match(stringShapeRegex).forEach(function (number, i) { + return outputRanges[i].push(+number); + }); + }); + var interpolations = outputRange[0].match(stringShapeRegex).map(function (_value, i) { + return createInterpolator(_extends({}, config, { + output: outputRanges[i] + })); + }); + return function (input) { + var i = 0; + return outputRange[0] // 'rgba(0, 100, 200, 0)' + // -> + // 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...' + .replace(stringShapeRegex, function () { + return interpolations[i++](input); + }) // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to + // round the opacity (4th column). + .replace(/rgba\(([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+), ([0-9\.-]+)\)/gi, function (_, p1, p2, p3, p4) { + return "rgba(" + Math.round(p1) + ", " + Math.round(p2) + ", " + Math.round(p3) + ", " + p4 + ")"; + }); + }; +}; + +var isUnitlessNumber = { + animationIterationCount: true, + borderImageOutset: true, + borderImageSlice: true, + borderImageWidth: true, + boxFlex: true, + boxFlexGroup: true, + boxOrdinalGroup: true, + columnCount: true, + columns: true, + flex: true, + flexGrow: true, + flexPositive: true, + flexShrink: true, + flexNegative: true, + flexOrder: true, + gridRow: true, + gridRowEnd: true, + gridRowSpan: true, + gridRowStart: true, + gridColumn: true, + gridColumnEnd: true, + gridColumnSpan: true, + gridColumnStart: true, + fontWeight: true, + lineClamp: true, + lineHeight: true, + opacity: true, + order: true, + orphans: true, + tabSize: true, + widows: true, + zIndex: true, + zoom: true, + // SVG-related properties + fillOpacity: true, + floodOpacity: true, + stopOpacity: true, + strokeDasharray: true, + strokeDashoffset: true, + strokeMiterlimit: true, + strokeOpacity: true, + strokeWidth: true +}; + +var prefixKey = function prefixKey(prefix, key) { + return prefix + key.charAt(0).toUpperCase() + key.substring(1); +}; + +var prefixes = ['Webkit', 'Ms', 'Moz', 'O']; +isUnitlessNumber = Object.keys(isUnitlessNumber).reduce(function (acc, prop) { + prefixes.forEach(function (prefix) { + return acc[prefixKey(prefix, prop)] = acc[prop]; + }); + return acc; +}, isUnitlessNumber); + +function dangerousStyleValue(name, value, isCustomProperty) { + if (value == null || typeof value === 'boolean' || value === '') return ''; + if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers + + return ('' + value).trim(); +} + +var attributeCache = {}; +injectCreateAnimatedStyle(function (style) { + return new AnimatedStyle(style); +}); +injectDefaultElement('div'); +injectStringInterpolator(createStringInterpolator); +injectColorNames(colors); +injectApplyAnimatedValues(function (instance, props) { + if (instance.nodeType && instance.setAttribute !== undefined) { + var style = props.style, + children = props.children, + scrollTop = props.scrollTop, + scrollLeft = props.scrollLeft, + attributes = _objectWithoutPropertiesLoose(props, ["style", "children", "scrollTop", "scrollLeft"]); + + var filter = instance.nodeName === 'filter' || instance.parentNode && instance.parentNode.nodeName === 'filter'; + if (scrollTop !== void 0) instance.scrollTop = scrollTop; + if (scrollLeft !== void 0) instance.scrollLeft = scrollLeft; // Set textContent, if children is an animatable value + + if (children !== void 0) instance.textContent = children; // Set styles ... + + for (var styleName in style) { + if (!style.hasOwnProperty(styleName)) continue; + var isCustomProperty = styleName.indexOf('--') === 0; + var styleValue = dangerousStyleValue(styleName, style[styleName], isCustomProperty); + if (styleName === 'float') styleName = 'cssFloat'; + if (isCustomProperty) instance.style.setProperty(styleName, styleValue);else instance.style[styleName] = styleValue; + } // Set attributes ... + + + for (var name in attributes) { + // Attributes are written in dash case + var dashCase = filter ? name : attributeCache[name] || (attributeCache[name] = name.replace(/([A-Z])/g, function (n) { + return '-' + n.toLowerCase(); + })); + if (typeof instance.getAttribute(dashCase) !== 'undefined') instance.setAttribute(dashCase, attributes[name]); + } + + return; + } else return false; +}, function (style) { + return style; +}); + +var domElements = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG +'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan']; +// Extend animated with all the available THREE elements +var apply = merge(createAnimatedComponent, false); +var extendedAnimated = apply(domElements); + +exports.apply = apply; +exports.config = config; +exports.update = update; +exports.animated = extendedAnimated; +exports.a = extendedAnimated; +exports.interpolate = interpolate$1; +exports.Globals = Globals; +exports.useSpring = useSpring; +exports.useTrail = useTrail; +exports.useTransition = useTransition; +exports.useChain = useChain; +exports.useSprings = useSprings; + + +/***/ }), + +/***/ 65: +/***/ (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; + + +/***/ }), + +/***/ 68: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +module.exports = __webpack_require__(113); + +/***/ }), + +/***/ 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__(10); + +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; +} + +/***/ }), + +/***/ 72: +/***/ (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; + + +/***/ }), + +/***/ 8: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["compose"]; }()); + +/***/ }), + +/***/ 82: +/***/ (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__(123); +var util = __webpack_require__(125); + +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__(126); + +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; +}; + + +/***/ }), + +/***/ 87: +/***/ (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__(88); + +function emptyFunction() {} +function emptyFunctionWithReset() {} +emptyFunctionWithReset.resetWarningCache = 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, + elementType: shim, + instanceOf: getShim, + node: shim, + objectOf: getShim, + oneOf: getShim, + oneOfType: getShim, + shape: getShim, + exact: getShim, + + checkPropTypes: emptyFunctionWithReset, + resetWarningCache: emptyFunction + }; + + ReactPropTypes.PropTypes = ReactPropTypes; + + return ReactPropTypes; +}; + + +/***/ }), + +/***/ 88: +/***/ (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; + + +/***/ }), + +/***/ 9: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["blocks"]; }()); + +/***/ }), + +/***/ 97: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["wordcount"]; }()); + +/***/ }) + +/******/ });
\ No newline at end of file |