[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/ -> data.js (source)

   1  this["wp"] = this["wp"] || {}; this["wp"]["data"] =
   2  /******/ (function(modules) { // webpackBootstrap
   3  /******/     // The module cache
   4  /******/     var installedModules = {};
   5  /******/
   6  /******/     // The require function
   7  /******/ 	function __webpack_require__(moduleId) {
   8  /******/
   9  /******/         // Check if module is in cache
  10  /******/         if(installedModules[moduleId]) {
  11  /******/             return installedModules[moduleId].exports;
  12  /******/         }
  13  /******/         // Create a new module (and put it into the cache)
  14  /******/         var module = installedModules[moduleId] = {
  15  /******/             i: moduleId,
  16  /******/             l: false,
  17  /******/             exports: {}
  18  /******/         };
  19  /******/
  20  /******/         // Execute the module function
  21  /******/         modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  22  /******/
  23  /******/         // Flag the module as loaded
  24  /******/         module.l = true;
  25  /******/
  26  /******/         // Return the exports of the module
  27  /******/         return module.exports;
  28  /******/     }
  29  /******/
  30  /******/
  31  /******/     // expose the modules object (__webpack_modules__)
  32  /******/     __webpack_require__.m = modules;
  33  /******/
  34  /******/     // expose the module cache
  35  /******/     __webpack_require__.c = installedModules;
  36  /******/
  37  /******/     // define getter function for harmony exports
  38  /******/     __webpack_require__.d = function(exports, name, getter) {
  39  /******/         if(!__webpack_require__.o(exports, name)) {
  40  /******/             Object.defineProperty(exports, name, { enumerable: true, get: getter });
  41  /******/         }
  42  /******/     };
  43  /******/
  44  /******/     // define __esModule on exports
  45  /******/     __webpack_require__.r = function(exports) {
  46  /******/         if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  47  /******/             Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  48  /******/         }
  49  /******/         Object.defineProperty(exports, '__esModule', { value: true });
  50  /******/     };
  51  /******/
  52  /******/     // create a fake namespace object
  53  /******/     // mode & 1: value is a module id, require it
  54  /******/     // mode & 2: merge all properties of value into the ns
  55  /******/     // mode & 4: return value when already ns object
  56  /******/     // mode & 8|1: behave like require
  57  /******/     __webpack_require__.t = function(value, mode) {
  58  /******/         if(mode & 1) value = __webpack_require__(value);
  59  /******/         if(mode & 8) return value;
  60  /******/         if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  61  /******/         var ns = Object.create(null);
  62  /******/         __webpack_require__.r(ns);
  63  /******/         Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  64  /******/         if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  65  /******/         return ns;
  66  /******/     };
  67  /******/
  68  /******/     // getDefaultExport function for compatibility with non-harmony modules
  69  /******/     __webpack_require__.n = function(module) {
  70  /******/         var getter = module && module.__esModule ?
  71  /******/ 			function getDefault() { return module['default']; } :
  72  /******/ 			function getModuleExports() { return module; };
  73  /******/         __webpack_require__.d(getter, 'a', getter);
  74  /******/         return getter;
  75  /******/     };
  76  /******/
  77  /******/     // Object.prototype.hasOwnProperty.call
  78  /******/     __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  79  /******/
  80  /******/     // __webpack_public_path__
  81  /******/     __webpack_require__.p = "";
  82  /******/
  83  /******/
  84  /******/     // Load entry module and return exports
  85  /******/     return __webpack_require__(__webpack_require__.s = "pfJ3");
  86  /******/ })
  87  /************************************************************************/
  88  /******/ ({
  89  
  90  /***/ "8mpt":
  91  /***/ (function(module, exports) {
  92  
  93  function combineReducers( reducers ) {
  94      var keys = Object.keys( reducers ),
  95          getNextState;
  96  
  97      getNextState = ( function() {
  98          var fn, i, key;
  99  
 100          fn = 'return {';
 101          for ( i = 0; i < keys.length; i++ ) {
 102              // Rely on Quoted escaping of JSON.stringify with guarantee that
 103              // each member of Object.keys is a string.
 104              //
 105              // "If Type(value) is String, then return the result of calling the
 106              // abstract operation Quote with argument value. [...] The abstract
 107              // operation Quote(value) wraps a String value in double quotes and
 108              // escapes characters within it."
 109              //
 110              // https://www.ecma-international.org/ecma-262/5.1/#sec-15.12.3
 111              key = JSON.stringify( keys[ i ] );
 112  
 113              fn += key + ':r[' + key + '](s[' + key + '],a),';
 114          }
 115          fn += '}';
 116  
 117          return new Function( 'r,s,a', fn );
 118      } )();
 119  
 120      return function combinedReducer( state, action ) {
 121          var nextState, i, key;
 122  
 123          // Assumed changed if initial state.
 124          if ( state === undefined ) {
 125              return getNextState( reducers, {}, action );
 126          }
 127  
 128          nextState = getNextState( reducers, state, action );
 129  
 130          // Determine whether state has changed.
 131          i = keys.length;
 132          while ( i-- ) {
 133              key = keys[ i ];
 134              if ( state[ key ] !== nextState[ key ] ) {
 135                  // Return immediately if a changed value is encountered.
 136                  return nextState;
 137              }
 138          }
 139  
 140          return state;
 141      };
 142  }
 143  
 144  module.exports = combineReducers;
 145  
 146  
 147  /***/ }),
 148  
 149  /***/ "FtRg":
 150  /***/ (function(module, exports, __webpack_require__) {
 151  
 152  "use strict";
 153  
 154  
 155  function _typeof(obj) {
 156    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
 157      _typeof = function (obj) {
 158        return typeof obj;
 159      };
 160    } else {
 161      _typeof = function (obj) {
 162        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
 163      };
 164    }
 165  
 166    return _typeof(obj);
 167  }
 168  
 169  function _classCallCheck(instance, Constructor) {
 170    if (!(instance instanceof Constructor)) {
 171      throw new TypeError("Cannot call a class as a function");
 172    }
 173  }
 174  
 175  function _defineProperties(target, props) {
 176    for (var i = 0; i < props.length; i++) {
 177      var descriptor = props[i];
 178      descriptor.enumerable = descriptor.enumerable || false;
 179      descriptor.configurable = true;
 180      if ("value" in descriptor) descriptor.writable = true;
 181      Object.defineProperty(target, descriptor.key, descriptor);
 182    }
 183  }
 184  
 185  function _createClass(Constructor, protoProps, staticProps) {
 186    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
 187    if (staticProps) _defineProperties(Constructor, staticProps);
 188    return Constructor;
 189  }
 190  
 191  /**
 192   * Given an instance of EquivalentKeyMap, returns its internal value pair tuple
 193   * for a key, if one exists. The tuple members consist of the last reference
 194   * value for the key (used in efficient subsequent lookups) and the value
 195   * assigned for the key at the leaf node.
 196   *
 197   * @param {EquivalentKeyMap} instance EquivalentKeyMap instance.
 198   * @param {*} key                     The key for which to return value pair.
 199   *
 200   * @return {?Array} Value pair, if exists.
 201   */
 202  function getValuePair(instance, key) {
 203    var _map = instance._map,
 204        _arrayTreeMap = instance._arrayTreeMap,
 205        _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the
 206    // value, which can be used to shortcut immediately to the value.
 207  
 208    if (_map.has(key)) {
 209      return _map.get(key);
 210    } // Sort keys to ensure stable retrieval from tree.
 211  
 212  
 213    var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value.
 214  
 215    var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;
 216  
 217    for (var i = 0; i < properties.length; i++) {
 218      var property = properties[i];
 219      map = map.get(property);
 220  
 221      if (map === undefined) {
 222        return;
 223      }
 224  
 225      var propertyValue = key[property];
 226      map = map.get(propertyValue);
 227  
 228      if (map === undefined) {
 229        return;
 230      }
 231    }
 232  
 233    var valuePair = map.get('_ekm_value');
 234  
 235    if (!valuePair) {
 236      return;
 237    } // If reached, it implies that an object-like key was set with another
 238    // reference, so delete the reference and replace with the current.
 239  
 240  
 241    _map.delete(valuePair[0]);
 242  
 243    valuePair[0] = key;
 244    map.set('_ekm_value', valuePair);
 245  
 246    _map.set(key, valuePair);
 247  
 248    return valuePair;
 249  }
 250  /**
 251   * Variant of a Map object which enables lookup by equivalent (deeply equal)
 252   * object and array keys.
 253   */
 254  
 255  
 256  var EquivalentKeyMap =
 257  /*#__PURE__*/
 258  function () {
 259    /**
 260     * Constructs a new instance of EquivalentKeyMap.
 261     *
 262     * @param {Iterable.<*>} iterable Initial pair of key, value for map.
 263     */
 264    function EquivalentKeyMap(iterable) {
 265      _classCallCheck(this, EquivalentKeyMap);
 266  
 267      this.clear();
 268  
 269      if (iterable instanceof EquivalentKeyMap) {
 270        // Map#forEach is only means of iterating with support for IE11.
 271        var iterablePairs = [];
 272        iterable.forEach(function (value, key) {
 273          iterablePairs.push([key, value]);
 274        });
 275        iterable = iterablePairs;
 276      }
 277  
 278      if (iterable != null) {
 279        for (var i = 0; i < iterable.length; i++) {
 280          this.set(iterable[i][0], iterable[i][1]);
 281        }
 282      }
 283    }
 284    /**
 285     * Accessor property returning the number of elements.
 286     *
 287     * @return {number} Number of elements.
 288     */
 289  
 290  
 291    _createClass(EquivalentKeyMap, [{
 292      key: "set",
 293  
 294      /**
 295       * Add or update an element with a specified key and value.
 296       *
 297       * @param {*} key   The key of the element to add.
 298       * @param {*} value The value of the element to add.
 299       *
 300       * @return {EquivalentKeyMap} Map instance.
 301       */
 302      value: function set(key, value) {
 303        // Shortcut non-object-like to set on internal Map.
 304        if (key === null || _typeof(key) !== 'object') {
 305          this._map.set(key, value);
 306  
 307          return this;
 308        } // Sort keys to ensure stable assignment into tree.
 309  
 310  
 311        var properties = Object.keys(key).sort();
 312        var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value.
 313  
 314        var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;
 315  
 316        for (var i = 0; i < properties.length; i++) {
 317          var property = properties[i];
 318  
 319          if (!map.has(property)) {
 320            map.set(property, new EquivalentKeyMap());
 321          }
 322  
 323          map = map.get(property);
 324          var propertyValue = key[property];
 325  
 326          if (!map.has(propertyValue)) {
 327            map.set(propertyValue, new EquivalentKeyMap());
 328          }
 329  
 330          map = map.get(propertyValue);
 331        } // If an _ekm_value exists, there was already an equivalent key. Before
 332        // overriding, ensure that the old key reference is removed from map to
 333        // avoid memory leak of accumulating equivalent keys. This is, in a
 334        // sense, a poor man's WeakMap, while still enabling iterability.
 335  
 336  
 337        var previousValuePair = map.get('_ekm_value');
 338  
 339        if (previousValuePair) {
 340          this._map.delete(previousValuePair[0]);
 341        }
 342  
 343        map.set('_ekm_value', valuePair);
 344  
 345        this._map.set(key, valuePair);
 346  
 347        return this;
 348      }
 349      /**
 350       * Returns a specified element.
 351       *
 352       * @param {*} key The key of the element to return.
 353       *
 354       * @return {?*} The element associated with the specified key or undefined
 355       *              if the key can't be found.
 356       */
 357  
 358    }, {
 359      key: "get",
 360      value: function get(key) {
 361        // Shortcut non-object-like to get from internal Map.
 362        if (key === null || _typeof(key) !== 'object') {
 363          return this._map.get(key);
 364        }
 365  
 366        var valuePair = getValuePair(this, key);
 367  
 368        if (valuePair) {
 369          return valuePair[1];
 370        }
 371      }
 372      /**
 373       * Returns a boolean indicating whether an element with the specified key
 374       * exists or not.
 375       *
 376       * @param {*} key The key of the element to test for presence.
 377       *
 378       * @return {boolean} Whether an element with the specified key exists.
 379       */
 380  
 381    }, {
 382      key: "has",
 383      value: function has(key) {
 384        if (key === null || _typeof(key) !== 'object') {
 385          return this._map.has(key);
 386        } // Test on the _presence_ of the pair, not its value, as even undefined
 387        // can be a valid member value for a key.
 388  
 389  
 390        return getValuePair(this, key) !== undefined;
 391      }
 392      /**
 393       * Removes the specified element.
 394       *
 395       * @param {*} key The key of the element to remove.
 396       *
 397       * @return {boolean} Returns true if an element existed and has been
 398       *                   removed, or false if the element does not exist.
 399       */
 400  
 401    }, {
 402      key: "delete",
 403      value: function _delete(key) {
 404        if (!this.has(key)) {
 405          return false;
 406        } // This naive implementation will leave orphaned child trees. A better
 407        // implementation should traverse and remove orphans.
 408  
 409  
 410        this.set(key, undefined);
 411        return true;
 412      }
 413      /**
 414       * Executes a provided function once per each key/value pair, in insertion
 415       * order.
 416       *
 417       * @param {Function} callback Function to execute for each element.
 418       * @param {*}        thisArg  Value to use as `this` when executing
 419       *                            `callback`.
 420       */
 421  
 422    }, {
 423      key: "forEach",
 424      value: function forEach(callback) {
 425        var _this = this;
 426  
 427        var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;
 428  
 429        this._map.forEach(function (value, key) {
 430          // Unwrap value from object-like value pair.
 431          if (key !== null && _typeof(key) === 'object') {
 432            value = value[1];
 433          }
 434  
 435          callback.call(thisArg, value, key, _this);
 436        });
 437      }
 438      /**
 439       * Removes all elements.
 440       */
 441  
 442    }, {
 443      key: "clear",
 444      value: function clear() {
 445        this._map = new Map();
 446        this._arrayTreeMap = new Map();
 447        this._objectTreeMap = new Map();
 448      }
 449    }, {
 450      key: "size",
 451      get: function get() {
 452        return this._map.size;
 453      }
 454    }]);
 455  
 456    return EquivalentKeyMap;
 457  }();
 458  
 459  module.exports = EquivalentKeyMap;
 460  
 461  
 462  /***/ }),
 463  
 464  /***/ "GRId":
 465  /***/ (function(module, exports) {
 466  
 467  (function() { module.exports = window["wp"]["element"]; }());
 468  
 469  /***/ }),
 470  
 471  /***/ "JlUD":
 472  /***/ (function(module, exports) {
 473  
 474  module.exports = isPromise;
 475  module.exports.default = isPromise;
 476  
 477  function isPromise(obj) {
 478    return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
 479  }
 480  
 481  
 482  /***/ }),
 483  
 484  /***/ "K9lf":
 485  /***/ (function(module, exports) {
 486  
 487  (function() { module.exports = window["wp"]["compose"]; }());
 488  
 489  /***/ }),
 490  
 491  /***/ "NMb1":
 492  /***/ (function(module, exports) {
 493  
 494  (function() { module.exports = window["wp"]["deprecated"]; }());
 495  
 496  /***/ }),
 497  
 498  /***/ "XI5e":
 499  /***/ (function(module, exports) {
 500  
 501  (function() { module.exports = window["wp"]["priorityQueue"]; }());
 502  
 503  /***/ }),
 504  
 505  /***/ "XIDh":
 506  /***/ (function(module, exports) {
 507  
 508  (function() { module.exports = window["wp"]["reduxRoutine"]; }());
 509  
 510  /***/ }),
 511  
 512  /***/ "YLtl":
 513  /***/ (function(module, exports) {
 514  
 515  (function() { module.exports = window["lodash"]; }());
 516  
 517  /***/ }),
 518  
 519  /***/ "cDcd":
 520  /***/ (function(module, exports) {
 521  
 522  (function() { module.exports = window["React"]; }());
 523  
 524  /***/ }),
 525  
 526  /***/ "mHlH":
 527  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 528  
 529  "use strict";
 530  /* unused harmony export useCallback */
 531  /* unused harmony export useCallbackOne */
 532  /* unused harmony export useMemo */
 533  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return useMemoOne; });
 534  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("cDcd");
 535  /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
 536  
 537  
 538  function areInputsEqual(newInputs, lastInputs) {
 539    if (newInputs.length !== lastInputs.length) {
 540      return false;
 541    }
 542  
 543    for (var i = 0; i < newInputs.length; i++) {
 544      if (newInputs[i] !== lastInputs[i]) {
 545        return false;
 546      }
 547    }
 548  
 549    return true;
 550  }
 551  
 552  function useMemoOne(getResult, inputs) {
 553    var initial = Object(react__WEBPACK_IMPORTED_MODULE_0__["useState"])(function () {
 554      return {
 555        inputs: inputs,
 556        result: getResult()
 557      };
 558    })[0];
 559    var isFirstRun = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(true);
 560    var committed = Object(react__WEBPACK_IMPORTED_MODULE_0__["useRef"])(initial);
 561    var useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs));
 562    var cache = useCache ? committed.current : {
 563      inputs: inputs,
 564      result: getResult()
 565    };
 566    Object(react__WEBPACK_IMPORTED_MODULE_0__["useEffect"])(function () {
 567      isFirstRun.current = false;
 568      committed.current = cache;
 569    }, [cache]);
 570    return cache.result;
 571  }
 572  function useCallbackOne(callback, inputs) {
 573    return useMemoOne(function () {
 574      return callback;
 575    }, inputs);
 576  }
 577  var useMemo = useMemoOne;
 578  var useCallback = useCallbackOne;
 579  
 580  
 581  
 582  
 583  /***/ }),
 584  
 585  /***/ "pfJ3":
 586  /***/ (function(module, __webpack_exports__, __webpack_require__) {
 587  
 588  "use strict";
 589  // ESM COMPAT FLAG
 590  __webpack_require__.r(__webpack_exports__);
 591  
 592  // EXPORTS
 593  __webpack_require__.d(__webpack_exports__, "withSelect", function() { return /* reexport */ with_select; });
 594  __webpack_require__.d(__webpack_exports__, "withDispatch", function() { return /* reexport */ with_dispatch; });
 595  __webpack_require__.d(__webpack_exports__, "withRegistry", function() { return /* reexport */ with_registry; });
 596  __webpack_require__.d(__webpack_exports__, "RegistryProvider", function() { return /* reexport */ context; });
 597  __webpack_require__.d(__webpack_exports__, "RegistryConsumer", function() { return /* reexport */ RegistryConsumer; });
 598  __webpack_require__.d(__webpack_exports__, "useRegistry", function() { return /* reexport */ useRegistry; });
 599  __webpack_require__.d(__webpack_exports__, "useSelect", function() { return /* reexport */ useSelect; });
 600  __webpack_require__.d(__webpack_exports__, "useDispatch", function() { return /* reexport */ use_dispatch; });
 601  __webpack_require__.d(__webpack_exports__, "AsyncModeProvider", function() { return /* reexport */ async_mode_provider_context; });
 602  __webpack_require__.d(__webpack_exports__, "createRegistry", function() { return /* reexport */ createRegistry; });
 603  __webpack_require__.d(__webpack_exports__, "createRegistrySelector", function() { return /* reexport */ createRegistrySelector; });
 604  __webpack_require__.d(__webpack_exports__, "createRegistryControl", function() { return /* reexport */ createRegistryControl; });
 605  __webpack_require__.d(__webpack_exports__, "controls", function() { return /* reexport */ controls_controls; });
 606  __webpack_require__.d(__webpack_exports__, "createReduxStore", function() { return /* reexport */ createReduxStore; });
 607  __webpack_require__.d(__webpack_exports__, "plugins", function() { return /* reexport */ plugins_namespaceObject; });
 608  __webpack_require__.d(__webpack_exports__, "combineReducers", function() { return /* reexport */ turbo_combine_reducers_default.a; });
 609  __webpack_require__.d(__webpack_exports__, "select", function() { return /* binding */ build_module_select; });
 610  __webpack_require__.d(__webpack_exports__, "resolveSelect", function() { return /* binding */ build_module_resolveSelect; });
 611  __webpack_require__.d(__webpack_exports__, "dispatch", function() { return /* binding */ build_module_dispatch; });
 612  __webpack_require__.d(__webpack_exports__, "subscribe", function() { return /* binding */ build_module_subscribe; });
 613  __webpack_require__.d(__webpack_exports__, "registerGenericStore", function() { return /* binding */ build_module_registerGenericStore; });
 614  __webpack_require__.d(__webpack_exports__, "registerStore", function() { return /* binding */ registerStore; });
 615  __webpack_require__.d(__webpack_exports__, "use", function() { return /* binding */ build_module_use; });
 616  __webpack_require__.d(__webpack_exports__, "register", function() { return /* binding */ build_module_register; });
 617  
 618  // NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js
 619  var selectors_namespaceObject = {};
 620  __webpack_require__.r(selectors_namespaceObject);
 621  __webpack_require__.d(selectors_namespaceObject, "getIsResolving", function() { return getIsResolving; });
 622  __webpack_require__.d(selectors_namespaceObject, "hasStartedResolution", function() { return hasStartedResolution; });
 623  __webpack_require__.d(selectors_namespaceObject, "hasFinishedResolution", function() { return hasFinishedResolution; });
 624  __webpack_require__.d(selectors_namespaceObject, "isResolving", function() { return isResolving; });
 625  __webpack_require__.d(selectors_namespaceObject, "getCachedResolvers", function() { return getCachedResolvers; });
 626  
 627  // NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js
 628  var actions_namespaceObject = {};
 629  __webpack_require__.r(actions_namespaceObject);
 630  __webpack_require__.d(actions_namespaceObject, "startResolution", function() { return startResolution; });
 631  __webpack_require__.d(actions_namespaceObject, "finishResolution", function() { return finishResolution; });
 632  __webpack_require__.d(actions_namespaceObject, "startResolutions", function() { return startResolutions; });
 633  __webpack_require__.d(actions_namespaceObject, "finishResolutions", function() { return finishResolutions; });
 634  __webpack_require__.d(actions_namespaceObject, "invalidateResolution", function() { return invalidateResolution; });
 635  __webpack_require__.d(actions_namespaceObject, "invalidateResolutionForStore", function() { return invalidateResolutionForStore; });
 636  __webpack_require__.d(actions_namespaceObject, "invalidateResolutionForStoreSelector", function() { return invalidateResolutionForStoreSelector; });
 637  
 638  // NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/plugins/index.js
 639  var plugins_namespaceObject = {};
 640  __webpack_require__.r(plugins_namespaceObject);
 641  __webpack_require__.d(plugins_namespaceObject, "controls", function() { return plugins_controls; });
 642  __webpack_require__.d(plugins_namespaceObject, "persistence", function() { return plugins_persistence; });
 643  
 644  // EXTERNAL MODULE: ./node_modules/turbo-combine-reducers/index.js
 645  var turbo_combine_reducers = __webpack_require__("8mpt");
 646  var turbo_combine_reducers_default = /*#__PURE__*/__webpack_require__.n(turbo_combine_reducers);
 647  
 648  // EXTERNAL MODULE: external "lodash"
 649  var external_lodash_ = __webpack_require__("YLtl");
 650  
 651  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
 652  function _defineProperty(obj, key, value) {
 653    if (key in obj) {
 654      Object.defineProperty(obj, key, {
 655        value: value,
 656        enumerable: true,
 657        configurable: true,
 658        writable: true
 659      });
 660    } else {
 661      obj[key] = value;
 662    }
 663  
 664    return obj;
 665  }
 666  // CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
 667  
 668  
 669  function ownKeys(object, enumerableOnly) {
 670    var keys = Object.keys(object);
 671  
 672    if (Object.getOwnPropertySymbols) {
 673      var symbols = Object.getOwnPropertySymbols(object);
 674      enumerableOnly && (symbols = symbols.filter(function (sym) {
 675        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
 676      })), keys.push.apply(keys, symbols);
 677    }
 678  
 679    return keys;
 680  }
 681  
 682  function _objectSpread2(target) {
 683    for (var i = 1; i < arguments.length; i++) {
 684      var source = null != arguments[i] ? arguments[i] : {};
 685      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
 686        _defineProperty(target, key, source[key]);
 687      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
 688        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
 689      });
 690    }
 691  
 692    return target;
 693  }
 694  // CONCATENATED MODULE: ./node_modules/redux/es/redux.js
 695  
 696  
 697  /**
 698   * Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js
 699   *
 700   * Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes
 701   * during build.
 702   * @param {number} code
 703   */
 704  function formatProdErrorMessage(code) {
 705    return "Minified Redux error #" + code + "; visit https://redux.js.org/Errors?code=" + code + " for the full message or " + 'use the non-minified dev environment for full errors. ';
 706  }
 707  
 708  // Inlined version of the `symbol-observable` polyfill
 709  var $$observable = (function () {
 710    return typeof Symbol === 'function' && Symbol.observable || '@@observable';
 711  })();
 712  
 713  /**
 714   * These are private action types reserved by Redux.
 715   * For any unknown actions, you must return the current state.
 716   * If the current state is undefined, you must return the initial state.
 717   * Do not reference these action types directly in your code.
 718   */
 719  var randomString = function randomString() {
 720    return Math.random().toString(36).substring(7).split('').join('.');
 721  };
 722  
 723  var ActionTypes = {
 724    INIT: "@@redux/INIT" + randomString(),
 725    REPLACE: "@@redux/REPLACE" + randomString(),
 726    PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
 727      return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
 728    }
 729  };
 730  
 731  /**
 732   * @param {any} obj The object to inspect.
 733   * @returns {boolean} True if the argument appears to be a plain object.
 734   */
 735  function isPlainObject(obj) {
 736    if (typeof obj !== 'object' || obj === null) return false;
 737    var proto = obj;
 738  
 739    while (Object.getPrototypeOf(proto) !== null) {
 740      proto = Object.getPrototypeOf(proto);
 741    }
 742  
 743    return Object.getPrototypeOf(obj) === proto;
 744  }
 745  
 746  // Inlined / shortened version of `kindOf` from https://github.com/jonschlinkert/kind-of
 747  function miniKindOf(val) {
 748    if (val === void 0) return 'undefined';
 749    if (val === null) return 'null';
 750    var type = typeof val;
 751  
 752    switch (type) {
 753      case 'boolean':
 754      case 'string':
 755      case 'number':
 756      case 'symbol':
 757      case 'function':
 758        {
 759          return type;
 760        }
 761    }
 762  
 763    if (Array.isArray(val)) return 'array';
 764    if (isDate(val)) return 'date';
 765    if (isError(val)) return 'error';
 766    var constructorName = ctorName(val);
 767  
 768    switch (constructorName) {
 769      case 'Symbol':
 770      case 'Promise':
 771      case 'WeakMap':
 772      case 'WeakSet':
 773      case 'Map':
 774      case 'Set':
 775        return constructorName;
 776    } // other
 777  
 778  
 779    return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
 780  }
 781  
 782  function ctorName(val) {
 783    return typeof val.constructor === 'function' ? val.constructor.name : null;
 784  }
 785  
 786  function isError(val) {
 787    return val instanceof Error || typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number';
 788  }
 789  
 790  function isDate(val) {
 791    if (val instanceof Date) return true;
 792    return typeof val.toDateString === 'function' && typeof val.getDate === 'function' && typeof val.setDate === 'function';
 793  }
 794  
 795  function kindOf(val) {
 796    var typeOfVal = typeof val;
 797  
 798    if (false) {}
 799  
 800    return typeOfVal;
 801  }
 802  
 803  /**
 804   * Creates a Redux store that holds the state tree.
 805   * The only way to change the data in the store is to call `dispatch()` on it.
 806   *
 807   * There should only be a single store in your app. To specify how different
 808   * parts of the state tree respond to actions, you may combine several reducers
 809   * into a single reducer function by using `combineReducers`.
 810   *
 811   * @param {Function} reducer A function that returns the next state tree, given
 812   * the current state tree and the action to handle.
 813   *
 814   * @param {any} [preloadedState] The initial state. You may optionally specify it
 815   * to hydrate the state from the server in universal apps, or to restore a
 816   * previously serialized user session.
 817   * If you use `combineReducers` to produce the root reducer function, this must be
 818   * an object with the same shape as `combineReducers` keys.
 819   *
 820   * @param {Function} [enhancer] The store enhancer. You may optionally specify it
 821   * to enhance the store with third-party capabilities such as middleware,
 822   * time travel, persistence, etc. The only store enhancer that ships with Redux
 823   * is `applyMiddleware()`.
 824   *
 825   * @returns {Store} A Redux store that lets you read the state, dispatch actions
 826   * and subscribe to changes.
 827   */
 828  
 829  function redux_createStore(reducer, preloadedState, enhancer) {
 830    var _ref2;
 831  
 832    if (typeof preloadedState === 'function' && typeof enhancer === 'function' || typeof enhancer === 'function' && typeof arguments[3] === 'function') {
 833      throw new Error( true ? formatProdErrorMessage(0) : undefined);
 834    }
 835  
 836    if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
 837      enhancer = preloadedState;
 838      preloadedState = undefined;
 839    }
 840  
 841    if (typeof enhancer !== 'undefined') {
 842      if (typeof enhancer !== 'function') {
 843        throw new Error( true ? formatProdErrorMessage(1) : undefined);
 844      }
 845  
 846      return enhancer(redux_createStore)(reducer, preloadedState);
 847    }
 848  
 849    if (typeof reducer !== 'function') {
 850      throw new Error( true ? formatProdErrorMessage(2) : undefined);
 851    }
 852  
 853    var currentReducer = reducer;
 854    var currentState = preloadedState;
 855    var currentListeners = [];
 856    var nextListeners = currentListeners;
 857    var isDispatching = false;
 858    /**
 859     * This makes a shallow copy of currentListeners so we can use
 860     * nextListeners as a temporary list while dispatching.
 861     *
 862     * This prevents any bugs around consumers calling
 863     * subscribe/unsubscribe in the middle of a dispatch.
 864     */
 865  
 866    function ensureCanMutateNextListeners() {
 867      if (nextListeners === currentListeners) {
 868        nextListeners = currentListeners.slice();
 869      }
 870    }
 871    /**
 872     * Reads the state tree managed by the store.
 873     *
 874     * @returns {any} The current state tree of your application.
 875     */
 876  
 877  
 878    function getState() {
 879      if (isDispatching) {
 880        throw new Error( true ? formatProdErrorMessage(3) : undefined);
 881      }
 882  
 883      return currentState;
 884    }
 885    /**
 886     * Adds a change listener. It will be called any time an action is dispatched,
 887     * and some part of the state tree may potentially have changed. You may then
 888     * call `getState()` to read the current state tree inside the callback.
 889     *
 890     * You may call `dispatch()` from a change listener, with the following
 891     * caveats:
 892     *
 893     * 1. The subscriptions are snapshotted just before every `dispatch()` call.
 894     * If you subscribe or unsubscribe while the listeners are being invoked, this
 895     * will not have any effect on the `dispatch()` that is currently in progress.
 896     * However, the next `dispatch()` call, whether nested or not, will use a more
 897     * recent snapshot of the subscription list.
 898     *
 899     * 2. The listener should not expect to see all state changes, as the state
 900     * might have been updated multiple times during a nested `dispatch()` before
 901     * the listener is called. It is, however, guaranteed that all subscribers
 902     * registered before the `dispatch()` started will be called with the latest
 903     * state by the time it exits.
 904     *
 905     * @param {Function} listener A callback to be invoked on every dispatch.
 906     * @returns {Function} A function to remove this change listener.
 907     */
 908  
 909  
 910    function subscribe(listener) {
 911      if (typeof listener !== 'function') {
 912        throw new Error( true ? formatProdErrorMessage(4) : undefined);
 913      }
 914  
 915      if (isDispatching) {
 916        throw new Error( true ? formatProdErrorMessage(5) : undefined);
 917      }
 918  
 919      var isSubscribed = true;
 920      ensureCanMutateNextListeners();
 921      nextListeners.push(listener);
 922      return function unsubscribe() {
 923        if (!isSubscribed) {
 924          return;
 925        }
 926  
 927        if (isDispatching) {
 928          throw new Error( true ? formatProdErrorMessage(6) : undefined);
 929        }
 930  
 931        isSubscribed = false;
 932        ensureCanMutateNextListeners();
 933        var index = nextListeners.indexOf(listener);
 934        nextListeners.splice(index, 1);
 935        currentListeners = null;
 936      };
 937    }
 938    /**
 939     * Dispatches an action. It is the only way to trigger a state change.
 940     *
 941     * The `reducer` function, used to create the store, will be called with the
 942     * current state tree and the given `action`. Its return value will
 943     * be considered the **next** state of the tree, and the change listeners
 944     * will be notified.
 945     *
 946     * The base implementation only supports plain object actions. If you want to
 947     * dispatch a Promise, an Observable, a thunk, or something else, you need to
 948     * wrap your store creating function into the corresponding middleware. For
 949     * example, see the documentation for the `redux-thunk` package. Even the
 950     * middleware will eventually dispatch plain object actions using this method.
 951     *
 952     * @param {Object} action A plain object representing “what changed”. It is
 953     * a good idea to keep actions serializable so you can record and replay user
 954     * sessions, or use the time travelling `redux-devtools`. An action must have
 955     * a `type` property which may not be `undefined`. It is a good idea to use
 956     * string constants for action types.
 957     *
 958     * @returns {Object} For convenience, the same action object you dispatched.
 959     *
 960     * Note that, if you use a custom middleware, it may wrap `dispatch()` to
 961     * return something else (for example, a Promise you can await).
 962     */
 963  
 964  
 965    function dispatch(action) {
 966      if (!isPlainObject(action)) {
 967        throw new Error( true ? formatProdErrorMessage(7) : undefined);
 968      }
 969  
 970      if (typeof action.type === 'undefined') {
 971        throw new Error( true ? formatProdErrorMessage(8) : undefined);
 972      }
 973  
 974      if (isDispatching) {
 975        throw new Error( true ? formatProdErrorMessage(9) : undefined);
 976      }
 977  
 978      try {
 979        isDispatching = true;
 980        currentState = currentReducer(currentState, action);
 981      } finally {
 982        isDispatching = false;
 983      }
 984  
 985      var listeners = currentListeners = nextListeners;
 986  
 987      for (var i = 0; i < listeners.length; i++) {
 988        var listener = listeners[i];
 989        listener();
 990      }
 991  
 992      return action;
 993    }
 994    /**
 995     * Replaces the reducer currently used by the store to calculate the state.
 996     *
 997     * You might need this if your app implements code splitting and you want to
 998     * load some of the reducers dynamically. You might also need this if you
 999     * implement a hot reloading mechanism for Redux.
1000     *
1001     * @param {Function} nextReducer The reducer for the store to use instead.
1002     * @returns {void}
1003     */
1004  
1005  
1006    function replaceReducer(nextReducer) {
1007      if (typeof nextReducer !== 'function') {
1008        throw new Error( true ? formatProdErrorMessage(10) : undefined);
1009      }
1010  
1011      currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT.
1012      // Any reducers that existed in both the new and old rootReducer
1013      // will receive the previous state. This effectively populates
1014      // the new state tree with any relevant data from the old one.
1015  
1016      dispatch({
1017        type: ActionTypes.REPLACE
1018      });
1019    }
1020    /**
1021     * Interoperability point for observable/reactive libraries.
1022     * @returns {observable} A minimal observable of state changes.
1023     * For more information, see the observable proposal:
1024     * https://github.com/tc39/proposal-observable
1025     */
1026  
1027  
1028    function observable() {
1029      var _ref;
1030  
1031      var outerSubscribe = subscribe;
1032      return _ref = {
1033        /**
1034         * The minimal observable subscription method.
1035         * @param {Object} observer Any object that can be used as an observer.
1036         * The observer object should have a `next` method.
1037         * @returns {subscription} An object with an `unsubscribe` method that can
1038         * be used to unsubscribe the observable from the store, and prevent further
1039         * emission of values from the observable.
1040         */
1041        subscribe: function subscribe(observer) {
1042          if (typeof observer !== 'object' || observer === null) {
1043            throw new Error( true ? formatProdErrorMessage(11) : undefined);
1044          }
1045  
1046          function observeState() {
1047            if (observer.next) {
1048              observer.next(getState());
1049            }
1050          }
1051  
1052          observeState();
1053          var unsubscribe = outerSubscribe(observeState);
1054          return {
1055            unsubscribe: unsubscribe
1056          };
1057        }
1058      }, _ref[$$observable] = function () {
1059        return this;
1060      }, _ref;
1061    } // When a store is created, an "INIT" action is dispatched so that every
1062    // reducer returns their initial state. This effectively populates
1063    // the initial state tree.
1064  
1065  
1066    dispatch({
1067      type: ActionTypes.INIT
1068    });
1069    return _ref2 = {
1070      dispatch: dispatch,
1071      subscribe: subscribe,
1072      getState: getState,
1073      replaceReducer: replaceReducer
1074    }, _ref2[$$observable] = observable, _ref2;
1075  }
1076  
1077  /**
1078   * Prints a warning in the console if it exists.
1079   *
1080   * @param {String} message The warning message.
1081   * @returns {void}
1082   */
1083  function warning(message) {
1084    /* eslint-disable no-console */
1085    if (typeof console !== 'undefined' && typeof console.error === 'function') {
1086      console.error(message);
1087    }
1088    /* eslint-enable no-console */
1089  
1090  
1091    try {
1092      // This error was thrown as a convenience so that if you enable
1093      // "break on all exceptions" in your console,
1094      // it would pause the execution at this line.
1095      throw new Error(message);
1096    } catch (e) {} // eslint-disable-line no-empty
1097  
1098  }
1099  
1100  function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
1101    var reducerKeys = Object.keys(reducers);
1102    var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';
1103  
1104    if (reducerKeys.length === 0) {
1105      return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';
1106    }
1107  
1108    if (!isPlainObject(inputState)) {
1109      return "The " + argumentName + " has unexpected type of \"" + kindOf(inputState) + "\". Expected argument to be an object with the following " + ("keys: \"" + reducerKeys.join('", "') + "\"");
1110    }
1111  
1112    var unexpectedKeys = Object.keys(inputState).filter(function (key) {
1113      return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];
1114    });
1115    unexpectedKeys.forEach(function (key) {
1116      unexpectedKeyCache[key] = true;
1117    });
1118    if (action && action.type === ActionTypes.REPLACE) return;
1119  
1120    if (unexpectedKeys.length > 0) {
1121      return "Unexpected " + (unexpectedKeys.length > 1 ? 'keys' : 'key') + " " + ("\"" + unexpectedKeys.join('", "') + "\" found in " + argumentName + ". ") + "Expected to find one of the known reducer keys instead: " + ("\"" + reducerKeys.join('", "') + "\". Unexpected keys will be ignored.");
1122    }
1123  }
1124  
1125  function assertReducerShape(reducers) {
1126    Object.keys(reducers).forEach(function (key) {
1127      var reducer = reducers[key];
1128      var initialState = reducer(undefined, {
1129        type: ActionTypes.INIT
1130      });
1131  
1132      if (typeof initialState === 'undefined') {
1133        throw new Error( true ? formatProdErrorMessage(12) : undefined);
1134      }
1135  
1136      if (typeof reducer(undefined, {
1137        type: ActionTypes.PROBE_UNKNOWN_ACTION()
1138      }) === 'undefined') {
1139        throw new Error( true ? formatProdErrorMessage(13) : undefined);
1140      }
1141    });
1142  }
1143  /**
1144   * Turns an object whose values are different reducer functions, into a single
1145   * reducer function. It will call every child reducer, and gather their results
1146   * into a single state object, whose keys correspond to the keys of the passed
1147   * reducer functions.
1148   *
1149   * @param {Object} reducers An object whose values correspond to different
1150   * reducer functions that need to be combined into one. One handy way to obtain
1151   * it is to use ES6 `import * as reducers` syntax. The reducers may never return
1152   * undefined for any action. Instead, they should return their initial state
1153   * if the state passed to them was undefined, and the current state for any
1154   * unrecognized action.
1155   *
1156   * @returns {Function} A reducer function that invokes every reducer inside the
1157   * passed object, and builds a state object with the same shape.
1158   */
1159  
1160  
1161  function combineReducers(reducers) {
1162    var reducerKeys = Object.keys(reducers);
1163    var finalReducers = {};
1164  
1165    for (var i = 0; i < reducerKeys.length; i++) {
1166      var key = reducerKeys[i];
1167  
1168      if (false) {}
1169  
1170      if (typeof reducers[key] === 'function') {
1171        finalReducers[key] = reducers[key];
1172      }
1173    }
1174  
1175    var finalReducerKeys = Object.keys(finalReducers); // This is used to make sure we don't warn about the same
1176    // keys multiple times.
1177  
1178    var unexpectedKeyCache;
1179  
1180    if (false) {}
1181  
1182    var shapeAssertionError;
1183  
1184    try {
1185      assertReducerShape(finalReducers);
1186    } catch (e) {
1187      shapeAssertionError = e;
1188    }
1189  
1190    return function combination(state, action) {
1191      if (state === void 0) {
1192        state = {};
1193      }
1194  
1195      if (shapeAssertionError) {
1196        throw shapeAssertionError;
1197      }
1198  
1199      if (false) { var warningMessage; }
1200  
1201      var hasChanged = false;
1202      var nextState = {};
1203  
1204      for (var _i = 0; _i < finalReducerKeys.length; _i++) {
1205        var _key = finalReducerKeys[_i];
1206        var reducer = finalReducers[_key];
1207        var previousStateForKey = state[_key];
1208        var nextStateForKey = reducer(previousStateForKey, action);
1209  
1210        if (typeof nextStateForKey === 'undefined') {
1211          var actionType = action && action.type;
1212          throw new Error( true ? formatProdErrorMessage(14) : undefined);
1213        }
1214  
1215        nextState[_key] = nextStateForKey;
1216        hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
1217      }
1218  
1219      hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
1220      return hasChanged ? nextState : state;
1221    };
1222  }
1223  
1224  function bindActionCreator(actionCreator, dispatch) {
1225    return function () {
1226      return dispatch(actionCreator.apply(this, arguments));
1227    };
1228  }
1229  /**
1230   * Turns an object whose values are action creators, into an object with the
1231   * same keys, but with every function wrapped into a `dispatch` call so they
1232   * may be invoked directly. This is just a convenience method, as you can call
1233   * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.
1234   *
1235   * For convenience, you can also pass an action creator as the first argument,
1236   * and get a dispatch wrapped function in return.
1237   *
1238   * @param {Function|Object} actionCreators An object whose values are action
1239   * creator functions. One handy way to obtain it is to use ES6 `import * as`
1240   * syntax. You may also pass a single function.
1241   *
1242   * @param {Function} dispatch The `dispatch` function available on your Redux
1243   * store.
1244   *
1245   * @returns {Function|Object} The object mimicking the original object, but with
1246   * every action creator wrapped into the `dispatch` call. If you passed a
1247   * function as `actionCreators`, the return value will also be a single
1248   * function.
1249   */
1250  
1251  
1252  function bindActionCreators(actionCreators, dispatch) {
1253    if (typeof actionCreators === 'function') {
1254      return bindActionCreator(actionCreators, dispatch);
1255    }
1256  
1257    if (typeof actionCreators !== 'object' || actionCreators === null) {
1258      throw new Error( true ? formatProdErrorMessage(16) : undefined);
1259    }
1260  
1261    var boundActionCreators = {};
1262  
1263    for (var key in actionCreators) {
1264      var actionCreator = actionCreators[key];
1265  
1266      if (typeof actionCreator === 'function') {
1267        boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
1268      }
1269    }
1270  
1271    return boundActionCreators;
1272  }
1273  
1274  /**
1275   * Composes single-argument functions from right to left. The rightmost
1276   * function can take multiple arguments as it provides the signature for
1277   * the resulting composite function.
1278   *
1279   * @param {...Function} funcs The functions to compose.
1280   * @returns {Function} A function obtained by composing the argument functions
1281   * from right to left. For example, compose(f, g, h) is identical to doing
1282   * (...args) => f(g(h(...args))).
1283   */
1284  function compose() {
1285    for (var _len = arguments.length, funcs = new Array(_len), _key = 0; _key < _len; _key++) {
1286      funcs[_key] = arguments[_key];
1287    }
1288  
1289    if (funcs.length === 0) {
1290      return function (arg) {
1291        return arg;
1292      };
1293    }
1294  
1295    if (funcs.length === 1) {
1296      return funcs[0];
1297    }
1298  
1299    return funcs.reduce(function (a, b) {
1300      return function () {
1301        return a(b.apply(void 0, arguments));
1302      };
1303    });
1304  }
1305  
1306  /**
1307   * Creates a store enhancer that applies middleware to the dispatch method
1308   * of the Redux store. This is handy for a variety of tasks, such as expressing
1309   * asynchronous actions in a concise manner, or logging every action payload.
1310   *
1311   * See `redux-thunk` package as an example of the Redux middleware.
1312   *
1313   * Because middleware is potentially asynchronous, this should be the first
1314   * store enhancer in the composition chain.
1315   *
1316   * Note that each middleware will be given the `dispatch` and `getState` functions
1317   * as named arguments.
1318   *
1319   * @param {...Function} middlewares The middleware chain to be applied.
1320   * @returns {Function} A store enhancer applying the middleware.
1321   */
1322  
1323  function applyMiddleware() {
1324    for (var _len = arguments.length, middlewares = new Array(_len), _key = 0; _key < _len; _key++) {
1325      middlewares[_key] = arguments[_key];
1326    }
1327  
1328    return function (createStore) {
1329      return function () {
1330        var store = createStore.apply(void 0, arguments);
1331  
1332        var _dispatch = function dispatch() {
1333          throw new Error( true ? formatProdErrorMessage(15) : undefined);
1334        };
1335  
1336        var middlewareAPI = {
1337          getState: store.getState,
1338          dispatch: function dispatch() {
1339            return _dispatch.apply(void 0, arguments);
1340          }
1341        };
1342        var chain = middlewares.map(function (middleware) {
1343          return middleware(middlewareAPI);
1344        });
1345        _dispatch = compose.apply(void 0, chain)(store.dispatch);
1346        return _objectSpread2(_objectSpread2({}, store), {}, {
1347          dispatch: _dispatch
1348        });
1349      };
1350    };
1351  }
1352  
1353  /*
1354   * This is a dummy function to check if the function name has been altered by minification.
1355   * If the function has been minified and NODE_ENV !== 'production', warn the user.
1356   */
1357  
1358  function isCrushed() {}
1359  
1360  if (false) {}
1361  
1362  
1363  
1364  // EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js
1365  var equivalent_key_map = __webpack_require__("FtRg");
1366  var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map);
1367  
1368  // EXTERNAL MODULE: external ["wp","reduxRoutine"]
1369  var external_wp_reduxRoutine_ = __webpack_require__("XIDh");
1370  var external_wp_reduxRoutine_default = /*#__PURE__*/__webpack_require__.n(external_wp_reduxRoutine_);
1371  
1372  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/factory.js
1373  /**
1374   * Creates a selector function that takes additional curried argument with the
1375   * registry `select` function. While a regular selector has signature
1376   * ```js
1377   * ( state, ...selectorArgs ) => ( result )
1378   * ```
1379   * that allows to select data from the store's `state`, a registry selector
1380   * has signature:
1381   * ```js
1382   * ( select ) => ( state, ...selectorArgs ) => ( result )
1383   * ```
1384   * that supports also selecting from other registered stores.
1385   *
1386   * @example
1387   * ```js
1388   * const getCurrentPostId = createRegistrySelector( ( select ) => ( state ) => {
1389   *   return select( 'core/editor' ).getCurrentPostId();
1390   * } );
1391   *
1392   * const getPostEdits = createRegistrySelector( ( select ) => ( state ) => {
1393   *   // calling another registry selector just like any other function
1394   *   const postType = getCurrentPostType( state );
1395   *   const postId = getCurrentPostId( state );
1396   *     return select( 'core' ).getEntityRecordEdits( 'postType', postType, postId );
1397   * } );
1398   * ```
1399   *
1400   * Note how the `getCurrentPostId` selector can be called just like any other function,
1401   * (it works even inside a regular non-registry selector) and we don't need to pass the
1402   * registry as argument. The registry binding happens automatically when registering the selector
1403   * with a store.
1404   *
1405   * @param {Function} registrySelector Function receiving a registry `select`
1406   *                                    function and returning a state selector.
1407   *
1408   * @return {Function} Registry selector that can be registered with a store.
1409   */
1410  function createRegistrySelector(registrySelector) {
1411    // create a selector function that is bound to the registry referenced by `selector.registry`
1412    // and that has the same API as a regular selector. Binding it in such a way makes it
1413    // possible to call the selector directly from another selector.
1414    const selector = function () {
1415      return registrySelector(selector.registry.select)(...arguments);
1416    };
1417    /**
1418     * Flag indicating that the selector is a registry selector that needs the correct registry
1419     * reference to be assigned to `selecto.registry` to make it work correctly.
1420     * be mapped as a registry selector.
1421     *
1422     * @type {boolean}
1423     */
1424  
1425  
1426    selector.isRegistrySelector = true;
1427    return selector;
1428  }
1429  /**
1430   * Creates a control function that takes additional curried argument with the `registry` object.
1431   * While a regular control has signature
1432   * ```js
1433   * ( action ) => ( iteratorOrPromise )
1434   * ```
1435   * where the control works with the `action` that it's bound to, a registry control has signature:
1436   * ```js
1437   * ( registry ) => ( action ) => ( iteratorOrPromise )
1438   * ```
1439   * A registry control is typically used to select data or dispatch an action to a registered
1440   * store.
1441   *
1442   * When registering a control created with `createRegistryControl` with a store, the store
1443   * knows which calling convention to use when executing the control.
1444   *
1445   * @param {Function} registryControl Function receiving a registry object and returning a control.
1446   *
1447   * @return {Function} Registry control that can be registered with a store.
1448   */
1449  
1450  function createRegistryControl(registryControl) {
1451    registryControl.isRegistryControl = true;
1452    return registryControl;
1453  }
1454  
1455  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/controls.js
1456  /**
1457   * External dependencies
1458   */
1459  
1460  /**
1461   * Internal dependencies
1462   */
1463  
1464  
1465  /** @typedef {import('./types').WPDataStore} WPDataStore */
1466  
1467  const SELECT = '@@data/SELECT';
1468  const RESOLVE_SELECT = '@@data/RESOLVE_SELECT';
1469  const DISPATCH = '@@data/DISPATCH';
1470  /**
1471   * Dispatches a control action for triggering a synchronous registry select.
1472   *
1473   * Note: This control synchronously returns the current selector value, triggering the
1474   * resolution, but not waiting for it.
1475   *
1476   * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store
1477   * @param {string}             selectorName          The name of the selector.
1478   * @param {Array}              args                  Arguments for the selector.
1479   *
1480   * @example
1481   * ```js
1482   * import { controls } from '@wordpress/data';
1483   *
1484   * // Action generator using `select`.
1485   * export function* myAction() {
1486   *   const isEditorSideBarOpened = yield controls.select( 'core/edit-post', 'isEditorSideBarOpened' );
1487   *   // Do stuff with the result from the `select`.
1488   * }
1489   * ```
1490   *
1491   * @return {Object} The control descriptor.
1492   */
1493  
1494  function controls_select(storeNameOrDefinition, selectorName) {
1495    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
1496      args[_key - 2] = arguments[_key];
1497    }
1498  
1499    return {
1500      type: SELECT,
1501      storeKey: Object(external_lodash_["isObject"])(storeNameOrDefinition) ? storeNameOrDefinition.name : storeNameOrDefinition,
1502      selectorName,
1503      args
1504    };
1505  }
1506  /**
1507   * Dispatches a control action for triggering and resolving a registry select.
1508   *
1509   * Note: when this control action is handled, it automatically considers
1510   * selectors that may have a resolver. In such case, it will return a `Promise` that resolves
1511   * after the selector finishes resolving, with the final result value.
1512   *
1513   * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store
1514   * @param {string}             selectorName          The name of the selector
1515   * @param {Array}              args                  Arguments for the selector.
1516   *
1517   * @example
1518   * ```js
1519   * import { controls } from '@wordpress/data';
1520   *
1521   * // Action generator using resolveSelect
1522   * export function* myAction() {
1523   *     const isSidebarOpened = yield controls.resolveSelect( 'core/edit-post', 'isEditorSideBarOpened' );
1524   *     // do stuff with the result from the select.
1525   * }
1526   * ```
1527   *
1528   * @return {Object} The control descriptor.
1529   */
1530  
1531  
1532  function controls_resolveSelect(storeNameOrDefinition, selectorName) {
1533    for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
1534      args[_key2 - 2] = arguments[_key2];
1535    }
1536  
1537    return {
1538      type: RESOLVE_SELECT,
1539      storeKey: Object(external_lodash_["isObject"])(storeNameOrDefinition) ? storeNameOrDefinition.name : storeNameOrDefinition,
1540      selectorName,
1541      args
1542    };
1543  }
1544  /**
1545   * Dispatches a control action for triggering a registry dispatch.
1546   *
1547   * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store
1548   * @param {string}             actionName            The name of the action to dispatch
1549   * @param {Array}              args                  Arguments for the dispatch action.
1550   *
1551   * @example
1552   * ```js
1553   * import { controls } from '@wordpress/data-controls';
1554   *
1555   * // Action generator using dispatch
1556   * export function* myAction() {
1557   *   yield controls.dispatch( 'core/edit-post', 'togglePublishSidebar' );
1558   *   // do some other things.
1559   * }
1560   * ```
1561   *
1562   * @return {Object}  The control descriptor.
1563   */
1564  
1565  
1566  function controls_dispatch(storeNameOrDefinition, actionName) {
1567    for (var _len3 = arguments.length, args = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
1568      args[_key3 - 2] = arguments[_key3];
1569    }
1570  
1571    return {
1572      type: DISPATCH,
1573      storeKey: Object(external_lodash_["isObject"])(storeNameOrDefinition) ? storeNameOrDefinition.name : storeNameOrDefinition,
1574      actionName,
1575      args
1576    };
1577  }
1578  
1579  const controls_controls = {
1580    select: controls_select,
1581    resolveSelect: controls_resolveSelect,
1582    dispatch: controls_dispatch
1583  };
1584  const builtinControls = {
1585    [SELECT]: createRegistryControl(registry => _ref => {
1586      let {
1587        storeKey,
1588        selectorName,
1589        args
1590      } = _ref;
1591      return registry.select(storeKey)[selectorName](...args);
1592    }),
1593    [RESOLVE_SELECT]: createRegistryControl(registry => _ref2 => {
1594      let {
1595        storeKey,
1596        selectorName,
1597        args
1598      } = _ref2;
1599      const method = registry.select(storeKey)[selectorName].hasResolver ? 'resolveSelect' : 'select';
1600      return registry[method](storeKey)[selectorName](...args);
1601    }),
1602    [DISPATCH]: createRegistryControl(registry => _ref3 => {
1603      let {
1604        storeKey,
1605        actionName,
1606        args
1607      } = _ref3;
1608      return registry.dispatch(storeKey)[actionName](...args);
1609    })
1610  };
1611  
1612  // EXTERNAL MODULE: ./node_modules/is-promise/index.js
1613  var is_promise = __webpack_require__("JlUD");
1614  var is_promise_default = /*#__PURE__*/__webpack_require__.n(is_promise);
1615  
1616  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/promise-middleware.js
1617  /**
1618   * External dependencies
1619   */
1620  
1621  /**
1622   * Simplest possible promise redux middleware.
1623   *
1624   * @type {import('redux').Middleware}
1625   */
1626  
1627  const promiseMiddleware = () => next => action => {
1628    if (is_promise_default()(action)) {
1629      return action.then(resolvedAction => {
1630        if (resolvedAction) {
1631          return next(resolvedAction);
1632        }
1633      });
1634    }
1635  
1636    return next(action);
1637  };
1638  
1639  /* harmony default export */ var promise_middleware = (promiseMiddleware);
1640  
1641  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/store/name.js
1642  /**
1643   * The identifier for the core/data store.
1644   *
1645   * @type {string}
1646   */
1647  const STORE_NAME = 'core/data';
1648  
1649  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/resolvers-cache-middleware.js
1650  /**
1651   * External dependencies
1652   */
1653  
1654  /**
1655   * Internal dependencies
1656   */
1657  
1658  
1659  /** @typedef {import('./registry').WPDataRegistry} WPDataRegistry */
1660  
1661  /**
1662   * Creates a middleware handling resolvers cache invalidation.
1663   *
1664   * @param {WPDataRegistry} registry   The registry reference for which to create
1665   *                                    the middleware.
1666   * @param {string}         reducerKey The namespace for which to create the
1667   *                                    middleware.
1668   *
1669   * @return {Function} Middleware function.
1670   */
1671  
1672  const createResolversCacheMiddleware = (registry, reducerKey) => () => next => action => {
1673    const resolvers = registry.select(STORE_NAME).getCachedResolvers(reducerKey);
1674    Object.entries(resolvers).forEach(_ref => {
1675      let [selectorName, resolversByArgs] = _ref;
1676      const resolver = Object(external_lodash_["get"])(registry.stores, [reducerKey, 'resolvers', selectorName]);
1677  
1678      if (!resolver || !resolver.shouldInvalidate) {
1679        return;
1680      }
1681  
1682      resolversByArgs.forEach((value, args) => {
1683        // resolversByArgs is the map Map([ args ] => boolean) storing the cache resolution status for a given selector.
1684        // If the value is false it means this resolver has finished its resolution which means we need to invalidate it,
1685        // if it's true it means it's inflight and the invalidation is not necessary.
1686        if (value !== false || !resolver.shouldInvalidate(action, ...args)) {
1687          return;
1688        } // Trigger cache invalidation
1689  
1690  
1691        registry.dispatch(STORE_NAME).invalidateResolution(reducerKey, selectorName, args);
1692      });
1693    });
1694    return next(action);
1695  };
1696  
1697  /* harmony default export */ var resolvers_cache_middleware = (createResolversCacheMiddleware);
1698  
1699  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/thunk-middleware.js
1700  function createThunkMiddleware(args) {
1701    return () => next => action => {
1702      if (typeof action === 'function') {
1703        return action(args);
1704      }
1705  
1706      return next(action);
1707    };
1708  }
1709  
1710  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/metadata/utils.js
1711  /**
1712   * Higher-order reducer creator which creates a combined reducer object, keyed
1713   * by a property on the action object.
1714   *
1715   * @template {any} TState
1716   * @template {import('redux').AnyAction} TAction
1717   *
1718   * @param {string} actionProperty Action property by which to key object.
1719   *
1720   * @return {(reducer: import('redux').Reducer<TState, TAction>) => import('redux').Reducer<Record<string, TState>, TAction>} Higher-order reducer.
1721   */
1722  const onSubKey = actionProperty => reducer => function () {
1723    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] :
1724    /** @type {Record<string, TState>} */
1725    {};
1726    let action = arguments.length > 1 ? arguments[1] : undefined;
1727    // Retrieve subkey from action. Do not track if undefined; useful for cases
1728    // where reducer is scoped by action shape.
1729  
1730    /** @type {keyof state} */
1731  
1732    /* eslint-enable jsdoc/no-undefined-types */
1733    const key = action[actionProperty];
1734  
1735    if (key === undefined) {
1736      return state;
1737    } // Avoid updating state if unchanged. Note that this also accounts for a
1738    // reducer which returns undefined on a key which is not yet tracked.
1739  
1740  
1741    const nextKeyState = reducer(state[key], action);
1742  
1743    if (nextKeyState === state[key]) {
1744      return state;
1745    }
1746  
1747    return { ...state,
1748      [key]: nextKeyState
1749    };
1750  };
1751  
1752  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/metadata/reducer.js
1753  /**
1754   * External dependencies
1755   */
1756  
1757  
1758  
1759  /**
1760   * Internal dependencies
1761   */
1762  
1763  
1764  /**
1765   * Reducer function returning next state for selector resolution of
1766   * subkeys, object form:
1767   *
1768   *  selectorName -> EquivalentKeyMap<Array,boolean>
1769   */
1770  const subKeysIsResolved = onSubKey('selectorName')(function () {
1771    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new equivalent_key_map_default.a();
1772    let action = arguments.length > 1 ? arguments[1] : undefined;
1773  
1774    switch (action.type) {
1775      case 'START_RESOLUTION':
1776      case 'FINISH_RESOLUTION':
1777        {
1778          const isStarting = action.type === 'START_RESOLUTION';
1779          const nextState = new equivalent_key_map_default.a(state);
1780          nextState.set(action.args, isStarting);
1781          return nextState;
1782        }
1783  
1784      case 'START_RESOLUTIONS':
1785      case 'FINISH_RESOLUTIONS':
1786        {
1787          const isStarting = action.type === 'START_RESOLUTIONS';
1788          const nextState = new equivalent_key_map_default.a(state);
1789  
1790          for (const resolutionArgs of action.args) {
1791            nextState.set(resolutionArgs, isStarting);
1792          }
1793  
1794          return nextState;
1795        }
1796  
1797      case 'INVALIDATE_RESOLUTION':
1798        {
1799          const nextState = new equivalent_key_map_default.a(state);
1800          nextState.delete(action.args);
1801          return nextState;
1802        }
1803    }
1804  
1805    return state;
1806  });
1807  /**
1808   * Reducer function returning next state for selector resolution, object form:
1809   *
1810   *   selectorName -> EquivalentKeyMap<Array, boolean>
1811   *
1812   * @param  state  Current state.
1813   * @param  action Dispatched action.
1814   *
1815   * @return Next state.
1816   */
1817  
1818  const isResolved = function () {
1819    let state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
1820    let action = arguments.length > 1 ? arguments[1] : undefined;
1821  
1822    switch (action.type) {
1823      case 'INVALIDATE_RESOLUTION_FOR_STORE':
1824        return {};
1825  
1826      case 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR':
1827        return Object(external_lodash_["has"])(state, [action.selectorName]) ? Object(external_lodash_["omit"])(state, [action.selectorName]) : state;
1828  
1829      case 'START_RESOLUTION':
1830      case 'FINISH_RESOLUTION':
1831      case 'START_RESOLUTIONS':
1832      case 'FINISH_RESOLUTIONS':
1833      case 'INVALIDATE_RESOLUTION':
1834        return subKeysIsResolved(state, action);
1835    }
1836  
1837    return state;
1838  };
1839  
1840  /* harmony default export */ var metadata_reducer = (isResolved);
1841  
1842  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js
1843  /**
1844   * External dependencies
1845   */
1846  
1847  /** @typedef {Record<string, import('./reducer').State>} State */
1848  
1849  /**
1850   * Returns the raw `isResolving` value for a given selector name,
1851   * and arguments set. May be undefined if the selector has never been resolved
1852   * or not resolved for the given set of arguments, otherwise true or false for
1853   * resolution started and completed respectively.
1854   *
1855   * @param {State}     state        Data state.
1856   * @param {string}    selectorName Selector name.
1857   * @param {unknown[]} args         Arguments passed to selector.
1858   *
1859   * @return {boolean | undefined} isResolving value.
1860   */
1861  
1862  function getIsResolving(state, selectorName, args) {
1863    const map = Object(external_lodash_["get"])(state, [selectorName]);
1864  
1865    if (!map) {
1866      return undefined;
1867    }
1868  
1869    return map.get(args);
1870  }
1871  /**
1872   * Returns true if resolution has already been triggered for a given
1873   * selector name, and arguments set.
1874   *
1875   * @param {State}     state        Data state.
1876   * @param {string}    selectorName Selector name.
1877   * @param {unknown[]} [args]       Arguments passed to selector (default `[]`).
1878   *
1879   * @return {boolean} Whether resolution has been triggered.
1880   */
1881  
1882  function hasStartedResolution(state, selectorName) {
1883    let args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
1884    return getIsResolving(state, selectorName, args) !== undefined;
1885  }
1886  /**
1887   * Returns true if resolution has completed for a given selector
1888   * name, and arguments set.
1889   *
1890   * @param {State}     state        Data state.
1891   * @param {string}    selectorName Selector name.
1892   * @param {unknown[]} [args]       Arguments passed to selector.
1893   *
1894   * @return {boolean} Whether resolution has completed.
1895   */
1896  
1897  function hasFinishedResolution(state, selectorName) {
1898    let args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
1899    return getIsResolving(state, selectorName, args) === false;
1900  }
1901  /**
1902   * Returns true if resolution has been triggered but has not yet completed for
1903   * a given selector name, and arguments set.
1904   *
1905   * @param {State}     state        Data state.
1906   * @param {string}    selectorName Selector name.
1907   * @param {unknown[]} [args]       Arguments passed to selector.
1908   *
1909   * @return {boolean} Whether resolution is in progress.
1910   */
1911  
1912  function isResolving(state, selectorName) {
1913    let args = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
1914    return getIsResolving(state, selectorName, args) === true;
1915  }
1916  /**
1917   * Returns the list of the cached resolvers.
1918   *
1919   * @param {State} state Data state.
1920   *
1921   * @return {State} Resolvers mapped by args and selectorName.
1922   */
1923  
1924  function getCachedResolvers(state) {
1925    return state;
1926  }
1927  
1928  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js
1929  /**
1930   * Returns an action object used in signalling that selector resolution has
1931   * started.
1932   *
1933   * @param {string}    selectorName Name of selector for which resolver triggered.
1934   * @param {unknown[]} args         Arguments to associate for uniqueness.
1935   *
1936   * @return {{ type: 'START_RESOLUTION', selectorName: string, args: unknown[] }} Action object.
1937   */
1938  function startResolution(selectorName, args) {
1939    return {
1940      type: 'START_RESOLUTION',
1941      selectorName,
1942      args
1943    };
1944  }
1945  /**
1946   * Returns an action object used in signalling that selector resolution has
1947   * completed.
1948   *
1949   * @param {string}    selectorName Name of selector for which resolver triggered.
1950   * @param {unknown[]} args         Arguments to associate for uniqueness.
1951   *
1952   * @return {{ type: 'FINISH_RESOLUTION', selectorName: string, args: unknown[] }} Action object.
1953   */
1954  
1955  function finishResolution(selectorName, args) {
1956    return {
1957      type: 'FINISH_RESOLUTION',
1958      selectorName,
1959      args
1960    };
1961  }
1962  /**
1963   * Returns an action object used in signalling that a batch of selector resolutions has
1964   * started.
1965   *
1966   * @param {string}    selectorName Name of selector for which resolver triggered.
1967   * @param {unknown[]} args         Array of arguments to associate for uniqueness, each item
1968   *                                 is associated to a resolution.
1969   *
1970   * @return {{ type: 'START_RESOLUTIONS', selectorName: string, args: unknown[] }} Action object.
1971   */
1972  
1973  function startResolutions(selectorName, args) {
1974    return {
1975      type: 'START_RESOLUTIONS',
1976      selectorName,
1977      args
1978    };
1979  }
1980  /**
1981   * Returns an action object used in signalling that a batch of selector resolutions has
1982   * completed.
1983   *
1984   * @param {string}    selectorName Name of selector for which resolver triggered.
1985   * @param {unknown[]} args         Array of arguments to associate for uniqueness, each item
1986   *                                 is associated to a resolution.
1987   *
1988   * @return {{ type: 'FINISH_RESOLUTIONS', selectorName: string, args: unknown[] }} Action object.
1989   */
1990  
1991  function finishResolutions(selectorName, args) {
1992    return {
1993      type: 'FINISH_RESOLUTIONS',
1994      selectorName,
1995      args
1996    };
1997  }
1998  /**
1999   * Returns an action object used in signalling that we should invalidate the resolution cache.
2000   *
2001   * @param {string}    selectorName Name of selector for which resolver should be invalidated.
2002   * @param {unknown[]} args         Arguments to associate for uniqueness.
2003   *
2004   * @return {{ type: 'INVALIDATE_RESOLUTION', selectorName: string, args: any[] }} Action object.
2005   */
2006  
2007  function invalidateResolution(selectorName, args) {
2008    return {
2009      type: 'INVALIDATE_RESOLUTION',
2010      selectorName,
2011      args
2012    };
2013  }
2014  /**
2015   * Returns an action object used in signalling that the resolution
2016   * should be invalidated.
2017   *
2018   * @return {{ type: 'INVALIDATE_RESOLUTION_FOR_STORE' }} Action object.
2019   */
2020  
2021  function invalidateResolutionForStore() {
2022    return {
2023      type: 'INVALIDATE_RESOLUTION_FOR_STORE'
2024    };
2025  }
2026  /**
2027   * Returns an action object used in signalling that the resolution cache for a
2028   * given selectorName should be invalidated.
2029   *
2030   * @param {string} selectorName Name of selector for which all resolvers should
2031   *                              be invalidated.
2032   *
2033   * @return  {{ type: 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR', selectorName: string }} Action object.
2034   */
2035  
2036  function invalidateResolutionForStoreSelector(selectorName) {
2037    return {
2038      type: 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR',
2039      selectorName
2040    };
2041  }
2042  
2043  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/redux-store/index.js
2044  /**
2045   * External dependencies
2046   */
2047  
2048  
2049  
2050  
2051  /**
2052   * WordPress dependencies
2053   */
2054  
2055  
2056  /**
2057   * Internal dependencies
2058   */
2059  
2060  
2061  
2062  
2063  
2064  
2065  
2066  
2067  /** @typedef {import('../types').WPDataRegistry} WPDataRegistry */
2068  
2069  /** @typedef {import('../types').WPDataStore} WPDataStore */
2070  
2071  /** @typedef {import('../types').WPDataReduxStoreConfig} WPDataReduxStoreConfig */
2072  
2073  const trimUndefinedValues = array => {
2074    const result = [...array];
2075  
2076    for (let i = result.length - 1; i >= 0; i--) {
2077      if (result[i] === undefined) {
2078        result.splice(i, 1);
2079      }
2080    }
2081  
2082    return result;
2083  };
2084  /**
2085   * Create a cache to track whether resolvers started running or not.
2086   *
2087   * @return {Object} Resolvers Cache.
2088   */
2089  
2090  
2091  function createResolversCache() {
2092    const cache = {};
2093    return {
2094      isRunning(selectorName, args) {
2095        return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args));
2096      },
2097  
2098      clear(selectorName, args) {
2099        if (cache[selectorName]) {
2100          cache[selectorName].delete(trimUndefinedValues(args));
2101        }
2102      },
2103  
2104      markAsRunning(selectorName, args) {
2105        if (!cache[selectorName]) {
2106          cache[selectorName] = new equivalent_key_map_default.a();
2107        }
2108  
2109        cache[selectorName].set(trimUndefinedValues(args), true);
2110      }
2111  
2112    };
2113  }
2114  /**
2115   * Creates a data store definition for the provided Redux store options containing
2116   * properties describing reducer, actions, selectors, controls and resolvers.
2117   *
2118   * @example
2119   * ```js
2120   * import { createReduxStore } from '@wordpress/data';
2121   *
2122   * const store = createReduxStore( 'demo', {
2123   *     reducer: ( state = 'OK' ) => state,
2124   *     selectors: {
2125   *         getValue: ( state ) => state,
2126   *     },
2127   * } );
2128   * ```
2129   *
2130   * @param {string}                 key     Unique namespace identifier.
2131   * @param {WPDataReduxStoreConfig} options Registered store options, with properties
2132   *                                         describing reducer, actions, selectors,
2133   *                                         and resolvers.
2134   *
2135   * @return {WPDataStore} Store Object.
2136   */
2137  
2138  
2139  function createReduxStore(key, options) {
2140    return {
2141      name: key,
2142      instantiate: registry => {
2143        const reducer = options.reducer;
2144        const thunkArgs = {
2145          registry,
2146  
2147          get dispatch() {
2148            return Object.assign(action => store.dispatch(action), getActions());
2149          },
2150  
2151          get select() {
2152            return Object.assign(selector => selector(store.__unstableOriginalGetState()), getSelectors());
2153          },
2154  
2155          get resolveSelect() {
2156            return getResolveSelectors();
2157          }
2158  
2159        };
2160        const store = instantiateReduxStore(key, options, registry, thunkArgs);
2161        const resolversCache = createResolversCache();
2162        let resolvers;
2163        const actions = mapActions({ ...actions_namespaceObject,
2164          ...options.actions
2165        }, store);
2166        let selectors = mapSelectors({ ...Object(external_lodash_["mapValues"])(selectors_namespaceObject, selector => function (state) {
2167            for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
2168              args[_key - 1] = arguments[_key];
2169            }
2170  
2171            return selector(state.metadata, ...args);
2172          }),
2173          ...Object(external_lodash_["mapValues"])(options.selectors, selector => {
2174            if (selector.isRegistrySelector) {
2175              selector.registry = registry;
2176            }
2177  
2178            return function (state) {
2179              for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
2180                args[_key2 - 1] = arguments[_key2];
2181              }
2182  
2183              return selector(state.root, ...args);
2184            };
2185          })
2186        }, store);
2187  
2188        if (options.resolvers) {
2189          const result = mapResolvers(options.resolvers, selectors, store, resolversCache);
2190          resolvers = result.resolvers;
2191          selectors = result.selectors;
2192        }
2193  
2194        const resolveSelectors = mapResolveSelectors(selectors, store);
2195  
2196        const getSelectors = () => selectors;
2197  
2198        const getActions = () => actions;
2199  
2200        const getResolveSelectors = () => resolveSelectors; // We have some modules monkey-patching the store object
2201        // It's wrong to do so but until we refactor all of our effects to controls
2202        // We need to keep the same "store" instance here.
2203  
2204  
2205        store.__unstableOriginalGetState = store.getState;
2206  
2207        store.getState = () => store.__unstableOriginalGetState().root; // Customize subscribe behavior to call listeners only on effective change,
2208        // not on every dispatch.
2209  
2210  
2211        const subscribe = store && (listener => {
2212          let lastState = store.__unstableOriginalGetState();
2213  
2214          return store.subscribe(() => {
2215            const state = store.__unstableOriginalGetState();
2216  
2217            const hasChanged = state !== lastState;
2218            lastState = state;
2219  
2220            if (hasChanged) {
2221              listener();
2222            }
2223          });
2224        }); // This can be simplified to just { subscribe, getSelectors, getActions }
2225        // Once we remove the use function.
2226  
2227  
2228        return {
2229          reducer,
2230          store,
2231          actions,
2232          selectors,
2233          resolvers,
2234          getSelectors,
2235          getResolveSelectors,
2236          getActions,
2237          subscribe
2238        };
2239      }
2240    };
2241  }
2242  /**
2243   * Creates a redux store for a namespace.
2244   *
2245   * @param {string}         key       Unique namespace identifier.
2246   * @param {Object}         options   Registered store options, with properties
2247   *                                   describing reducer, actions, selectors,
2248   *                                   and resolvers.
2249   * @param {WPDataRegistry} registry  Registry reference.
2250   * @param {Object}         thunkArgs Argument object for the thunk middleware.
2251   * @return {Object} Newly created redux store.
2252   */
2253  
2254  function instantiateReduxStore(key, options, registry, thunkArgs) {
2255    const controls = { ...options.controls,
2256      ...builtinControls
2257    };
2258    const normalizedControls = Object(external_lodash_["mapValues"])(controls, control => control.isRegistryControl ? control(registry) : control);
2259    const middlewares = [resolvers_cache_middleware(registry, key), promise_middleware, external_wp_reduxRoutine_default()(normalizedControls)];
2260  
2261    if (options.__experimentalUseThunks) {
2262      middlewares.push(createThunkMiddleware(thunkArgs));
2263    }
2264  
2265    const enhancers = [applyMiddleware(...middlewares)];
2266  
2267    if (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__) {
2268      enhancers.push(window.__REDUX_DEVTOOLS_EXTENSION__({
2269        name: key,
2270        instanceId: key
2271      }));
2272    }
2273  
2274    const {
2275      reducer,
2276      initialState
2277    } = options;
2278    const enhancedReducer = turbo_combine_reducers_default()({
2279      metadata: metadata_reducer,
2280      root: reducer
2281    });
2282    return redux_createStore(enhancedReducer, {
2283      root: initialState
2284    }, Object(external_lodash_["flowRight"])(enhancers));
2285  }
2286  /**
2287   * Maps selectors to a store.
2288   *
2289   * @param {Object} selectors Selectors to register. Keys will be used as the
2290   *                           public facing API. Selectors will get passed the
2291   *                           state as first argument.
2292   * @param {Object} store     The store to which the selectors should be mapped.
2293   * @return {Object} Selectors mapped to the provided store.
2294   */
2295  
2296  
2297  function mapSelectors(selectors, store) {
2298    const createStateSelector = registrySelector => {
2299      const selector = function runSelector() {
2300        // This function is an optimized implementation of:
2301        //
2302        //   selector( store.getState(), ...arguments )
2303        //
2304        // Where the above would incur an `Array#concat` in its application,
2305        // the logic here instead efficiently constructs an arguments array via
2306        // direct assignment.
2307        const argsLength = arguments.length;
2308        const args = new Array(argsLength + 1);
2309        args[0] = store.__unstableOriginalGetState();
2310  
2311        for (let i = 0; i < argsLength; i++) {
2312          args[i + 1] = arguments[i];
2313        }
2314  
2315        return registrySelector(...args);
2316      };
2317  
2318      selector.hasResolver = false;
2319      return selector;
2320    };
2321  
2322    return Object(external_lodash_["mapValues"])(selectors, createStateSelector);
2323  }
2324  /**
2325   * Maps actions to dispatch from a given store.
2326   *
2327   * @param {Object} actions Actions to register.
2328   * @param {Object} store   The redux store to which the actions should be mapped.
2329   *
2330   * @return {Object} Actions mapped to the redux store provided.
2331   */
2332  
2333  
2334  function mapActions(actions, store) {
2335    const createBoundAction = action => function () {
2336      return Promise.resolve(store.dispatch(action(...arguments)));
2337    };
2338  
2339    return Object(external_lodash_["mapValues"])(actions, createBoundAction);
2340  }
2341  /**
2342   * Maps selectors to functions that return a resolution promise for them
2343   *
2344   * @param {Object} selectors Selectors to map.
2345   * @param {Object} store     The redux store the selectors select from.
2346   *
2347   * @return {Object} Selectors mapped to their resolution functions.
2348   */
2349  
2350  
2351  function mapResolveSelectors(selectors, store) {
2352    return Object(external_lodash_["mapValues"])(Object(external_lodash_["omit"])(selectors, ['getIsResolving', 'hasStartedResolution', 'hasFinishedResolution', 'isResolving', 'getCachedResolvers']), (selector, selectorName) => function () {
2353      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
2354        args[_key3] = arguments[_key3];
2355      }
2356  
2357      return new Promise(resolve => {
2358        const hasFinished = () => selectors.hasFinishedResolution(selectorName, args);
2359  
2360        const getResult = () => selector.apply(null, args); // trigger the selector (to trigger the resolver)
2361  
2362  
2363        const result = getResult();
2364  
2365        if (hasFinished()) {
2366          return resolve(result);
2367        }
2368  
2369        const unsubscribe = store.subscribe(() => {
2370          if (hasFinished()) {
2371            unsubscribe();
2372            resolve(getResult());
2373          }
2374        });
2375      });
2376    });
2377  }
2378  /**
2379   * Returns resolvers with matched selectors for a given namespace.
2380   * Resolvers are side effects invoked once per argument set of a given selector call,
2381   * used in ensuring that the data needs for the selector are satisfied.
2382   *
2383   * @param {Object} resolvers      Resolvers to register.
2384   * @param {Object} selectors      The current selectors to be modified.
2385   * @param {Object} store          The redux store to which the resolvers should be mapped.
2386   * @param {Object} resolversCache Resolvers Cache.
2387   */
2388  
2389  
2390  function mapResolvers(resolvers, selectors, store, resolversCache) {
2391    // The `resolver` can be either a function that does the resolution, or, in more advanced
2392    // cases, an object with a `fullfill` method and other optional methods like `isFulfilled`.
2393    // Here we normalize the `resolver` function to an object with `fulfill` method.
2394    const mappedResolvers = Object(external_lodash_["mapValues"])(resolvers, resolver => {
2395      if (resolver.fulfill) {
2396        return resolver;
2397      }
2398  
2399      return { ...resolver,
2400        // copy the enumerable properties of the resolver function
2401        fulfill: resolver // add the fulfill method
2402  
2403      };
2404    });
2405  
2406    const mapSelector = (selector, selectorName) => {
2407      const resolver = resolvers[selectorName];
2408  
2409      if (!resolver) {
2410        selector.hasResolver = false;
2411        return selector;
2412      }
2413  
2414      const selectorResolver = function () {
2415        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
2416          args[_key4] = arguments[_key4];
2417        }
2418  
2419        async function fulfillSelector() {
2420          const state = store.getState();
2421  
2422          if (resolversCache.isRunning(selectorName, args) || typeof resolver.isFulfilled === 'function' && resolver.isFulfilled(state, ...args)) {
2423            return;
2424          }
2425  
2426          const {
2427            metadata
2428          } = store.__unstableOriginalGetState();
2429  
2430          if (hasStartedResolution(metadata, selectorName, args)) {
2431            return;
2432          }
2433  
2434          resolversCache.markAsRunning(selectorName, args);
2435          setTimeout(async () => {
2436            resolversCache.clear(selectorName, args);
2437            store.dispatch(startResolution(selectorName, args));
2438            await fulfillResolver(store, mappedResolvers, selectorName, ...args);
2439            store.dispatch(finishResolution(selectorName, args));
2440          });
2441        }
2442  
2443        fulfillSelector(...args);
2444        return selector(...args);
2445      };
2446  
2447      selectorResolver.hasResolver = true;
2448      return selectorResolver;
2449    };
2450  
2451    return {
2452      resolvers: mappedResolvers,
2453      selectors: Object(external_lodash_["mapValues"])(selectors, mapSelector)
2454    };
2455  }
2456  /**
2457   * Calls a resolver given arguments
2458   *
2459   * @param {Object} store        Store reference, for fulfilling via resolvers
2460   * @param {Object} resolvers    Store Resolvers
2461   * @param {string} selectorName Selector name to fulfill.
2462   * @param {Array}  args         Selector Arguments.
2463   */
2464  
2465  
2466  async function fulfillResolver(store, resolvers, selectorName) {
2467    const resolver = Object(external_lodash_["get"])(resolvers, [selectorName]);
2468  
2469    if (!resolver) {
2470      return;
2471    }
2472  
2473    for (var _len5 = arguments.length, args = new Array(_len5 > 3 ? _len5 - 3 : 0), _key5 = 3; _key5 < _len5; _key5++) {
2474      args[_key5 - 3] = arguments[_key5];
2475    }
2476  
2477    const action = resolver.fulfill(...args);
2478  
2479    if (action) {
2480      await store.dispatch(action);
2481    }
2482  }
2483  
2484  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/store/index.js
2485  function createCoreDataStore(registry) {
2486    const getCoreDataSelector = selectorName => function (key) {
2487      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
2488        args[_key - 1] = arguments[_key];
2489      }
2490  
2491      return registry.select(key)[selectorName](...args);
2492    };
2493  
2494    const getCoreDataAction = actionName => function (key) {
2495      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
2496        args[_key2 - 1] = arguments[_key2];
2497      }
2498  
2499      return registry.dispatch(key)[actionName](...args);
2500    };
2501  
2502    return {
2503      getSelectors() {
2504        return ['getIsResolving', 'hasStartedResolution', 'hasFinishedResolution', 'isResolving', 'getCachedResolvers'].reduce((memo, selectorName) => ({ ...memo,
2505          [selectorName]: getCoreDataSelector(selectorName)
2506        }), {});
2507      },
2508  
2509      getActions() {
2510        return ['startResolution', 'finishResolution', 'invalidateResolution', 'invalidateResolutionForStore', 'invalidateResolutionForStoreSelector'].reduce((memo, actionName) => ({ ...memo,
2511          [actionName]: getCoreDataAction(actionName)
2512        }), {});
2513      },
2514  
2515      subscribe() {
2516        // There's no reasons to trigger any listener when we subscribe to this store
2517        // because there's no state stored in this store that need to retrigger selectors
2518        // if a change happens, the corresponding store where the tracking stated live
2519        // would have already triggered a "subscribe" call.
2520        return () => {};
2521      }
2522  
2523    };
2524  }
2525  
2526  /* harmony default export */ var build_module_store = (createCoreDataStore);
2527  
2528  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/utils/emitter.js
2529  /**
2530   * Create an event emitter.
2531   *
2532   * @return {import("../types").WPDataEmitter} Emitter.
2533   */
2534  function createEmitter() {
2535    let isPaused = false;
2536    let isPending = false;
2537    const listeners = new Set();
2538  
2539    const notifyListeners = () => // We use Array.from to clone the listeners Set
2540    // This ensures that we don't run a listener
2541    // that was added as a response to another listener.
2542    Array.from(listeners).forEach(listener => listener());
2543  
2544    return {
2545      get isPaused() {
2546        return isPaused;
2547      },
2548  
2549      subscribe(listener) {
2550        listeners.add(listener);
2551        return () => listeners.delete(listener);
2552      },
2553  
2554      pause() {
2555        isPaused = true;
2556      },
2557  
2558      resume() {
2559        isPaused = false;
2560  
2561        if (isPending) {
2562          isPending = false;
2563          notifyListeners();
2564        }
2565      },
2566  
2567      emit() {
2568        if (isPaused) {
2569          isPending = true;
2570          return;
2571        }
2572  
2573        notifyListeners();
2574      }
2575  
2576    };
2577  }
2578  
2579  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/registry.js
2580  /**
2581   * External dependencies
2582   */
2583  
2584  /**
2585   * Internal dependencies
2586   */
2587  
2588  
2589  
2590  
2591  
2592  /** @typedef {import('./types').WPDataStore} WPDataStore */
2593  
2594  /**
2595   * @typedef {Object} WPDataRegistry An isolated orchestrator of store registrations.
2596   *
2597   * @property {Function} registerGenericStore Given a namespace key and settings
2598   *                                           object, registers a new generic
2599   *                                           store.
2600   * @property {Function} registerStore        Given a namespace key and settings
2601   *                                           object, registers a new namespace
2602   *                                           store.
2603   * @property {Function} subscribe            Given a function callback, invokes
2604   *                                           the callback on any change to state
2605   *                                           within any registered store.
2606   * @property {Function} select               Given a namespace key, returns an
2607   *                                           object of the  store's registered
2608   *                                           selectors.
2609   * @property {Function} dispatch             Given a namespace key, returns an
2610   *                                           object of the store's registered
2611   *                                           action dispatchers.
2612   */
2613  
2614  /**
2615   * @typedef {Object} WPDataPlugin An object of registry function overrides.
2616   *
2617   * @property {Function} registerStore registers store.
2618   */
2619  
2620  /**
2621   * Creates a new store registry, given an optional object of initial store
2622   * configurations.
2623   *
2624   * @param {Object}  storeConfigs Initial store configurations.
2625   * @param {Object?} parent       Parent registry.
2626   *
2627   * @return {WPDataRegistry} Data registry.
2628   */
2629  
2630  function createRegistry() {
2631    let storeConfigs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2632    let parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
2633    const stores = {};
2634    const emitter = createEmitter();
2635  
2636    const __experimentalListeningStores = new Set();
2637    /**
2638     * Global listener called for each store's update.
2639     */
2640  
2641  
2642    function globalListener() {
2643      emitter.emit();
2644    }
2645    /**
2646     * Subscribe to changes to any data.
2647     *
2648     * @param {Function} listener Listener function.
2649     *
2650     * @return {Function} Unsubscribe function.
2651     */
2652  
2653  
2654    const subscribe = listener => {
2655      return emitter.subscribe(listener);
2656    };
2657    /**
2658     * Calls a selector given the current state and extra arguments.
2659     *
2660     * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store
2661     *                                                   or the store definition.
2662     *
2663     * @return {*} The selector's returned value.
2664     */
2665  
2666  
2667    function select(storeNameOrDefinition) {
2668      const storeName = Object(external_lodash_["isObject"])(storeNameOrDefinition) ? storeNameOrDefinition.name : storeNameOrDefinition;
2669  
2670      __experimentalListeningStores.add(storeName);
2671  
2672      const store = stores[storeName];
2673  
2674      if (store) {
2675        return store.getSelectors();
2676      }
2677  
2678      return parent && parent.select(storeName);
2679    }
2680  
2681    function __experimentalMarkListeningStores(callback, ref) {
2682      __experimentalListeningStores.clear();
2683  
2684      const result = callback.call(this);
2685      ref.current = Array.from(__experimentalListeningStores);
2686      return result;
2687    }
2688    /**
2689     * Given the name of a registered store, returns an object containing the store's
2690     * selectors pre-bound to state so that you only need to supply additional arguments,
2691     * and modified so that they return promises that resolve to their eventual values,
2692     * after any resolvers have ran.
2693     *
2694     * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store
2695     *                                                   or the store definition.
2696     *
2697     * @return {Object} Each key of the object matches the name of a selector.
2698     */
2699  
2700  
2701    function resolveSelect(storeNameOrDefinition) {
2702      const storeName = Object(external_lodash_["isObject"])(storeNameOrDefinition) ? storeNameOrDefinition.name : storeNameOrDefinition;
2703  
2704      __experimentalListeningStores.add(storeName);
2705  
2706      const store = stores[storeName];
2707  
2708      if (store) {
2709        return store.getResolveSelectors();
2710      }
2711  
2712      return parent && parent.resolveSelect(storeName);
2713    }
2714    /**
2715     * Returns the available actions for a part of the state.
2716     *
2717     * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store
2718     *                                                   or the store definition.
2719     *
2720     * @return {*} The action's returned value.
2721     */
2722  
2723  
2724    function dispatch(storeNameOrDefinition) {
2725      const storeName = Object(external_lodash_["isObject"])(storeNameOrDefinition) ? storeNameOrDefinition.name : storeNameOrDefinition;
2726      const store = stores[storeName];
2727  
2728      if (store) {
2729        return store.getActions();
2730      }
2731  
2732      return parent && parent.dispatch(storeName);
2733    } //
2734    // Deprecated
2735    // TODO: Remove this after `use()` is removed.
2736    //
2737  
2738  
2739    function withPlugins(attributes) {
2740      return Object(external_lodash_["mapValues"])(attributes, (attribute, key) => {
2741        if (typeof attribute !== 'function') {
2742          return attribute;
2743        }
2744  
2745        return function () {
2746          return registry[key].apply(null, arguments);
2747        };
2748      });
2749    }
2750    /**
2751     * Registers a generic store.
2752     *
2753     * @param {string} key    Store registry key.
2754     * @param {Object} config Configuration (getSelectors, getActions, subscribe).
2755     */
2756  
2757  
2758    function registerGenericStore(key, config) {
2759      if (typeof config.getSelectors !== 'function') {
2760        throw new TypeError('config.getSelectors must be a function');
2761      }
2762  
2763      if (typeof config.getActions !== 'function') {
2764        throw new TypeError('config.getActions must be a function');
2765      }
2766  
2767      if (typeof config.subscribe !== 'function') {
2768        throw new TypeError('config.subscribe must be a function');
2769      } // Thi emitter is used to keep track of active listeners when the registry
2770      // get paused, that way, when resumed we should be able to call all these
2771      // pending listeners.
2772  
2773  
2774      config.emitter = createEmitter();
2775      const currentSubscribe = config.subscribe;
2776  
2777      config.subscribe = listener => {
2778        const unsubscribeFromStoreEmitter = config.emitter.subscribe(listener);
2779        const unsubscribeFromRootStore = currentSubscribe(() => {
2780          if (config.emitter.isPaused) {
2781            config.emitter.emit();
2782            return;
2783          }
2784  
2785          listener();
2786        });
2787        return () => {
2788          if (unsubscribeFromRootStore) {
2789            unsubscribeFromRootStore();
2790          }
2791  
2792          unsubscribeFromStoreEmitter();
2793        };
2794      };
2795  
2796      stores[key] = config;
2797      config.subscribe(globalListener);
2798    }
2799    /**
2800     * Registers a new store definition.
2801     *
2802     * @param {WPDataStore} store Store definition.
2803     */
2804  
2805  
2806    function register(store) {
2807      registerGenericStore(store.name, store.instantiate(registry));
2808    }
2809    /**
2810     * Subscribe handler to a store.
2811     *
2812     * @param {string[]} storeName The store name.
2813     * @param {Function} handler   The function subscribed to the store.
2814     * @return {Function} A function to unsubscribe the handler.
2815     */
2816  
2817  
2818    function __experimentalSubscribeStore(storeName, handler) {
2819      if (storeName in stores) {
2820        return stores[storeName].subscribe(handler);
2821      } // Trying to access a store that hasn't been registered,
2822      // this is a pattern rarely used but seen in some places.
2823      // We fallback to regular `subscribe` here for backward-compatibility for now.
2824      // See https://github.com/WordPress/gutenberg/pull/27466 for more info.
2825  
2826  
2827      if (!parent) {
2828        return subscribe(handler);
2829      }
2830  
2831      return parent.__experimentalSubscribeStore(storeName, handler);
2832    }
2833  
2834    function batch(callback) {
2835      emitter.pause();
2836      Object(external_lodash_["forEach"])(stores, store => store.emitter.pause());
2837      callback();
2838      emitter.resume();
2839      Object(external_lodash_["forEach"])(stores, store => store.emitter.resume());
2840    }
2841  
2842    let registry = {
2843      batch,
2844      registerGenericStore,
2845      stores,
2846      namespaces: stores,
2847      // TODO: Deprecate/remove this.
2848      subscribe,
2849      select,
2850      resolveSelect,
2851      dispatch,
2852      use,
2853      register,
2854      __experimentalMarkListeningStores,
2855      __experimentalSubscribeStore
2856    };
2857    /**
2858     * Registers a standard `@wordpress/data` store.
2859     *
2860     * @param {string} storeName Unique namespace identifier.
2861     * @param {Object} options   Store description (reducer, actions, selectors, resolvers).
2862     *
2863     * @return {Object} Registered store object.
2864     */
2865  
2866    registry.registerStore = (storeName, options) => {
2867      if (!options.reducer) {
2868        throw new TypeError('Must specify store reducer');
2869      }
2870  
2871      const store = createReduxStore(storeName, options).instantiate(registry);
2872      registerGenericStore(storeName, store);
2873      return store.store;
2874    }; //
2875    // TODO:
2876    // This function will be deprecated as soon as it is no longer internally referenced.
2877    //
2878  
2879  
2880    function use(plugin, options) {
2881      registry = { ...registry,
2882        ...plugin(registry, options)
2883      };
2884      return registry;
2885    }
2886  
2887    registerGenericStore(STORE_NAME, build_module_store(registry));
2888    Object.entries(storeConfigs).forEach(_ref => {
2889      let [name, config] = _ref;
2890      return registry.registerStore(name, config);
2891    });
2892  
2893    if (parent) {
2894      parent.subscribe(globalListener);
2895    }
2896  
2897    return withPlugins(registry);
2898  }
2899  
2900  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/default-registry.js
2901  /**
2902   * Internal dependencies
2903   */
2904  
2905  /* harmony default export */ var default_registry = (createRegistry());
2906  
2907  // EXTERNAL MODULE: external ["wp","deprecated"]
2908  var external_wp_deprecated_ = __webpack_require__("NMb1");
2909  var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_);
2910  
2911  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/controls/index.js
2912  /**
2913   * WordPress dependencies
2914   */
2915  
2916  /* harmony default export */ var plugins_controls = (registry => {
2917    external_wp_deprecated_default()('wp.data.plugins.controls', {
2918      since: '5.4',
2919      hint: 'The controls plugins is now baked-in.'
2920    });
2921    return registry;
2922  });
2923  
2924  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/object.js
2925  let objectStorage;
2926  const storage = {
2927    getItem(key) {
2928      if (!objectStorage || !objectStorage[key]) {
2929        return null;
2930      }
2931  
2932      return objectStorage[key];
2933    },
2934  
2935    setItem(key, value) {
2936      if (!objectStorage) {
2937        storage.clear();
2938      }
2939  
2940      objectStorage[key] = String(value);
2941    },
2942  
2943    clear() {
2944      objectStorage = Object.create(null);
2945    }
2946  
2947  };
2948  /* harmony default export */ var object = (storage);
2949  
2950  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/default.js
2951  /**
2952   * Internal dependencies
2953   */
2954  
2955  let default_storage;
2956  
2957  try {
2958    // Private Browsing in Safari 10 and earlier will throw an error when
2959    // attempting to set into localStorage. The test here is intentional in
2960    // causing a thrown error as condition for using fallback object storage.
2961    default_storage = window.localStorage;
2962    default_storage.setItem('__wpDataTestLocalStorage', '');
2963    default_storage.removeItem('__wpDataTestLocalStorage');
2964  } catch (error) {
2965    default_storage = object;
2966  }
2967  
2968  /* harmony default export */ var storage_default = (default_storage);
2969  
2970  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/persistence/index.js
2971  /**
2972   * External dependencies
2973   */
2974  
2975  /**
2976   * Internal dependencies
2977   */
2978  
2979  
2980  
2981  /** @typedef {import('../../registry').WPDataRegistry} WPDataRegistry */
2982  
2983  /** @typedef {import('../../registry').WPDataPlugin} WPDataPlugin */
2984  
2985  /**
2986   * @typedef {Object} WPDataPersistencePluginOptions Persistence plugin options.
2987   *
2988   * @property {Storage} storage    Persistent storage implementation. This must
2989   *                                at least implement `getItem` and `setItem` of
2990   *                                the Web Storage API.
2991   * @property {string}  storageKey Key on which to set in persistent storage.
2992   *
2993   */
2994  
2995  /**
2996   * Default plugin storage.
2997   *
2998   * @type {Storage}
2999   */
3000  
3001  const DEFAULT_STORAGE = storage_default;
3002  /**
3003   * Default plugin storage key.
3004   *
3005   * @type {string}
3006   */
3007  
3008  const DEFAULT_STORAGE_KEY = 'WP_DATA';
3009  /**
3010   * Higher-order reducer which invokes the original reducer only if state is
3011   * inequal from that of the action's `nextState` property, otherwise returning
3012   * the original state reference.
3013   *
3014   * @param {Function} reducer Original reducer.
3015   *
3016   * @return {Function} Enhanced reducer.
3017   */
3018  
3019  const withLazySameState = reducer => (state, action) => {
3020    if (action.nextState === state) {
3021      return state;
3022    }
3023  
3024    return reducer(state, action);
3025  };
3026  /**
3027   * Creates a persistence interface, exposing getter and setter methods (`get`
3028   * and `set` respectively).
3029   *
3030   * @param {WPDataPersistencePluginOptions} options Plugin options.
3031   *
3032   * @return {Object} Persistence interface.
3033   */
3034  
3035  function createPersistenceInterface(options) {
3036    const {
3037      storage = DEFAULT_STORAGE,
3038      storageKey = DEFAULT_STORAGE_KEY
3039    } = options;
3040    let data;
3041    /**
3042     * Returns the persisted data as an object, defaulting to an empty object.
3043     *
3044     * @return {Object} Persisted data.
3045     */
3046  
3047    function getData() {
3048      if (data === undefined) {
3049        // If unset, getItem is expected to return null. Fall back to
3050        // empty object.
3051        const persisted = storage.getItem(storageKey);
3052  
3053        if (persisted === null) {
3054          data = {};
3055        } else {
3056          try {
3057            data = JSON.parse(persisted);
3058          } catch (error) {
3059            // Similarly, should any error be thrown during parse of
3060            // the string (malformed JSON), fall back to empty object.
3061            data = {};
3062          }
3063        }
3064      }
3065  
3066      return data;
3067    }
3068    /**
3069     * Merges an updated reducer state into the persisted data.
3070     *
3071     * @param {string} key   Key to update.
3072     * @param {*}      value Updated value.
3073     */
3074  
3075  
3076    function setData(key, value) {
3077      data = { ...data,
3078        [key]: value
3079      };
3080      storage.setItem(storageKey, JSON.stringify(data));
3081    }
3082  
3083    return {
3084      get: getData,
3085      set: setData
3086    };
3087  }
3088  /**
3089   * Data plugin to persist store state into a single storage key.
3090   *
3091   * @param {WPDataRegistry}                  registry      Data registry.
3092   * @param {?WPDataPersistencePluginOptions} pluginOptions Plugin options.
3093   *
3094   * @return {WPDataPlugin} Data plugin.
3095   */
3096  
3097  function persistencePlugin(registry, pluginOptions) {
3098    const persistence = createPersistenceInterface(pluginOptions);
3099    /**
3100     * Creates an enhanced store dispatch function, triggering the state of the
3101     * given store name to be persisted when changed.
3102     *
3103     * @param {Function}       getState  Function which returns current state.
3104     * @param {string}         storeName Store name.
3105     * @param {?Array<string>} keys      Optional subset of keys to save.
3106     *
3107     * @return {Function} Enhanced dispatch function.
3108     */
3109  
3110    function createPersistOnChange(getState, storeName, keys) {
3111      let getPersistedState;
3112  
3113      if (Array.isArray(keys)) {
3114        // Given keys, the persisted state should by produced as an object
3115        // of the subset of keys. This implementation uses combineReducers
3116        // to leverage its behavior of returning the same object when none
3117        // of the property values changes. This allows a strict reference
3118        // equality to bypass a persistence set on an unchanging state.
3119        const reducers = keys.reduce((accumulator, key) => Object.assign(accumulator, {
3120          [key]: (state, action) => action.nextState[key]
3121        }), {});
3122        getPersistedState = withLazySameState(turbo_combine_reducers_default()(reducers));
3123      } else {
3124        getPersistedState = (state, action) => action.nextState;
3125      }
3126  
3127      let lastState = getPersistedState(undefined, {
3128        nextState: getState()
3129      });
3130      return () => {
3131        const state = getPersistedState(lastState, {
3132          nextState: getState()
3133        });
3134  
3135        if (state !== lastState) {
3136          persistence.set(storeName, state);
3137          lastState = state;
3138        }
3139      };
3140    }
3141  
3142    return {
3143      registerStore(storeName, options) {
3144        if (!options.persist) {
3145          return registry.registerStore(storeName, options);
3146        } // Load from persistence to use as initial state.
3147  
3148  
3149        const persistedState = persistence.get()[storeName];
3150  
3151        if (persistedState !== undefined) {
3152          let initialState = options.reducer(options.initialState, {
3153            type: '@@WP/PERSISTENCE_RESTORE'
3154          });
3155  
3156          if (Object(external_lodash_["isPlainObject"])(initialState) && Object(external_lodash_["isPlainObject"])(persistedState)) {
3157            // If state is an object, ensure that:
3158            // - Other keys are left intact when persisting only a
3159            //   subset of keys.
3160            // - New keys in what would otherwise be used as initial
3161            //   state are deeply merged as base for persisted value.
3162            initialState = Object(external_lodash_["merge"])({}, initialState, persistedState);
3163          } else {
3164            // If there is a mismatch in object-likeness of default
3165            // initial or persisted state, defer to persisted value.
3166            initialState = persistedState;
3167          }
3168  
3169          options = { ...options,
3170            initialState
3171          };
3172        }
3173  
3174        const store = registry.registerStore(storeName, options);
3175        store.subscribe(createPersistOnChange(store.getState, storeName, options.persist));
3176        return store;
3177      }
3178  
3179    };
3180  }
3181  /**
3182   * Move the 'features' object in local storage from the sourceStoreName to the
3183   * interface store.
3184   *
3185   * @param {Object} persistence     The persistence interface.
3186   * @param {string} sourceStoreName The name of the store that has persisted
3187   *                                 preferences to migrate to the interface
3188   *                                 package.
3189   */
3190  
3191  
3192  function migrateFeaturePreferencesToInterfaceStore(persistence, sourceStoreName) {
3193    var _state$sourceStoreNam;
3194  
3195    const interfaceStoreName = 'core/interface';
3196    const state = persistence.get();
3197    const sourcePreferences = (_state$sourceStoreNam = state[sourceStoreName]) === null || _state$sourceStoreNam === void 0 ? void 0 : _state$sourceStoreNam.preferences;
3198    const sourceFeatures = sourcePreferences === null || sourcePreferences === void 0 ? void 0 : sourcePreferences.features;
3199  
3200    if (sourceFeatures) {
3201      var _state$interfaceStore, _state$interfaceStore2;
3202  
3203      const targetFeatures = (_state$interfaceStore = state[interfaceStoreName]) === null || _state$interfaceStore === void 0 ? void 0 : (_state$interfaceStore2 = _state$interfaceStore.preferences) === null || _state$interfaceStore2 === void 0 ? void 0 : _state$interfaceStore2.features; // Avoid migrating features again if they've previously been migrated.
3204  
3205      if (!(targetFeatures !== null && targetFeatures !== void 0 && targetFeatures[sourceStoreName])) {
3206        // Set the feature values in the interface store, the features
3207        // object is keyed by 'scope', which matches the store name for
3208        // the source.
3209        persistence.set(interfaceStoreName, {
3210          preferences: {
3211            features: { ...targetFeatures,
3212              [sourceStoreName]: sourceFeatures
3213            }
3214          }
3215        }); // Remove feature preferences from the source.
3216  
3217        persistence.set(sourceStoreName, {
3218          preferences: { ...sourcePreferences,
3219            features: undefined
3220          }
3221        });
3222      }
3223    }
3224  }
3225  /**
3226   * Deprecated: Remove this function and the code in WordPress Core that calls
3227   * it once WordPress 6.0 is released.
3228   */
3229  
3230  persistencePlugin.__unstableMigrate = pluginOptions => {
3231    const persistence = createPersistenceInterface(pluginOptions);
3232    migrateFeaturePreferencesToInterfaceStore(persistence, 'core/edit-widgets');
3233    migrateFeaturePreferencesToInterfaceStore(persistence, 'core/customize-widgets');
3234    migrateFeaturePreferencesToInterfaceStore(persistence, 'core/edit-post');
3235  };
3236  
3237  /* harmony default export */ var plugins_persistence = (persistencePlugin);
3238  
3239  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/plugins/index.js
3240  
3241  
3242  
3243  // EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
3244  var esm_extends = __webpack_require__("wx14");
3245  
3246  // EXTERNAL MODULE: external ["wp","element"]
3247  var external_wp_element_ = __webpack_require__("GRId");
3248  
3249  // EXTERNAL MODULE: external ["wp","compose"]
3250  var external_wp_compose_ = __webpack_require__("K9lf");
3251  
3252  // EXTERNAL MODULE: ./node_modules/use-memo-one/dist/use-memo-one.esm.js
3253  var use_memo_one_esm = __webpack_require__("mHlH");
3254  
3255  // EXTERNAL MODULE: external ["wp","priorityQueue"]
3256  var external_wp_priorityQueue_ = __webpack_require__("XI5e");
3257  
3258  // EXTERNAL MODULE: external ["wp","isShallowEqual"]
3259  var external_wp_isShallowEqual_ = __webpack_require__("rl8x");
3260  var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_);
3261  
3262  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/registry-provider/context.js
3263  /**
3264   * WordPress dependencies
3265   */
3266  
3267  /**
3268   * Internal dependencies
3269   */
3270  
3271  
3272  const Context = Object(external_wp_element_["createContext"])(default_registry);
3273  const {
3274    Consumer,
3275    Provider
3276  } = Context;
3277  /**
3278   * A custom react Context consumer exposing the provided `registry` to
3279   * children components. Used along with the RegistryProvider.
3280   *
3281   * You can read more about the react context api here:
3282   * https://reactjs.org/docs/context.html#contextprovider
3283   *
3284   * @example
3285   * ```js
3286   * import {
3287   *   RegistryProvider,
3288   *   RegistryConsumer,
3289   *   createRegistry
3290   * } from '@wordpress/data';
3291   *
3292   * const registry = createRegistry( {} );
3293   *
3294   * const App = ( { props } ) => {
3295   *   return <RegistryProvider value={ registry }>
3296   *     <div>Hello There</div>
3297   *     <RegistryConsumer>
3298   *       { ( registry ) => (
3299   *         <ComponentUsingRegistry
3300   *                 { ...props }
3301   *               registry={ registry }
3302   *       ) }
3303   *     </RegistryConsumer>
3304   *   </RegistryProvider>
3305   * }
3306   * ```
3307   */
3308  
3309  const RegistryConsumer = Consumer;
3310  /**
3311   * A custom Context provider for exposing the provided `registry` to children
3312   * components via a consumer.
3313   *
3314   * See <a name="#RegistryConsumer">RegistryConsumer</a> documentation for
3315   * example.
3316   */
3317  
3318  /* harmony default export */ var context = (Provider);
3319  
3320  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/registry-provider/use-registry.js
3321  /**
3322   * WordPress dependencies
3323   */
3324  
3325  /**
3326   * Internal dependencies
3327   */
3328  
3329  
3330  /**
3331   * A custom react hook exposing the registry context for use.
3332   *
3333   * This exposes the `registry` value provided via the
3334   * <a href="#RegistryProvider">Registry Provider</a> to a component implementing
3335   * this hook.
3336   *
3337   * It acts similarly to the `useContext` react hook.
3338   *
3339   * Note: Generally speaking, `useRegistry` is a low level hook that in most cases
3340   * won't be needed for implementation. Most interactions with the `@wordpress/data`
3341   * API can be performed via the `useSelect` hook,  or the `withSelect` and
3342   * `withDispatch` higher order components.
3343   *
3344   * @example
3345   * ```js
3346   * import {
3347   *   RegistryProvider,
3348   *   createRegistry,
3349   *   useRegistry,
3350   * } from '@wordpress/data';
3351   *
3352   * const registry = createRegistry( {} );
3353   *
3354   * const SomeChildUsingRegistry = ( props ) => {
3355   *   const registry = useRegistry();
3356   *   // ...logic implementing the registry in other react hooks.
3357   * };
3358   *
3359   *
3360   * const ParentProvidingRegistry = ( props ) => {
3361   *   return <RegistryProvider value={ registry }>
3362   *     <SomeChildUsingRegistry { ...props } />
3363   *   </RegistryProvider>
3364   * };
3365   * ```
3366   *
3367   * @return {Function}  A custom react hook exposing the registry context value.
3368   */
3369  
3370  function useRegistry() {
3371    return Object(external_wp_element_["useContext"])(Context);
3372  }
3373  
3374  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/async-mode-provider/context.js
3375  /**
3376   * WordPress dependencies
3377   */
3378  
3379  const context_Context = Object(external_wp_element_["createContext"])(false);
3380  const {
3381    Consumer: context_Consumer,
3382    Provider: context_Provider
3383  } = context_Context;
3384  const AsyncModeConsumer = context_Consumer;
3385  /**
3386   * Context Provider Component used to switch the data module component rerendering
3387   * between Sync and Async modes.
3388   *
3389   * @example
3390   *
3391   * ```js
3392   * import { useSelect, AsyncModeProvider } from '@wordpress/data';
3393   *
3394   * function BlockCount() {
3395   *   const count = useSelect( ( select ) => {
3396   *     return select( 'core/block-editor' ).getBlockCount()
3397   *   }, [] );
3398   *
3399   *   return count;
3400   * }
3401   *
3402   * function App() {
3403   *   return (
3404   *     <AsyncModeProvider value={ true }>
3405   *       <BlockCount />
3406   *     </AsyncModeProvider>
3407   *   );
3408   * }
3409   * ```
3410   *
3411   * In this example, the BlockCount component is rerendered asynchronously.
3412   * It means if a more critical task is being performed (like typing in an input),
3413   * the rerendering is delayed until the browser becomes IDLE.
3414   * It is possible to nest multiple levels of AsyncModeProvider to fine-tune the rendering behavior.
3415   *
3416   * @param {boolean} props.value Enable Async Mode.
3417   * @return {WPComponent} The component to be rendered.
3418   */
3419  
3420  /* harmony default export */ var async_mode_provider_context = (context_Provider);
3421  
3422  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/async-mode-provider/use-async-mode.js
3423  /**
3424   * WordPress dependencies
3425   */
3426  
3427  /**
3428   * Internal dependencies
3429   */
3430  
3431  
3432  function useAsyncMode() {
3433    return Object(external_wp_element_["useContext"])(context_Context);
3434  }
3435  
3436  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/use-select/index.js
3437  /**
3438   * External dependencies
3439   */
3440  
3441  /**
3442   * WordPress dependencies
3443   */
3444  
3445  
3446  
3447  
3448  
3449  /**
3450   * Internal dependencies
3451   */
3452  
3453  
3454  
3455  const renderQueue = Object(external_wp_priorityQueue_["createQueue"])();
3456  /** @typedef {import('./types').WPDataStore} WPDataStore */
3457  
3458  /**
3459   * Custom react hook for retrieving props from registered selectors.
3460   *
3461   * In general, this custom React hook follows the
3462   * [rules of hooks](https://reactjs.org/docs/hooks-rules.html).
3463   *
3464   * @param {Function|WPDataStore|string} _mapSelect Function called on every state change. The
3465   *                                                 returned value is exposed to the component
3466   *                                                 implementing this hook. The function receives
3467   *                                                 the `registry.select` method on the first
3468   *                                                 argument and the `registry` on the second
3469   *                                                 argument.
3470   *                                                 When a store key is passed, all selectors for
3471   *                                                 the store will be returned. This is only meant
3472   *                                                 for usage of these selectors in event
3473   *                                                 callbacks, not for data needed to create the
3474   *                                                 element tree.
3475   * @param {Array}                       deps       If provided, this memoizes the mapSelect so the
3476   *                                                 same `mapSelect` is invoked on every state
3477   *                                                 change unless the dependencies change.
3478   *
3479   * @example
3480   * ```js
3481   * import { useSelect } from '@wordpress/data';
3482   *
3483   * function HammerPriceDisplay( { currency } ) {
3484   *   const price = useSelect( ( select ) => {
3485   *     return select( 'my-shop' ).getPrice( 'hammer', currency )
3486   *   }, [ currency ] );
3487   *   return new Intl.NumberFormat( 'en-US', {
3488   *     style: 'currency',
3489   *     currency,
3490   *   } ).format( price );
3491   * }
3492   *
3493   * // Rendered in the application:
3494   * // <HammerPriceDisplay currency="USD" />
3495   * ```
3496   *
3497   * In the above example, when `HammerPriceDisplay` is rendered into an
3498   * application, the price will be retrieved from the store state using the
3499   * `mapSelect` callback on `useSelect`. If the currency prop changes then
3500   * any price in the state for that currency is retrieved. If the currency prop
3501   * doesn't change and other props are passed in that do change, the price will
3502   * not change because the dependency is just the currency.
3503   *
3504   * When data is only used in an event callback, the data should not be retrieved
3505   * on render, so it may be useful to get the selectors function instead.
3506   *
3507   * **Don't use `useSelect` this way when calling the selectors in the render
3508   * function because your component won't re-render on a data change.**
3509   *
3510   * ```js
3511   * import { useSelect } from '@wordpress/data';
3512   *
3513   * function Paste( { children } ) {
3514   *   const { getSettings } = useSelect( 'my-shop' );
3515   *   function onPaste() {
3516   *     // Do something with the settings.
3517   *     const settings = getSettings();
3518   *   }
3519   *   return <div onPaste={ onPaste }>{ children }</div>;
3520   * }
3521   * ```
3522   *
3523   * @return {Function}  A custom react hook.
3524   */
3525  
3526  function useSelect(_mapSelect, deps) {
3527    const isWithoutMapping = typeof _mapSelect !== 'function';
3528  
3529    if (isWithoutMapping) {
3530      deps = [];
3531    }
3532  
3533    const mapSelect = Object(external_wp_element_["useCallback"])(_mapSelect, deps);
3534    const registry = useRegistry();
3535    const isAsync = useAsyncMode(); // React can sometimes clear the `useMemo` cache.
3536    // We use the cache-stable `useMemoOne` to avoid
3537    // losing queues.
3538  
3539    const queueContext = Object(use_memo_one_esm["a" /* useMemoOne */])(() => ({
3540      queue: true
3541    }), [registry]);
3542    const [, forceRender] = Object(external_wp_element_["useReducer"])(s => s + 1, 0);
3543    const latestMapSelect = Object(external_wp_element_["useRef"])();
3544    const latestIsAsync = Object(external_wp_element_["useRef"])(isAsync);
3545    const latestMapOutput = Object(external_wp_element_["useRef"])();
3546    const latestMapOutputError = Object(external_wp_element_["useRef"])();
3547    const isMountedAndNotUnsubscribing = Object(external_wp_element_["useRef"])(); // Keep track of the stores being selected in the mapSelect function,
3548    // and only subscribe to those stores later.
3549  
3550    const listeningStores = Object(external_wp_element_["useRef"])([]);
3551    const trapSelect = Object(external_wp_element_["useCallback"])(callback => registry.__experimentalMarkListeningStores(callback, listeningStores), [registry]); // Generate a "flag" for used in the effect dependency array.
3552    // It's different than just using `mapSelect` since deps could be undefined,
3553    // in that case, we would still want to memoize it.
3554  
3555    const depsChangedFlag = Object(external_wp_element_["useMemo"])(() => ({}), deps || []);
3556    let mapOutput;
3557  
3558    if (!isWithoutMapping) {
3559      try {
3560        if (latestMapSelect.current !== mapSelect || latestMapOutputError.current) {
3561          mapOutput = trapSelect(() => mapSelect(registry.select, registry));
3562        } else {
3563          mapOutput = latestMapOutput.current;
3564        }
3565      } catch (error) {
3566        let errorMessage = `An error occurred while running 'mapSelect': $error.message}`;
3567  
3568        if (latestMapOutputError.current) {
3569          errorMessage += `\nThe error may be correlated with this previous error:\n`;
3570          errorMessage += `$latestMapOutputError.current.stack}\n\n`;
3571          errorMessage += 'Original stack trace:';
3572        } // eslint-disable-next-line no-console
3573  
3574  
3575        console.error(errorMessage);
3576        mapOutput = latestMapOutput.current;
3577      }
3578    }
3579  
3580    Object(external_wp_compose_["useIsomorphicLayoutEffect"])(() => {
3581      if (isWithoutMapping) {
3582        return;
3583      }
3584  
3585      latestMapSelect.current = mapSelect;
3586      latestMapOutput.current = mapOutput;
3587      latestMapOutputError.current = undefined;
3588      isMountedAndNotUnsubscribing.current = true; // This has to run after the other ref updates
3589      // to avoid using stale values in the flushed
3590      // callbacks or potentially overwriting a
3591      // changed `latestMapOutput.current`.
3592  
3593      if (latestIsAsync.current !== isAsync) {
3594        latestIsAsync.current = isAsync;
3595        renderQueue.flush(queueContext);
3596      }
3597    });
3598    Object(external_wp_compose_["useIsomorphicLayoutEffect"])(() => {
3599      if (isWithoutMapping) {
3600        return;
3601      }
3602  
3603      const onStoreChange = () => {
3604        if (isMountedAndNotUnsubscribing.current) {
3605          try {
3606            const newMapOutput = trapSelect(() => latestMapSelect.current(registry.select, registry));
3607  
3608            if (external_wp_isShallowEqual_default()(latestMapOutput.current, newMapOutput)) {
3609              return;
3610            }
3611  
3612            latestMapOutput.current = newMapOutput;
3613          } catch (error) {
3614            latestMapOutputError.current = error;
3615          }
3616  
3617          forceRender();
3618        }
3619      }; // catch any possible state changes during mount before the subscription
3620      // could be set.
3621  
3622  
3623      if (latestIsAsync.current) {
3624        renderQueue.add(queueContext, onStoreChange);
3625      } else {
3626        onStoreChange();
3627      }
3628  
3629      const onChange = () => {
3630        if (latestIsAsync.current) {
3631          renderQueue.add(queueContext, onStoreChange);
3632        } else {
3633          onStoreChange();
3634        }
3635      };
3636  
3637      const unsubscribers = listeningStores.current.map(storeName => registry.__experimentalSubscribeStore(storeName, onChange));
3638      return () => {
3639        isMountedAndNotUnsubscribing.current = false; // The return value of the subscribe function could be undefined if the store is a custom generic store.
3640  
3641        unsubscribers.forEach(unsubscribe => unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe());
3642        renderQueue.flush(queueContext);
3643      };
3644    }, [registry, trapSelect, depsChangedFlag, isWithoutMapping]);
3645    return isWithoutMapping ? registry.select(_mapSelect) : mapOutput;
3646  }
3647  
3648  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/with-select/index.js
3649  
3650  
3651  
3652  /**
3653   * WordPress dependencies
3654   */
3655  
3656  /**
3657   * Internal dependencies
3658   */
3659  
3660  
3661  /**
3662   * Higher-order component used to inject state-derived props using registered
3663   * selectors.
3664   *
3665   * @param {Function} mapSelectToProps Function called on every state change,
3666   *                                    expected to return object of props to
3667   *                                    merge with the component's own props.
3668   *
3669   * @example
3670   * ```js
3671   * import { withSelect } from '@wordpress/data';
3672   *
3673   * function PriceDisplay( { price, currency } ) {
3674   *     return new Intl.NumberFormat( 'en-US', {
3675   *         style: 'currency',
3676   *         currency,
3677   *     } ).format( price );
3678   * }
3679   *
3680   * const HammerPriceDisplay = withSelect( ( select, ownProps ) => {
3681   *     const { getPrice } = select( 'my-shop' );
3682   *     const { currency } = ownProps;
3683   *
3684   *     return {
3685   *         price: getPrice( 'hammer', currency ),
3686   *     };
3687   * } )( PriceDisplay );
3688   *
3689   * // Rendered in the application:
3690   * //
3691   * //  <HammerPriceDisplay currency="USD" />
3692   * ```
3693   * In the above example, when `HammerPriceDisplay` is rendered into an
3694   * application, it will pass the price into the underlying `PriceDisplay`
3695   * component and update automatically if the price of a hammer ever changes in
3696   * the store.
3697   *
3698   * @return {WPComponent} Enhanced component with merged state data props.
3699   */
3700  
3701  const withSelect = mapSelectToProps => Object(external_wp_compose_["createHigherOrderComponent"])(WrappedComponent => Object(external_wp_compose_["pure"])(ownProps => {
3702    const mapSelect = (select, registry) => mapSelectToProps(select, ownProps, registry);
3703  
3704    const mergeProps = useSelect(mapSelect);
3705    return Object(external_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, ownProps, mergeProps));
3706  }), 'withSelect');
3707  
3708  /* harmony default export */ var with_select = (withSelect);
3709  
3710  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch-with-map.js
3711  /**
3712   * External dependencies
3713   */
3714  
3715  /**
3716   * WordPress dependencies
3717   */
3718  
3719  
3720  
3721  /**
3722   * Internal dependencies
3723   */
3724  
3725  
3726  /**
3727   * Custom react hook for returning aggregate dispatch actions using the provided
3728   * dispatchMap.
3729   *
3730   * Currently this is an internal api only and is implemented by `withDispatch`
3731   *
3732   * @param {Function} dispatchMap Receives the `registry.dispatch` function as
3733   *                               the first argument and the `registry` object
3734   *                               as the second argument.  Should return an
3735   *                               object mapping props to functions.
3736   * @param {Array}    deps        An array of dependencies for the hook.
3737   * @return {Object}  An object mapping props to functions created by the passed
3738   *                   in dispatchMap.
3739   */
3740  
3741  const useDispatchWithMap = (dispatchMap, deps) => {
3742    const registry = useRegistry();
3743    const currentDispatchMap = Object(external_wp_element_["useRef"])(dispatchMap);
3744    Object(external_wp_compose_["useIsomorphicLayoutEffect"])(() => {
3745      currentDispatchMap.current = dispatchMap;
3746    });
3747    return Object(external_wp_element_["useMemo"])(() => {
3748      const currentDispatchProps = currentDispatchMap.current(registry.dispatch, registry);
3749      return Object(external_lodash_["mapValues"])(currentDispatchProps, (dispatcher, propName) => {
3750        if (typeof dispatcher !== 'function') {
3751          // eslint-disable-next-line no-console
3752          console.warn(`Property $propName} returned from dispatchMap in useDispatchWithMap must be a function.`);
3753        }
3754  
3755        return function () {
3756          return currentDispatchMap.current(registry.dispatch, registry)[propName](...arguments);
3757        };
3758      });
3759    }, [registry, ...deps]);
3760  };
3761  
3762  /* harmony default export */ var use_dispatch_with_map = (useDispatchWithMap);
3763  
3764  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/with-dispatch/index.js
3765  
3766  
3767  
3768  /**
3769   * WordPress dependencies
3770   */
3771  
3772  /**
3773   * Internal dependencies
3774   */
3775  
3776  
3777  /**
3778   * Higher-order component used to add dispatch props using registered action
3779   * creators.
3780   *
3781   * @param {Function} mapDispatchToProps A function of returning an object of
3782   *                                      prop names where value is a
3783   *                                      dispatch-bound action creator, or a
3784   *                                      function to be called with the
3785   *                                      component's props and returning an
3786   *                                      action creator.
3787   *
3788   * @example
3789   * ```jsx
3790   * function Button( { onClick, children } ) {
3791   *     return <button type="button" onClick={ onClick }>{ children }</button>;
3792   * }
3793   *
3794   * import { withDispatch } from '@wordpress/data';
3795   *
3796   * const SaleButton = withDispatch( ( dispatch, ownProps ) => {
3797   *     const { startSale } = dispatch( 'my-shop' );
3798   *     const { discountPercent } = ownProps;
3799   *
3800   *     return {
3801   *         onClick() {
3802   *             startSale( discountPercent );
3803   *         },
3804   *     };
3805   * } )( Button );
3806   *
3807   * // Rendered in the application:
3808   * //
3809   * // <SaleButton discountPercent="20">Start Sale!</SaleButton>
3810   * ```
3811   *
3812   * @example
3813   * In the majority of cases, it will be sufficient to use only two first params
3814   * passed to `mapDispatchToProps` as illustrated in the previous example.
3815   * However, there might be some very advanced use cases where using the
3816   * `registry` object might be used as a tool to optimize the performance of
3817   * your component. Using `select` function from the registry might be useful
3818   * when you need to fetch some dynamic data from the store at the time when the
3819   * event is fired, but at the same time, you never use it to render your
3820   * component. In such scenario, you can avoid using the `withSelect` higher
3821   * order component to compute such prop, which might lead to unnecessary
3822   * re-renders of your component caused by its frequent value change.
3823   * Keep in mind, that `mapDispatchToProps` must return an object with functions
3824   * only.
3825   *
3826   * ```jsx
3827   * function Button( { onClick, children } ) {
3828   *     return <button type="button" onClick={ onClick }>{ children }</button>;
3829   * }
3830   *
3831   * import { withDispatch } from '@wordpress/data';
3832   *
3833   * const SaleButton = withDispatch( ( dispatch, ownProps, { select } ) => {
3834   *    // Stock number changes frequently.
3835   *    const { getStockNumber } = select( 'my-shop' );
3836   *    const { startSale } = dispatch( 'my-shop' );
3837   *    return {
3838   *        onClick() {
3839   *            const discountPercent = getStockNumber() > 50 ? 10 : 20;
3840   *            startSale( discountPercent );
3841   *        },
3842   *    };
3843   * } )( Button );
3844   *
3845   * // Rendered in the application:
3846   * //
3847   * //  <SaleButton>Start Sale!</SaleButton>
3848   * ```
3849   *
3850   * _Note:_ It is important that the `mapDispatchToProps` function always
3851   * returns an object with the same keys. For example, it should not contain
3852   * conditions under which a different value would be returned.
3853   *
3854   * @return {WPComponent} Enhanced component with merged dispatcher props.
3855   */
3856  
3857  const withDispatch = mapDispatchToProps => Object(external_wp_compose_["createHigherOrderComponent"])(WrappedComponent => ownProps => {
3858    const mapDispatch = (dispatch, registry) => mapDispatchToProps(dispatch, ownProps, registry);
3859  
3860    const dispatchProps = use_dispatch_with_map(mapDispatch, []);
3861    return Object(external_wp_element_["createElement"])(WrappedComponent, Object(esm_extends["a" /* default */])({}, ownProps, dispatchProps));
3862  }, 'withDispatch');
3863  
3864  /* harmony default export */ var with_dispatch = (withDispatch);
3865  
3866  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/with-registry/index.js
3867  
3868  
3869  
3870  /**
3871   * WordPress dependencies
3872   */
3873  
3874  /**
3875   * Internal dependencies
3876   */
3877  
3878  
3879  /**
3880   * Higher-order component which renders the original component with the current
3881   * registry context passed as its `registry` prop.
3882   *
3883   * @param {WPComponent} OriginalComponent Original component.
3884   *
3885   * @return {WPComponent} Enhanced component.
3886   */
3887  
3888  const withRegistry = Object(external_wp_compose_["createHigherOrderComponent"])(OriginalComponent => props => Object(external_wp_element_["createElement"])(RegistryConsumer, null, registry => Object(external_wp_element_["createElement"])(OriginalComponent, Object(esm_extends["a" /* default */])({}, props, {
3889    registry: registry
3890  }))), 'withRegistry');
3891  /* harmony default export */ var with_registry = (withRegistry);
3892  
3893  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch.js
3894  /**
3895   * Internal dependencies
3896   */
3897  
3898  /** @typedef {import('./types').WPDataStore} WPDataStore */
3899  
3900  /**
3901   * A custom react hook returning the current registry dispatch actions creators.
3902   *
3903   * Note: The component using this hook must be within the context of a
3904   * RegistryProvider.
3905   *
3906   * @param {string|WPDataStore} [storeNameOrDefinition] Optionally provide the name of the
3907   *                                                     store or its definition from which to
3908   *                                                     retrieve action creators. If not
3909   *                                                     provided, the registry.dispatch
3910   *                                                     function is returned instead.
3911   *
3912   * @example
3913   * This illustrates a pattern where you may need to retrieve dynamic data from
3914   * the server via the `useSelect` hook to use in combination with the dispatch
3915   * action.
3916   *
3917   * ```jsx
3918   * import { useDispatch, useSelect } from '@wordpress/data';
3919   * import { useCallback } from '@wordpress/element';
3920   *
3921   * function Button( { onClick, children } ) {
3922   *   return <button type="button" onClick={ onClick }>{ children }</button>
3923   * }
3924   *
3925   * const SaleButton = ( { children } ) => {
3926   *   const { stockNumber } = useSelect(
3927   *     ( select ) => select( 'my-shop' ).getStockNumber(),
3928   *     []
3929   *   );
3930   *   const { startSale } = useDispatch( 'my-shop' );
3931   *   const onClick = useCallback( () => {
3932   *     const discountPercent = stockNumber > 50 ? 10: 20;
3933   *     startSale( discountPercent );
3934   *   }, [ stockNumber ] );
3935   *   return <Button onClick={ onClick }>{ children }</Button>
3936   * }
3937   *
3938   * // Rendered somewhere in the application:
3939   * //
3940   * // <SaleButton>Start Sale!</SaleButton>
3941   * ```
3942   * @return {Function}  A custom react hook.
3943   */
3944  
3945  const useDispatch = storeNameOrDefinition => {
3946    const {
3947      dispatch
3948    } = useRegistry();
3949    return storeNameOrDefinition === void 0 ? dispatch : dispatch(storeNameOrDefinition);
3950  };
3951  
3952  /* harmony default export */ var use_dispatch = (useDispatch);
3953  
3954  // CONCATENATED MODULE: ./node_modules/@wordpress/data/build-module/index.js
3955  /**
3956   * External dependencies
3957   */
3958  
3959  /**
3960   * Internal dependencies
3961   */
3962  
3963  
3964  
3965  /** @typedef {import('./types').WPDataStore} WPDataStore */
3966  
3967  
3968  
3969  
3970  
3971  
3972  
3973  
3974  
3975  
3976  
3977  
3978  /**
3979   * Object of available plugins to use with a registry.
3980   *
3981   * @see [use](#use)
3982   *
3983   * @type {Object}
3984   */
3985  
3986  
3987  /**
3988   * The combineReducers helper function turns an object whose values are different
3989   * reducing functions into a single reducing function you can pass to registerReducer.
3990   *
3991   * @param {Object} reducers An object whose values correspond to different reducing
3992   *                          functions that need to be combined into one.
3993   *
3994   * @example
3995   * ```js
3996   * import { combineReducers, createReduxStore, register } from '@wordpress/data';
3997   *
3998   * const prices = ( state = {}, action ) => {
3999   *     return action.type === 'SET_PRICE' ?
4000   *         {
4001   *             ...state,
4002   *             [ action.item ]: action.price,
4003   *         } :
4004   *         state;
4005   * };
4006   *
4007   * const discountPercent = ( state = 0, action ) => {
4008   *     return action.type === 'START_SALE' ?
4009   *         action.discountPercent :
4010   *         state;
4011   * };
4012   *
4013   * const store = createReduxStore( 'my-shop', {
4014   *     reducer: combineReducers( {
4015   *         prices,
4016   *         discountPercent,
4017   *     } ),
4018   * } );
4019   * register( store );
4020   * ```
4021   *
4022   * @return {Function} A reducer that invokes every reducer inside the reducers
4023   *                    object, and constructs a state object with the same shape.
4024   */
4025  
4026  
4027  /**
4028   * Given the name or definition of a registered store, returns an object of the store's selectors.
4029   * The selector functions are been pre-bound to pass the current state automatically.
4030   * As a consumer, you need only pass arguments of the selector, if applicable.
4031   *
4032   * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store
4033   *                                                   or the store definition.
4034   *
4035   * @example
4036   * ```js
4037   * import { select } from '@wordpress/data';
4038   *
4039   * select( 'my-shop' ).getPrice( 'hammer' );
4040   * ```
4041   *
4042   * @return {Object} Object containing the store's selectors.
4043   */
4044  
4045  const build_module_select = default_registry.select;
4046  /**
4047   * Given the name of a registered store, returns an object containing the store's
4048   * selectors pre-bound to state so that you only need to supply additional arguments,
4049   * and modified so that they return promises that resolve to their eventual values,
4050   * after any resolvers have ran.
4051   *
4052   * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store
4053   *                                                   or the store definition.
4054   *
4055   * @example
4056   * ```js
4057   * import { resolveSelect } from '@wordpress/data';
4058   *
4059   * resolveSelect( 'my-shop' ).getPrice( 'hammer' ).then(console.log)
4060   * ```
4061   *
4062   * @return {Object} Object containing the store's promise-wrapped selectors.
4063   */
4064  
4065  const build_module_resolveSelect = default_registry.resolveSelect;
4066  /**
4067   * Given the name of a registered store, returns an object of the store's action creators.
4068   * Calling an action creator will cause it to be dispatched, updating the state value accordingly.
4069   *
4070   * Note: Action creators returned by the dispatch will return a promise when
4071   * they are called.
4072   *
4073   * @param {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store
4074   *                                                   or the store definition.
4075   *
4076   * @example
4077   * ```js
4078   * import { dispatch } from '@wordpress/data';
4079   *
4080   * dispatch( 'my-shop' ).setPrice( 'hammer', 9.75 );
4081   * ```
4082   * @return {Object} Object containing the action creators.
4083   */
4084  
4085  const build_module_dispatch = default_registry.dispatch;
4086  /**
4087   * Given a listener function, the function will be called any time the state value
4088   * of one of the registered stores has changed. This function returns a `unsubscribe`
4089   * function used to stop the subscription.
4090   *
4091   * @param {Function} listener Callback function.
4092   *
4093   * @example
4094   * ```js
4095   * import { subscribe } from '@wordpress/data';
4096   *
4097   * const unsubscribe = subscribe( () => {
4098   *     // You could use this opportunity to test whether the derived result of a
4099   *     // selector has subsequently changed as the result of a state update.
4100   * } );
4101   *
4102   * // Later, if necessary...
4103   * unsubscribe();
4104   * ```
4105   */
4106  
4107  const build_module_subscribe = default_registry.subscribe;
4108  /**
4109   * Registers a generic store.
4110   *
4111   * @deprecated Use `register` instead.
4112   *
4113   * @param {string} key    Store registry key.
4114   * @param {Object} config Configuration (getSelectors, getActions, subscribe).
4115   */
4116  
4117  const build_module_registerGenericStore = default_registry.registerGenericStore;
4118  /**
4119   * Registers a standard `@wordpress/data` store.
4120   *
4121   * @deprecated Use `register` instead.
4122   *
4123   * @param {string} storeName Unique namespace identifier for the store.
4124   * @param {Object} options   Store description (reducer, actions, selectors, resolvers).
4125   *
4126   * @return {Object} Registered store object.
4127   */
4128  
4129  const registerStore = default_registry.registerStore;
4130  /**
4131   * Extends a registry to inherit functionality provided by a given plugin. A
4132   * plugin is an object with properties aligning to that of a registry, merged
4133   * to extend the default registry behavior.
4134   *
4135   * @param {Object} plugin Plugin object.
4136   */
4137  
4138  const build_module_use = default_registry.use;
4139  /**
4140   * Registers a standard `@wordpress/data` store definition.
4141   *
4142   * @example
4143   * ```js
4144   * import { createReduxStore, register } from '@wordpress/data';
4145   *
4146   * const store = createReduxStore( 'demo', {
4147   *     reducer: ( state = 'OK' ) => state,
4148   *     selectors: {
4149   *         getValue: ( state ) => state,
4150   *     },
4151   * } );
4152   * register( store );
4153   * ```
4154   *
4155   * @param {WPDataStore} store Store definition.
4156   */
4157  
4158  const build_module_register = default_registry.register;
4159  
4160  
4161  /***/ }),
4162  
4163  /***/ "rl8x":
4164  /***/ (function(module, exports) {
4165  
4166  (function() { module.exports = window["wp"]["isShallowEqual"]; }());
4167  
4168  /***/ }),
4169  
4170  /***/ "wx14":
4171  /***/ (function(module, __webpack_exports__, __webpack_require__) {
4172  
4173  "use strict";
4174  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return _extends; });
4175  function _extends() {
4176    _extends = Object.assign || function (target) {
4177      for (var i = 1; i < arguments.length; i++) {
4178        var source = arguments[i];
4179  
4180        for (var key in source) {
4181          if (Object.prototype.hasOwnProperty.call(source, key)) {
4182            target[key] = source[key];
4183          }
4184        }
4185      }
4186  
4187      return target;
4188    };
4189  
4190    return _extends.apply(this, arguments);
4191  }
4192  
4193  /***/ })
4194  
4195  /******/ });


Generated: Wed Jan 19 01:00:04 2022 Cross-referenced by PHPXref 0.7.1