[Summary view] [Print] [Text view]

   1  /******/ (() => { // webpackBootstrap
   2  /******/     "use strict";
   3  /******/     // The require scope
   4  /******/     var __webpack_require__ = {};
   5  /******/     
   6  /************************************************************************/
   7  /******/     /* webpack/runtime/compat get default export */
   8  /******/     (() => {
   9  /******/         // getDefaultExport function for compatibility with non-harmony modules
  10  /******/         __webpack_require__.n = (module) => {
  11  /******/             var getter = module && module.__esModule ?
  12  /******/                 () => (module['default']) :
  13  /******/                 () => (module);
  14  /******/             __webpack_require__.d(getter, { a: getter });
  15  /******/             return getter;
  16  /******/         };
  17  /******/     })();
  18  /******/     
  19  /******/     /* webpack/runtime/define property getters */
  20  /******/     (() => {
  21  /******/         // define getter functions for harmony exports
  22  /******/         __webpack_require__.d = (exports, definition) => {
  23  /******/             for(var key in definition) {
  24  /******/                 if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
  25  /******/                     Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
  26  /******/                 }
  27  /******/             }
  28  /******/         };
  29  /******/     })();
  30  /******/     
  31  /******/     /* webpack/runtime/hasOwnProperty shorthand */
  32  /******/     (() => {
  33  /******/         __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
  34  /******/     })();
  35  /******/     
  36  /************************************************************************/
  37  var __webpack_exports__ = {};
  38  
  39  ;// external ["wp","element"]
  40  const external_wp_element_namespaceObject = window["wp"]["element"];
  41  ;// external ["wp","i18n"]
  42  const external_wp_i18n_namespaceObject = window["wp"]["i18n"];
  43  ;// ./node_modules/tslib/tslib.es6.mjs
  44  /******************************************************************************
  45  Copyright (c) Microsoft Corporation.
  46  
  47  Permission to use, copy, modify, and/or distribute this software for any
  48  purpose with or without fee is hereby granted.
  49  
  50  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
  51  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  52  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
  53  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  54  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  55  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  56  PERFORMANCE OF THIS SOFTWARE.
  57  ***************************************************************************** */
  58  /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
  59  
  60  var extendStatics = function(d, b) {
  61    extendStatics = Object.setPrototypeOf ||
  62        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
  63        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
  64    return extendStatics(d, b);
  65  };
  66  
  67  function __extends(d, b) {
  68    if (typeof b !== "function" && b !== null)
  69        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
  70    extendStatics(d, b);
  71    function __() { this.constructor = d; }
  72    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  73  }
  74  
  75  var __assign = function() {
  76    __assign = Object.assign || function __assign(t) {
  77        for (var s, i = 1, n = arguments.length; i < n; i++) {
  78            s = arguments[i];
  79            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
  80        }
  81        return t;
  82    }
  83    return __assign.apply(this, arguments);
  84  }
  85  
  86  function __rest(s, e) {
  87    var t = {};
  88    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
  89        t[p] = s[p];
  90    if (s != null && typeof Object.getOwnPropertySymbols === "function")
  91        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
  92            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
  93                t[p[i]] = s[p[i]];
  94        }
  95    return t;
  96  }
  97  
  98  function __decorate(decorators, target, key, desc) {
  99    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 100    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
 101    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
 102    return c > 3 && r && Object.defineProperty(target, key, r), r;
 103  }
 104  
 105  function __param(paramIndex, decorator) {
 106    return function (target, key) { decorator(target, key, paramIndex); }
 107  }
 108  
 109  function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
 110    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
 111    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
 112    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
 113    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
 114    var _, done = false;
 115    for (var i = decorators.length - 1; i >= 0; i--) {
 116        var context = {};
 117        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
 118        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
 119        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
 120        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
 121        if (kind === "accessor") {
 122            if (result === void 0) continue;
 123            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
 124            if (_ = accept(result.get)) descriptor.get = _;
 125            if (_ = accept(result.set)) descriptor.set = _;
 126            if (_ = accept(result.init)) initializers.unshift(_);
 127        }
 128        else if (_ = accept(result)) {
 129            if (kind === "field") initializers.unshift(_);
 130            else descriptor[key] = _;
 131        }
 132    }
 133    if (target) Object.defineProperty(target, contextIn.name, descriptor);
 134    done = true;
 135  };
 136  
 137  function __runInitializers(thisArg, initializers, value) {
 138    var useValue = arguments.length > 2;
 139    for (var i = 0; i < initializers.length; i++) {
 140        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
 141    }
 142    return useValue ? value : void 0;
 143  };
 144  
 145  function __propKey(x) {
 146    return typeof x === "symbol" ? x : "".concat(x);
 147  };
 148  
 149  function __setFunctionName(f, name, prefix) {
 150    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
 151    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 152  };
 153  
 154  function __metadata(metadataKey, metadataValue) {
 155    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 156  }
 157  
 158  function __awaiter(thisArg, _arguments, P, generator) {
 159    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
 160    return new (P || (P = Promise))(function (resolve, reject) {
 161        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
 162        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
 163        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
 164        step((generator = generator.apply(thisArg, _arguments || [])).next());
 165    });
 166  }
 167  
 168  function __generator(thisArg, body) {
 169    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
 170    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
 171    function verb(n) { return function (v) { return step([n, v]); }; }
 172    function step(op) {
 173        if (f) throw new TypeError("Generator is already executing.");
 174        while (g && (g = 0, op[0] && (_ = 0)), _) try {
 175            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
 176            if (y = 0, t) op = [op[0] & 2, t.value];
 177            switch (op[0]) {
 178                case 0: case 1: t = op; break;
 179                case 4: _.label++; return { value: op[1], done: false };
 180                case 5: _.label++; y = op[1]; op = [0]; continue;
 181                case 7: op = _.ops.pop(); _.trys.pop(); continue;
 182                default:
 183                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
 184                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
 185                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
 186                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
 187                    if (t[2]) _.ops.pop();
 188                    _.trys.pop(); continue;
 189            }
 190            op = body.call(thisArg, _);
 191        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
 192        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
 193    }
 194  }
 195  
 196  var __createBinding = Object.create ? (function(o, m, k, k2) {
 197    if (k2 === undefined) k2 = k;
 198    var desc = Object.getOwnPropertyDescriptor(m, k);
 199    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
 200        desc = { enumerable: true, get: function() { return m[k]; } };
 201    }
 202    Object.defineProperty(o, k2, desc);
 203  }) : (function(o, m, k, k2) {
 204    if (k2 === undefined) k2 = k;
 205    o[k2] = m[k];
 206  });
 207  
 208  function __exportStar(m, o) {
 209    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
 210  }
 211  
 212  function __values(o) {
 213    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
 214    if (m) return m.call(o);
 215    if (o && typeof o.length === "number") return {
 216        next: function () {
 217            if (o && i >= o.length) o = void 0;
 218            return { value: o && o[i++], done: !o };
 219        }
 220    };
 221    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 222  }
 223  
 224  function __read(o, n) {
 225    var m = typeof Symbol === "function" && o[Symbol.iterator];
 226    if (!m) return o;
 227    var i = m.call(o), r, ar = [], e;
 228    try {
 229        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
 230    }
 231    catch (error) { e = { error: error }; }
 232    finally {
 233        try {
 234            if (r && !r.done && (m = i["return"])) m.call(i);
 235        }
 236        finally { if (e) throw e.error; }
 237    }
 238    return ar;
 239  }
 240  
 241  /** @deprecated */
 242  function __spread() {
 243    for (var ar = [], i = 0; i < arguments.length; i++)
 244        ar = ar.concat(__read(arguments[i]));
 245    return ar;
 246  }
 247  
 248  /** @deprecated */
 249  function __spreadArrays() {
 250    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
 251    for (var r = Array(s), k = 0, i = 0; i < il; i++)
 252        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
 253            r[k] = a[j];
 254    return r;
 255  }
 256  
 257  function __spreadArray(to, from, pack) {
 258    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
 259        if (ar || !(i in from)) {
 260            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
 261            ar[i] = from[i];
 262        }
 263    }
 264    return to.concat(ar || Array.prototype.slice.call(from));
 265  }
 266  
 267  function __await(v) {
 268    return this instanceof __await ? (this.v = v, this) : new __await(v);
 269  }
 270  
 271  function __asyncGenerator(thisArg, _arguments, generator) {
 272    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
 273    var g = generator.apply(thisArg, _arguments || []), i, q = [];
 274    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
 275    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
 276    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
 277    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
 278    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
 279    function fulfill(value) { resume("next", value); }
 280    function reject(value) { resume("throw", value); }
 281    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 282  }
 283  
 284  function __asyncDelegator(o) {
 285    var i, p;
 286    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
 287    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
 288  }
 289  
 290  function __asyncValues(o) {
 291    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
 292    var m = o[Symbol.asyncIterator], i;
 293    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
 294    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
 295    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 296  }
 297  
 298  function __makeTemplateObject(cooked, raw) {
 299    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
 300    return cooked;
 301  };
 302  
 303  var __setModuleDefault = Object.create ? (function(o, v) {
 304    Object.defineProperty(o, "default", { enumerable: true, value: v });
 305  }) : function(o, v) {
 306    o["default"] = v;
 307  };
 308  
 309  var ownKeys = function(o) {
 310    ownKeys = Object.getOwnPropertyNames || function (o) {
 311      var ar = [];
 312      for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
 313      return ar;
 314    };
 315    return ownKeys(o);
 316  };
 317  
 318  function __importStar(mod) {
 319    if (mod && mod.__esModule) return mod;
 320    var result = {};
 321    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
 322    __setModuleDefault(result, mod);
 323    return result;
 324  }
 325  
 326  function __importDefault(mod) {
 327    return (mod && mod.__esModule) ? mod : { default: mod };
 328  }
 329  
 330  function __classPrivateFieldGet(receiver, state, kind, f) {
 331    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
 332    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
 333    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 334  }
 335  
 336  function __classPrivateFieldSet(receiver, state, value, kind, f) {
 337    if (kind === "m") throw new TypeError("Private method is not writable");
 338    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
 339    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
 340    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 341  }
 342  
 343  function __classPrivateFieldIn(state, receiver) {
 344    if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
 345    return typeof state === "function" ? receiver === state : state.has(receiver);
 346  }
 347  
 348  function __addDisposableResource(env, value, async) {
 349    if (value !== null && value !== void 0) {
 350      if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
 351      var dispose, inner;
 352      if (async) {
 353        if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
 354        dispose = value[Symbol.asyncDispose];
 355      }
 356      if (dispose === void 0) {
 357        if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
 358        dispose = value[Symbol.dispose];
 359        if (async) inner = dispose;
 360      }
 361      if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
 362      if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
 363      env.stack.push({ value: value, dispose: dispose, async: async });
 364    }
 365    else if (async) {
 366      env.stack.push({ async: true });
 367    }
 368    return value;
 369  }
 370  
 371  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
 372    var e = new Error(message);
 373    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 374  };
 375  
 376  function __disposeResources(env) {
 377    function fail(e) {
 378      env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
 379      env.hasError = true;
 380    }
 381    var r, s = 0;
 382    function next() {
 383      while (r = env.stack.pop()) {
 384        try {
 385          if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
 386          if (r.dispose) {
 387            var result = r.dispose.call(r.value);
 388            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
 389          }
 390          else s |= 1;
 391        }
 392        catch (e) {
 393          fail(e);
 394        }
 395      }
 396      if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
 397      if (env.hasError) throw env.error;
 398    }
 399    return next();
 400  }
 401  
 402  function __rewriteRelativeImportExtension(path, preserveJsx) {
 403    if (typeof path === "string" && /^\.\.?\//.test(path)) {
 404        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
 405            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
 406        });
 407    }
 408    return path;
 409  }
 410  
 411  /* harmony default export */ const tslib_es6 = ({
 412    __extends,
 413    __assign,
 414    __rest,
 415    __decorate,
 416    __param,
 417    __esDecorate,
 418    __runInitializers,
 419    __propKey,
 420    __setFunctionName,
 421    __metadata,
 422    __awaiter,
 423    __generator,
 424    __createBinding,
 425    __exportStar,
 426    __values,
 427    __read,
 428    __spread,
 429    __spreadArrays,
 430    __spreadArray,
 431    __await,
 432    __asyncGenerator,
 433    __asyncDelegator,
 434    __asyncValues,
 435    __makeTemplateObject,
 436    __importStar,
 437    __importDefault,
 438    __classPrivateFieldGet,
 439    __classPrivateFieldSet,
 440    __classPrivateFieldIn,
 441    __addDisposableResource,
 442    __disposeResources,
 443    __rewriteRelativeImportExtension,
 444  });
 445  
 446  ;// ./node_modules/lower-case/dist.es2015/index.js
 447  /**
 448   * Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
 449   */
 450  var SUPPORTED_LOCALE = {
 451      tr: {
 452          regexp: /\u0130|\u0049|\u0049\u0307/g,
 453          map: {
 454              İ: "\u0069",
 455              I: "\u0131",
 456              İ: "\u0069",
 457          },
 458      },
 459      az: {
 460          regexp: /\u0130/g,
 461          map: {
 462              İ: "\u0069",
 463              I: "\u0131",
 464              İ: "\u0069",
 465          },
 466      },
 467      lt: {
 468          regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g,
 469          map: {
 470              I: "\u0069\u0307",
 471              J: "\u006A\u0307",
 472              Į: "\u012F\u0307",
 473              Ì: "\u0069\u0307\u0300",
 474              Í: "\u0069\u0307\u0301",
 475              Ĩ: "\u0069\u0307\u0303",
 476          },
 477      },
 478  };
 479  /**
 480   * Localized lower case.
 481   */
 482  function localeLowerCase(str, locale) {
 483      var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
 484      if (lang)
 485          return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));
 486      return lowerCase(str);
 487  }
 488  /**
 489   * Lower case as a function.
 490   */
 491  function lowerCase(str) {
 492      return str.toLowerCase();
 493  }
 494  
 495  ;// ./node_modules/no-case/dist.es2015/index.js
 496  
 497  // Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
 498  var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
 499  // Remove all non-word characters.
 500  var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
 501  /**
 502   * Normalize the string into something other libraries can manipulate easier.
 503   */
 504  function noCase(input, options) {
 505      if (options === void 0) { options = {}; }
 506      var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
 507      var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
 508      var start = 0;
 509      var end = result.length;
 510      // Trim the delimiter from around the output string.
 511      while (result.charAt(start) === "\0")
 512          start++;
 513      while (result.charAt(end - 1) === "\0")
 514          end--;
 515      // Transform each token independently.
 516      return result.slice(start, end).split("\0").map(transform).join(delimiter);
 517  }
 518  /**
 519   * Replace `re` in the input string with the replacement value.
 520   */
 521  function replace(input, re, value) {
 522      if (re instanceof RegExp)
 523          return input.replace(re, value);
 524      return re.reduce(function (input, re) { return input.replace(re, value); }, input);
 525  }
 526  
 527  ;// ./node_modules/dot-case/dist.es2015/index.js
 528  
 529  
 530  function dotCase(input, options) {
 531      if (options === void 0) { options = {}; }
 532      return noCase(input, __assign({ delimiter: "." }, options));
 533  }
 534  
 535  ;// ./node_modules/param-case/dist.es2015/index.js
 536  
 537  
 538  function paramCase(input, options) {
 539      if (options === void 0) { options = {}; }
 540      return dotCase(input, __assign({ delimiter: "-" }, options));
 541  }
 542  
 543  ;// external ["wp","apiFetch"]
 544  const external_wp_apiFetch_namespaceObject = window["wp"]["apiFetch"];
 545  var external_wp_apiFetch_default = /*#__PURE__*/__webpack_require__.n(external_wp_apiFetch_namespaceObject);
 546  ;// external ["wp","blob"]
 547  const external_wp_blob_namespaceObject = window["wp"]["blob"];
 548  ;// ./node_modules/@wordpress/list-reusable-blocks/build-module/utils/export.js
 549  /**
 550   * External dependencies
 551   */
 552  
 553  
 554  /**
 555   * WordPress dependencies
 556   */
 557  
 558  
 559  /**
 560   * Internal dependencies
 561   */
 562  
 563  
 564  /**
 565   * Export a reusable block as a JSON file.
 566   *
 567   * @param {number} id
 568   */
 569  async function exportReusableBlock(id) {
 570    const postType = await external_wp_apiFetch_default()({
 571      path: `/wp/v2/types/wp_block`
 572    });
 573    const post = await external_wp_apiFetch_default()({
 574      path: `/wp/v2/$postType.rest_base}/$id}?context=edit`
 575    });
 576    const title = post.title.raw;
 577    const content = post.content.raw;
 578    const syncStatus = post.wp_pattern_sync_status;
 579    const fileContent = JSON.stringify({
 580      __file: 'wp_block',
 581      title,
 582      content,
 583      syncStatus
 584    }, null, 2);
 585    const fileName = paramCase(title) + '.json';
 586    (0,external_wp_blob_namespaceObject.downloadBlob)(fileName, fileContent, 'application/json');
 587  }
 588  /* harmony default export */ const utils_export = (exportReusableBlock);
 589  
 590  ;// external ["wp","compose"]
 591  const external_wp_compose_namespaceObject = window["wp"]["compose"];
 592  ;// external ["wp","components"]
 593  const external_wp_components_namespaceObject = window["wp"]["components"];
 594  ;// ./node_modules/@wordpress/list-reusable-blocks/build-module/utils/file.js
 595  /**
 596   * Reads the textual content of the given file.
 597   *
 598   * @param {File} file File.
 599   * @return {Promise<string>}  Content of the file.
 600   */
 601  function readTextFile(file) {
 602    const reader = new window.FileReader();
 603    return new Promise(resolve => {
 604      reader.onload = () => {
 605        resolve(reader.result);
 606      };
 607      reader.readAsText(file);
 608    });
 609  }
 610  
 611  ;// ./node_modules/@wordpress/list-reusable-blocks/build-module/utils/import.js
 612  /**
 613   * WordPress dependencies
 614   */
 615  
 616  
 617  /**
 618   * Internal dependencies
 619   */
 620  
 621  
 622  /**
 623   * Import a reusable block from a JSON file.
 624   *
 625   * @param {File} file File.
 626   * @return {Promise} Promise returning the imported reusable block.
 627   */
 628  async function importReusableBlock(file) {
 629    const fileContent = await readTextFile(file);
 630    let parsedContent;
 631    try {
 632      parsedContent = JSON.parse(fileContent);
 633    } catch (e) {
 634      throw new Error('Invalid JSON file');
 635    }
 636    if (parsedContent.__file !== 'wp_block' || !parsedContent.title || !parsedContent.content || typeof parsedContent.title !== 'string' || typeof parsedContent.content !== 'string' || parsedContent.syncStatus && typeof parsedContent.syncStatus !== 'string') {
 637      throw new Error('Invalid pattern JSON file');
 638    }
 639    const postType = await external_wp_apiFetch_default()({
 640      path: `/wp/v2/types/wp_block`
 641    });
 642    const reusableBlock = await external_wp_apiFetch_default()({
 643      path: `/wp/v2/$postType.rest_base}`,
 644      data: {
 645        title: parsedContent.title,
 646        content: parsedContent.content,
 647        status: 'publish',
 648        meta: parsedContent.syncStatus === 'unsynced' ? {
 649          wp_pattern_sync_status: parsedContent.syncStatus
 650        } : undefined
 651      },
 652      method: 'POST'
 653    });
 654    return reusableBlock;
 655  }
 656  /* harmony default export */ const utils_import = (importReusableBlock);
 657  
 658  ;// external "ReactJSXRuntime"
 659  const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
 660  ;// ./node_modules/@wordpress/list-reusable-blocks/build-module/components/import-form/index.js
 661  /**
 662   * WordPress dependencies
 663   */
 664  
 665  
 666  
 667  
 668  
 669  /**
 670   * Internal dependencies
 671   */
 672  
 673  
 674  function ImportForm({
 675    instanceId,
 676    onUpload
 677  }) {
 678    const inputId = 'list-reusable-blocks-import-form-' + instanceId;
 679    const formRef = (0,external_wp_element_namespaceObject.useRef)();
 680    const [isLoading, setIsLoading] = (0,external_wp_element_namespaceObject.useState)(false);
 681    const [error, setError] = (0,external_wp_element_namespaceObject.useState)(null);
 682    const [file, setFile] = (0,external_wp_element_namespaceObject.useState)(null);
 683    const onChangeFile = event => {
 684      setFile(event.target.files[0]);
 685      setError(null);
 686    };
 687    const onSubmit = event => {
 688      event.preventDefault();
 689      if (!file) {
 690        return;
 691      }
 692      setIsLoading({
 693        isLoading: true
 694      });
 695      utils_import(file).then(reusableBlock => {
 696        if (!formRef) {
 697          return;
 698        }
 699        setIsLoading(false);
 700        onUpload(reusableBlock);
 701      }).catch(errors => {
 702        if (!formRef) {
 703          return;
 704        }
 705        let uiMessage;
 706        switch (errors.message) {
 707          case 'Invalid JSON file':
 708            uiMessage = (0,external_wp_i18n_namespaceObject.__)('Invalid JSON file');
 709            break;
 710          case 'Invalid pattern JSON file':
 711            uiMessage = (0,external_wp_i18n_namespaceObject.__)('Invalid pattern JSON file');
 712            break;
 713          default:
 714            uiMessage = (0,external_wp_i18n_namespaceObject.__)('Unknown error');
 715        }
 716        setIsLoading(false);
 717        setError(uiMessage);
 718      });
 719    };
 720    const onDismissError = () => {
 721      setError(null);
 722    };
 723    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsxs)("form", {
 724      className: "list-reusable-blocks-import-form",
 725      onSubmit: onSubmit,
 726      ref: formRef,
 727      children: [error && /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Notice, {
 728        status: "error",
 729        onRemove: () => onDismissError(),
 730        children: error
 731      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("label", {
 732        htmlFor: inputId,
 733        className: "list-reusable-blocks-import-form__label",
 734        children: (0,external_wp_i18n_namespaceObject.__)('File')
 735      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)("input", {
 736        id: inputId,
 737        type: "file",
 738        onChange: onChangeFile
 739      }), /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
 740        __next40pxDefaultSize: true,
 741        type: "submit",
 742        isBusy: isLoading,
 743        accessibleWhenDisabled: true,
 744        disabled: !file || isLoading,
 745        variant: "secondary",
 746        className: "list-reusable-blocks-import-form__button",
 747        children: (0,external_wp_i18n_namespaceObject._x)('Import', 'button label')
 748      })]
 749    });
 750  }
 751  /* harmony default export */ const import_form = ((0,external_wp_compose_namespaceObject.withInstanceId)(ImportForm));
 752  
 753  ;// ./node_modules/@wordpress/list-reusable-blocks/build-module/components/import-dropdown/index.js
 754  /**
 755   * WordPress dependencies
 756   */
 757  
 758  
 759  
 760  
 761  /**
 762   * Internal dependencies
 763   */
 764  
 765  
 766  function ImportDropdown({
 767    onUpload
 768  }) {
 769    return /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Dropdown, {
 770      popoverProps: {
 771        placement: 'bottom-start'
 772      },
 773      contentClassName: "list-reusable-blocks-import-dropdown__content",
 774      renderToggle: ({
 775        isOpen,
 776        onToggle
 777      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_components_namespaceObject.Button, {
 778        size: "compact",
 779        className: "list-reusable-blocks-import-dropdown__button",
 780        "aria-expanded": isOpen,
 781        onClick: onToggle,
 782        variant: "primary",
 783        children: (0,external_wp_i18n_namespaceObject.__)('Import from JSON')
 784      }),
 785      renderContent: ({
 786        onClose
 787      }) => /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(import_form, {
 788        onUpload: (0,external_wp_compose_namespaceObject.pipe)(onClose, onUpload)
 789      })
 790    });
 791  }
 792  /* harmony default export */ const import_dropdown = (ImportDropdown);
 793  
 794  ;// ./node_modules/@wordpress/list-reusable-blocks/build-module/index.js
 795  /**
 796   * WordPress dependencies
 797   */
 798  
 799  
 800  
 801  /**
 802   * Internal dependencies
 803   */
 804  
 805  
 806  
 807  // Setup Export Links.
 808  
 809  document.body.addEventListener('click', event => {
 810    if (!event.target.classList.contains('wp-list-reusable-blocks__export')) {
 811      return;
 812    }
 813    event.preventDefault();
 814    utils_export(event.target.dataset.id);
 815  });
 816  
 817  // Setup Import Form.
 818  document.addEventListener('DOMContentLoaded', () => {
 819    const button = document.querySelector('.page-title-action');
 820    if (!button) {
 821      return;
 822    }
 823    const showNotice = () => {
 824      const notice = document.createElement('div');
 825      notice.className = 'notice notice-success is-dismissible';
 826      notice.innerHTML = `<p>${(0,external_wp_i18n_namespaceObject.__)('Pattern imported successfully!')}</p>`;
 827      const headerEnd = document.querySelector('.wp-header-end');
 828      if (!headerEnd) {
 829        return;
 830      }
 831      headerEnd.parentNode.insertBefore(notice, headerEnd);
 832    };
 833    const container = document.createElement('div');
 834    container.className = 'list-reusable-blocks__container';
 835    button.parentNode.insertBefore(container, button);
 836    (0,external_wp_element_namespaceObject.createRoot)(container).render(/*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.StrictMode, {
 837      children: /*#__PURE__*/(0,external_ReactJSXRuntime_namespaceObject.jsx)(import_dropdown, {
 838        onUpload: showNotice
 839      })
 840    }));
 841  });
 842  
 843  (window.wp = window.wp || {}).listReusableBlocks = __webpack_exports__;
 844  /******/ })()
 845  ;