From 7086111ad4dd997e12a3220e1ee60c9b9bcf0bb8 Mon Sep 17 00:00:00 2001 From: Charles Date: Tue, 7 Jan 2020 13:06:14 +0100 Subject: Added wordpress --- .../wordpress/wp-includes/js/dist/block-library.js | 22784 +++++++++++++++++++ 1 file changed, 22784 insertions(+) create mode 100644 srcs/wordpress/wp-includes/js/dist/block-library.js (limited to 'srcs/wordpress/wp-includes/js/dist/block-library.js') diff --git a/srcs/wordpress/wp-includes/js/dist/block-library.js b/srcs/wordpress/wp-includes/js/dist/block-library.js new file mode 100644 index 0000000..b7e22fa --- /dev/null +++ b/srcs/wordpress/wp-includes/js/dist/block-library.js @@ -0,0 +1,22784 @@ +this["wp"] = this["wp"] || {}; this["wp"]["blockLibrary"] = +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 341); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ 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; +} + +/***/ }), + +/***/ 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"); + } +} + +/***/ }), + +/***/ 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 + * @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 state to , + // but guard against overflow + handledCPCountPlusOne = handledCPCount + 1; + if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) { + error('overflow'); + } + + delta += (m - n) * handledCPCountPlusOne; + n = m; + + for (j = 0; j < inputLength; ++j) { + currentValue = input[j]; + + if (currentValue < n && ++delta > maxInt) { + error('overflow'); + } + + if (currentValue == n) { + // Represent delta as a generalized variable-length integer + for (q = delta, k = base; /* no condition */; k += base) { + t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias); + if (q < t) { + break; + } + qMinusT = q - t; + baseMinusT = base - t; + output.push( + stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0)) + ); + q = floor(qMinusT / baseMinusT); + } + + output.push(stringFromCharCode(digitToBasic(q, 0))); + bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength); + delta = 0; + ++handledCPCount; + } + } + + ++delta; + ++n; + + } + return output.join(''); + } + + /** + * Converts a Punycode string representing a domain name or an email address + * to Unicode. Only the Punycoded parts of the input will be converted, i.e. + * it doesn't matter if you call it on a string that has already been + * converted to Unicode. + * @memberOf punycode + * @param {String} input The Punycoded domain name or email address to + * convert to Unicode. + * @returns {String} The Unicode representation of the given Punycode + * string. + */ + function toUnicode(input) { + return mapDomain(input, function(string) { + return regexPunycode.test(string) + ? decode(string.slice(4).toLowerCase()) + : string; + }); + } + + /** + * Converts a Unicode string representing a domain name or an email address to + * Punycode. Only the non-ASCII parts of the domain name will be converted, + * i.e. it doesn't matter if you call it with a domain that's already in + * ASCII. + * @memberOf punycode + * @param {String} input The domain name or email address to convert, as a + * Unicode string. + * @returns {String} The Punycode representation of the given domain name or + * email address. + */ + function toASCII(input) { + return mapDomain(input, function(string) { + return regexNonASCII.test(string) + ? 'xn--' + encode(string) + : string; + }); + } + + /*--------------------------------------------------------------------------*/ + + /** Define the public API */ + punycode = { + /** + * A string representing the current Punycode.js version number. + * @memberOf punycode + * @type String + */ + 'version': '1.3.2', + /** + * An object of methods to convert from JavaScript's internal character + * representation (UCS-2) to Unicode code points, and back. + * @see + * @memberOf punycode + * @type Object + */ + 'ucs2': { + 'decode': ucs2decode, + 'encode': ucs2encode + }, + 'decode': decode, + 'encode': encode, + 'toASCII': toASCII, + 'toUnicode': toUnicode + }; + + /** Expose `punycode` */ + // Some AMD build optimizers, like r.js, check for specific condition patterns + // like the following: + if ( + true + ) { + !(__WEBPACK_AMD_DEFINE_RESULT__ = (function() { + return punycode; + }).call(exports, __webpack_require__, exports, module), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); + } else {} + +}(this)); + +/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(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); +} + +/***/ }), + +/***/ 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"]; }()); + +/***/ }), + +/***/ 21: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} +// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _objectWithoutProperties; }); + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + var target = _objectWithoutPropertiesLoose(source, excluded); + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +/***/ }), + +/***/ 22: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["richText"]; }()); + +/***/ }), + +/***/ 221: +/***/ (function(module, exports, __webpack_require__) { + +/*! Fast Average Color | © 2019 Denis Seleznev | MIT License | https://github.com/hcodes/fast-average-color/ */ +(function (global, factory) { + true ? module.exports = factory() : + undefined; +}(this, (function () { 'use strict'; + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +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; +} + +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); +} + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +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; +} + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); +} + +var FastAverageColor = +/*#__PURE__*/ +function () { + function FastAverageColor() { + _classCallCheck(this, FastAverageColor); + } + + _createClass(FastAverageColor, [{ + key: "getColorAsync", + + /** + * Get asynchronously the average color from not loaded image. + * + * @param {HTMLImageElement} resource + * @param {Function} callback + * @param {Object|null} [options] + * @param {Array} [options.defaultColor=[255, 255, 255, 255]] + * @param {*} [options.data] + * @param {string} [options.mode="speed"] "precision" or "speed" + * @param {string} [options.algorithm="sqrt"] "simple", "sqrt" or "dominant" + * @param {number} [options.step=1] + * @param {number} [options.left=0] + * @param {number} [options.top=0] + * @param {number} [options.width=width of resource] + * @param {number} [options.height=height of resource] + */ + value: function getColorAsync(resource, callback, options) { + if (resource.complete) { + callback.call(resource, this.getColor(resource, options), options && options.data); + } else { + this._bindImageEvents(resource, callback, options); + } + } + /** + * Get the average color from images, videos and canvas. + * + * @param {HTMLImageElement|HTMLVideoElement|HTMLCanvasElement} resource + * @param {Object|null} [options] + * @param {Array} [options.defaultColor=[255, 255, 255, 255]] + * @param {*} [options.data] + * @param {string} [options.mode="speed"] "precision" or "speed" + * @param {string} [options.algorithm="sqrt"] "simple", "sqrt" or "dominant" + * @param {number} [options.step=1] + * @param {number} [options.left=0] + * @param {number} [options.top=0] + * @param {number} [options.width=width of resource] + * @param {number} [options.height=height of resource] + * + * @returns {Object} + */ + + }, { + key: "getColor", + value: function getColor(resource, options) { + options = options || {}; + + var defaultColor = this._getDefaultColor(options), + originalSize = this._getOriginalSize(resource), + size = this._prepareSizeAndPosition(originalSize, options); + + var error = null, + value = defaultColor; + + if (!size.srcWidth || !size.srcHeight || !size.destWidth || !size.destHeight) { + return this._prepareResult(defaultColor, new Error('FastAverageColor: Incorrect sizes.')); + } + + if (!this._ctx) { + this._canvas = this._makeCanvas(); + this._ctx = this._canvas.getContext && this._canvas.getContext('2d'); + + if (!this._ctx) { + return this._prepareResult(defaultColor, new Error('FastAverageColor: Canvas Context 2D is not supported in this browser.')); + } + } + + this._canvas.width = size.destWidth; + this._canvas.height = size.destHeight; + + try { + this._ctx.clearRect(0, 0, size.destWidth, size.destHeight); + + this._ctx.drawImage(resource, size.srcLeft, size.srcTop, size.srcWidth, size.srcHeight, 0, 0, size.destWidth, size.destHeight); + + var bitmapData = this._ctx.getImageData(0, 0, size.destWidth, size.destHeight).data; + + value = this.getColorFromArray4(bitmapData, options); + } catch (e) { + // Security error, CORS + // https://developer.mozilla.org/en/docs/Web/HTML/CORS_enabled_image + error = e; + } + + return this._prepareResult(value, error); + } + /** + * Get the average color from a array when 1 pixel is 4 bytes. + * + * @param {Array|Uint8Array} arr + * @param {Object} [options] + * @param {string} [options.algorithm="sqrt"] "simple", "sqrt" or "dominant" + * @param {Array} [options.defaultColor=[255, 255, 255, 255]] + * @param {number} [options.step=1] + * + * @returns {Array} [red (0-255), green (0-255), blue (0-255), alpha (0-255)] + */ + + }, { + key: "getColorFromArray4", + value: function getColorFromArray4(arr, options) { + options = options || {}; + var bytesPerPixel = 4, + arrLength = arr.length; + + if (arrLength < bytesPerPixel) { + return this._getDefaultColor(options); + } + + var len = arrLength - arrLength % bytesPerPixel, + preparedStep = (options.step || 1) * bytesPerPixel, + algorithm = '_' + (options.algorithm || 'sqrt') + 'Algorithm'; + + if (typeof this[algorithm] !== 'function') { + throw new Error("FastAverageColor: ".concat(options.algorithm, " is unknown algorithm.")); + } + + return this[algorithm](arr, len, preparedStep); + } + /** + * Destroy the instance. + */ + + }, { + key: "destroy", + value: function destroy() { + delete this._canvas; + delete this._ctx; + } + }, { + key: "_getDefaultColor", + value: function _getDefaultColor(options) { + return this._getOption(options, 'defaultColor', [255, 255, 255, 255]); + } + }, { + key: "_getOption", + value: function _getOption(options, name, defaultValue) { + return typeof options[name] === 'undefined' ? defaultValue : options[name]; + } + }, { + key: "_prepareSizeAndPosition", + value: function _prepareSizeAndPosition(originalSize, options) { + var srcLeft = this._getOption(options, 'left', 0), + srcTop = this._getOption(options, 'top', 0), + srcWidth = this._getOption(options, 'width', originalSize.width), + srcHeight = this._getOption(options, 'height', originalSize.height), + destWidth = srcWidth, + destHeight = srcHeight; + + if (options.mode === 'precision') { + return { + srcLeft: srcLeft, + srcTop: srcTop, + srcWidth: srcWidth, + srcHeight: srcHeight, + destWidth: destWidth, + destHeight: destHeight + }; + } + + var maxSize = 100, + minSize = 10; + var factor; + + if (srcWidth > srcHeight) { + factor = srcWidth / srcHeight; + destWidth = maxSize; + destHeight = Math.round(destWidth / factor); + } else { + factor = srcHeight / srcWidth; + destHeight = maxSize; + destWidth = Math.round(destHeight / factor); + } + + if (destWidth > srcWidth || destHeight > srcHeight || destWidth < minSize || destHeight < minSize) { + destWidth = srcWidth; + destHeight = srcHeight; + } + + return { + srcLeft: srcLeft, + srcTop: srcTop, + srcWidth: srcWidth, + srcHeight: srcHeight, + destWidth: destWidth, + destHeight: destHeight + }; + } + }, { + key: "_simpleAlgorithm", + value: function _simpleAlgorithm(arr, len, preparedStep) { + var redTotal = 0, + greenTotal = 0, + blueTotal = 0, + alphaTotal = 0, + count = 0; + + for (var i = 0; i < len; i += preparedStep) { + var alpha = arr[i + 3], + red = arr[i] * alpha, + green = arr[i + 1] * alpha, + blue = arr[i + 2] * alpha; + redTotal += red; + greenTotal += green; + blueTotal += blue; + alphaTotal += alpha; + count++; + } + + return alphaTotal ? [Math.round(redTotal / alphaTotal), Math.round(greenTotal / alphaTotal), Math.round(blueTotal / alphaTotal), Math.round(alphaTotal / count)] : [0, 0, 0, 0]; + } + }, { + key: "_sqrtAlgorithm", + value: function _sqrtAlgorithm(arr, len, preparedStep) { + var redTotal = 0, + greenTotal = 0, + blueTotal = 0, + alphaTotal = 0, + count = 0; + + for (var i = 0; i < len; i += preparedStep) { + var red = arr[i], + green = arr[i + 1], + blue = arr[i + 2], + alpha = arr[i + 3]; + redTotal += red * red * alpha; + greenTotal += green * green * alpha; + blueTotal += blue * blue * alpha; + alphaTotal += alpha; + count++; + } + + return alphaTotal ? [Math.round(Math.sqrt(redTotal / alphaTotal)), Math.round(Math.sqrt(greenTotal / alphaTotal)), Math.round(Math.sqrt(blueTotal / alphaTotal)), Math.round(alphaTotal / count)] : [0, 0, 0, 0]; + } + }, { + key: "_dominantAlgorithm", + value: function _dominantAlgorithm(arr, len, preparedStep) { + var colorHash = {}, + divider = 24; + + for (var i = 0; i < len; i += preparedStep) { + var red = arr[i], + green = arr[i + 1], + blue = arr[i + 2], + alpha = arr[i + 3], + key = Math.round(red / divider) + ',' + Math.round(green / divider) + ',' + Math.round(blue / divider); + + if (colorHash[key]) { + colorHash[key] = [colorHash[key][0] + red * alpha, colorHash[key][1] + green * alpha, colorHash[key][2] + blue * alpha, colorHash[key][3] + alpha, colorHash[key][4] + 1]; + } else { + colorHash[key] = [red * alpha, green * alpha, blue * alpha, alpha, 1]; + } + } + + var buffer = Object.keys(colorHash).map(function (key) { + return colorHash[key]; + }).sort(function (a, b) { + var countA = a[4], + countB = b[4]; + return countA > countB ? -1 : countA === countB ? 0 : 1; + }); + + var _buffer$ = _slicedToArray(buffer[0], 5), + redTotal = _buffer$[0], + greenTotal = _buffer$[1], + blueTotal = _buffer$[2], + alphaTotal = _buffer$[3], + count = _buffer$[4]; + + return alphaTotal ? [Math.round(redTotal / alphaTotal), Math.round(greenTotal / alphaTotal), Math.round(blueTotal / alphaTotal), Math.round(alphaTotal / count)] : [0, 0, 0, 0]; + } + }, { + key: "_bindImageEvents", + value: function _bindImageEvents(resource, callback, options) { + var _this = this; + + options = options || {}; + + var data = options && options.data, + defaultColor = this._getDefaultColor(options), + onload = function onload() { + unbindEvents(); + callback.call(resource, _this.getColor(resource, options), data); + }, + onerror = function onerror() { + unbindEvents(); + callback.call(resource, _this._prepareResult(defaultColor, new Error('Image error')), data); + }, + onabort = function onabort() { + unbindEvents(); + callback.call(resource, _this._prepareResult(defaultColor, new Error('Image abort')), data); + }, + unbindEvents = function unbindEvents() { + resource.removeEventListener('load', onload); + resource.removeEventListener('error', onerror); + resource.removeEventListener('abort', onabort); + }; + + resource.addEventListener('load', onload); + resource.addEventListener('error', onerror); + resource.addEventListener('abort', onabort); + } + }, { + key: "_prepareResult", + value: function _prepareResult(value, error) { + var rgb = value.slice(0, 3), + rgba = [].concat(rgb, value[3] / 255), + isDark = this._isDark(value); + + return { + error: error, + value: value, + rgb: 'rgb(' + rgb.join(',') + ')', + rgba: 'rgba(' + rgba.join(',') + ')', + hex: this._arrayToHex(rgb), + hexa: this._arrayToHex(value), + isDark: isDark, + isLight: !isDark + }; + } + }, { + key: "_getOriginalSize", + value: function _getOriginalSize(resource) { + if (resource instanceof HTMLImageElement) { + return { + width: resource.naturalWidth, + height: resource.naturalHeight + }; + } + + if (resource instanceof HTMLVideoElement) { + return { + width: resource.videoWidth, + height: resource.videoHeight + }; + } + + return { + width: resource.width, + height: resource.height + }; + } + }, { + key: "_toHex", + value: function _toHex(num) { + var str = num.toString(16); + return str.length === 1 ? '0' + str : str; + } + }, { + key: "_arrayToHex", + value: function _arrayToHex(arr) { + return '#' + arr.map(this._toHex).join(''); + } + }, { + key: "_isDark", + value: function _isDark(color) { + // http://www.w3.org/TR/AERT#color-contrast + var result = (color[0] * 299 + color[1] * 587 + color[2] * 114) / 1000; + return result < 128; + } + }, { + key: "_makeCanvas", + value: function _makeCanvas() { + return typeof window === 'undefined' ? new OffscreenCanvas(1, 1) : document.createElement('canvas'); + } + }]); + + return FastAverageColor; +}(); + +return FastAverageColor; + +}))); + + +/***/ }), + +/***/ 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 */])(); +} + +/***/ }), + +/***/ 24: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["editor"]; }()); + +/***/ }), + +/***/ 26: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["url"]; }()); + +/***/ }), + +/***/ 29: +/***/ (function(module, exports) { + +(function() { module.exports = this["moment"]; }()); + +/***/ }), + +/***/ 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); +} + +/***/ }), + +/***/ 34: +/***/ (function(module, exports) { + +(function() { module.exports = this["wp"]["apiFetch"]; }()); + +/***/ }), + +/***/ 341: +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +var paragraph_namespaceObject = {}; +__webpack_require__.r(paragraph_namespaceObject); +__webpack_require__.d(paragraph_namespaceObject, "metadata", function() { return paragraph_metadata; }); +__webpack_require__.d(paragraph_namespaceObject, "name", function() { return paragraph_name; }); +__webpack_require__.d(paragraph_namespaceObject, "settings", function() { return paragraph_settings; }); +var image_namespaceObject = {}; +__webpack_require__.r(image_namespaceObject); +__webpack_require__.d(image_namespaceObject, "metadata", function() { return image_metadata; }); +__webpack_require__.d(image_namespaceObject, "name", function() { return image_name; }); +__webpack_require__.d(image_namespaceObject, "settings", function() { return image_settings; }); +var heading_namespaceObject = {}; +__webpack_require__.r(heading_namespaceObject); +__webpack_require__.d(heading_namespaceObject, "metadata", function() { return heading_metadata; }); +__webpack_require__.d(heading_namespaceObject, "name", function() { return heading_name; }); +__webpack_require__.d(heading_namespaceObject, "settings", function() { return heading_settings; }); +var quote_namespaceObject = {}; +__webpack_require__.r(quote_namespaceObject); +__webpack_require__.d(quote_namespaceObject, "metadata", function() { return quote_metadata; }); +__webpack_require__.d(quote_namespaceObject, "name", function() { return quote_name; }); +__webpack_require__.d(quote_namespaceObject, "settings", function() { return quote_settings; }); +var gallery_namespaceObject = {}; +__webpack_require__.r(gallery_namespaceObject); +__webpack_require__.d(gallery_namespaceObject, "metadata", function() { return gallery_metadata; }); +__webpack_require__.d(gallery_namespaceObject, "name", function() { return gallery_name; }); +__webpack_require__.d(gallery_namespaceObject, "settings", function() { return gallery_settings; }); +var archives_namespaceObject = {}; +__webpack_require__.r(archives_namespaceObject); +__webpack_require__.d(archives_namespaceObject, "name", function() { return archives_name; }); +__webpack_require__.d(archives_namespaceObject, "settings", function() { return archives_settings; }); +var audio_namespaceObject = {}; +__webpack_require__.r(audio_namespaceObject); +__webpack_require__.d(audio_namespaceObject, "metadata", function() { return audio_metadata; }); +__webpack_require__.d(audio_namespaceObject, "name", function() { return audio_name; }); +__webpack_require__.d(audio_namespaceObject, "settings", function() { return audio_settings; }); +var button_namespaceObject = {}; +__webpack_require__.r(button_namespaceObject); +__webpack_require__.d(button_namespaceObject, "metadata", function() { return button_metadata; }); +__webpack_require__.d(button_namespaceObject, "name", function() { return button_name; }); +__webpack_require__.d(button_namespaceObject, "settings", function() { return button_settings; }); +var calendar_namespaceObject = {}; +__webpack_require__.r(calendar_namespaceObject); +__webpack_require__.d(calendar_namespaceObject, "name", function() { return calendar_name; }); +__webpack_require__.d(calendar_namespaceObject, "settings", function() { return calendar_settings; }); +var categories_namespaceObject = {}; +__webpack_require__.r(categories_namespaceObject); +__webpack_require__.d(categories_namespaceObject, "name", function() { return categories_name; }); +__webpack_require__.d(categories_namespaceObject, "settings", function() { return categories_settings; }); +var code_namespaceObject = {}; +__webpack_require__.r(code_namespaceObject); +__webpack_require__.d(code_namespaceObject, "metadata", function() { return code_metadata; }); +__webpack_require__.d(code_namespaceObject, "name", function() { return code_name; }); +__webpack_require__.d(code_namespaceObject, "settings", function() { return code_settings; }); +var columns_namespaceObject = {}; +__webpack_require__.r(columns_namespaceObject); +__webpack_require__.d(columns_namespaceObject, "metadata", function() { return columns_metadata; }); +__webpack_require__.d(columns_namespaceObject, "name", function() { return columns_name; }); +__webpack_require__.d(columns_namespaceObject, "settings", function() { return columns_settings; }); +var column_namespaceObject = {}; +__webpack_require__.r(column_namespaceObject); +__webpack_require__.d(column_namespaceObject, "metadata", function() { return column_metadata; }); +__webpack_require__.d(column_namespaceObject, "name", function() { return column_name; }); +__webpack_require__.d(column_namespaceObject, "settings", function() { return column_settings; }); +var cover_namespaceObject = {}; +__webpack_require__.r(cover_namespaceObject); +__webpack_require__.d(cover_namespaceObject, "metadata", function() { return cover_metadata; }); +__webpack_require__.d(cover_namespaceObject, "name", function() { return cover_name; }); +__webpack_require__.d(cover_namespaceObject, "settings", function() { return cover_settings; }); +var embed_namespaceObject = {}; +__webpack_require__.r(embed_namespaceObject); +__webpack_require__.d(embed_namespaceObject, "name", function() { return embed_name; }); +__webpack_require__.d(embed_namespaceObject, "settings", function() { return embed_settings; }); +__webpack_require__.d(embed_namespaceObject, "common", function() { return embed_common; }); +__webpack_require__.d(embed_namespaceObject, "others", function() { return embed_others; }); +var file_namespaceObject = {}; +__webpack_require__.r(file_namespaceObject); +__webpack_require__.d(file_namespaceObject, "metadata", function() { return file_metadata; }); +__webpack_require__.d(file_namespaceObject, "name", function() { return file_name; }); +__webpack_require__.d(file_namespaceObject, "settings", function() { return file_settings; }); +var html_namespaceObject = {}; +__webpack_require__.r(html_namespaceObject); +__webpack_require__.d(html_namespaceObject, "metadata", function() { return html_metadata; }); +__webpack_require__.d(html_namespaceObject, "name", function() { return html_name; }); +__webpack_require__.d(html_namespaceObject, "settings", function() { return html_settings; }); +var media_text_namespaceObject = {}; +__webpack_require__.r(media_text_namespaceObject); +__webpack_require__.d(media_text_namespaceObject, "metadata", function() { return media_text_metadata; }); +__webpack_require__.d(media_text_namespaceObject, "name", function() { return media_text_name; }); +__webpack_require__.d(media_text_namespaceObject, "settings", function() { return media_text_settings; }); +var latest_comments_namespaceObject = {}; +__webpack_require__.r(latest_comments_namespaceObject); +__webpack_require__.d(latest_comments_namespaceObject, "name", function() { return latest_comments_name; }); +__webpack_require__.d(latest_comments_namespaceObject, "settings", function() { return latest_comments_settings; }); +var latest_posts_namespaceObject = {}; +__webpack_require__.r(latest_posts_namespaceObject); +__webpack_require__.d(latest_posts_namespaceObject, "name", function() { return latest_posts_name; }); +__webpack_require__.d(latest_posts_namespaceObject, "settings", function() { return latest_posts_settings; }); +var list_namespaceObject = {}; +__webpack_require__.r(list_namespaceObject); +__webpack_require__.d(list_namespaceObject, "metadata", function() { return list_metadata; }); +__webpack_require__.d(list_namespaceObject, "name", function() { return list_name; }); +__webpack_require__.d(list_namespaceObject, "settings", function() { return list_settings; }); +var missing_namespaceObject = {}; +__webpack_require__.r(missing_namespaceObject); +__webpack_require__.d(missing_namespaceObject, "metadata", function() { return missing_metadata; }); +__webpack_require__.d(missing_namespaceObject, "name", function() { return missing_name; }); +__webpack_require__.d(missing_namespaceObject, "settings", function() { return missing_settings; }); +var more_namespaceObject = {}; +__webpack_require__.r(more_namespaceObject); +__webpack_require__.d(more_namespaceObject, "metadata", function() { return more_metadata; }); +__webpack_require__.d(more_namespaceObject, "name", function() { return more_name; }); +__webpack_require__.d(more_namespaceObject, "settings", function() { return more_settings; }); +var nextpage_namespaceObject = {}; +__webpack_require__.r(nextpage_namespaceObject); +__webpack_require__.d(nextpage_namespaceObject, "metadata", function() { return nextpage_metadata; }); +__webpack_require__.d(nextpage_namespaceObject, "name", function() { return nextpage_name; }); +__webpack_require__.d(nextpage_namespaceObject, "settings", function() { return nextpage_settings; }); +var preformatted_namespaceObject = {}; +__webpack_require__.r(preformatted_namespaceObject); +__webpack_require__.d(preformatted_namespaceObject, "metadata", function() { return preformatted_metadata; }); +__webpack_require__.d(preformatted_namespaceObject, "name", function() { return preformatted_name; }); +__webpack_require__.d(preformatted_namespaceObject, "settings", function() { return preformatted_settings; }); +var pullquote_namespaceObject = {}; +__webpack_require__.r(pullquote_namespaceObject); +__webpack_require__.d(pullquote_namespaceObject, "metadata", function() { return pullquote_metadata; }); +__webpack_require__.d(pullquote_namespaceObject, "name", function() { return pullquote_name; }); +__webpack_require__.d(pullquote_namespaceObject, "settings", function() { return pullquote_settings; }); +var block_namespaceObject = {}; +__webpack_require__.r(block_namespaceObject); +__webpack_require__.d(block_namespaceObject, "name", function() { return block_name; }); +__webpack_require__.d(block_namespaceObject, "settings", function() { return block_settings; }); +var rss_namespaceObject = {}; +__webpack_require__.r(rss_namespaceObject); +__webpack_require__.d(rss_namespaceObject, "name", function() { return rss_name; }); +__webpack_require__.d(rss_namespaceObject, "settings", function() { return rss_settings; }); +var search_namespaceObject = {}; +__webpack_require__.r(search_namespaceObject); +__webpack_require__.d(search_namespaceObject, "name", function() { return search_name; }); +__webpack_require__.d(search_namespaceObject, "settings", function() { return search_settings; }); +var group_namespaceObject = {}; +__webpack_require__.r(group_namespaceObject); +__webpack_require__.d(group_namespaceObject, "metadata", function() { return group_metadata; }); +__webpack_require__.d(group_namespaceObject, "name", function() { return group_name; }); +__webpack_require__.d(group_namespaceObject, "settings", function() { return group_settings; }); +var separator_namespaceObject = {}; +__webpack_require__.r(separator_namespaceObject); +__webpack_require__.d(separator_namespaceObject, "metadata", function() { return separator_metadata; }); +__webpack_require__.d(separator_namespaceObject, "name", function() { return separator_name; }); +__webpack_require__.d(separator_namespaceObject, "settings", function() { return separator_settings; }); +var shortcode_namespaceObject = {}; +__webpack_require__.r(shortcode_namespaceObject); +__webpack_require__.d(shortcode_namespaceObject, "name", function() { return shortcode_name; }); +__webpack_require__.d(shortcode_namespaceObject, "settings", function() { return shortcode_settings; }); +var spacer_namespaceObject = {}; +__webpack_require__.r(spacer_namespaceObject); +__webpack_require__.d(spacer_namespaceObject, "metadata", function() { return spacer_metadata; }); +__webpack_require__.d(spacer_namespaceObject, "name", function() {