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


Generated: Mon Jan 27 01:00:03 2020 Cross-referenced by PHPXref 0.7.1