[Summary view] [Print] [Text view]

   1  "use strict";
   2  var wp;
   3  (wp ||= {}).data = (() => {
   4    var __create = Object.create;
   5    var __defProp = Object.defineProperty;
   6    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   7    var __getOwnPropNames = Object.getOwnPropertyNames;
   8    var __getProtoOf = Object.getPrototypeOf;
   9    var __hasOwnProp = Object.prototype.hasOwnProperty;
  10    var __commonJS = (cb, mod) => function __require() {
  11      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  12    };
  13    var __export = (target, all) => {
  14      for (var name in all)
  15        __defProp(target, name, { get: all[name], enumerable: true });
  16    };
  17    var __copyProps = (to, from, except, desc) => {
  18      if (from && typeof from === "object" || typeof from === "function") {
  19        for (let key of __getOwnPropNames(from))
  20          if (!__hasOwnProp.call(to, key) && key !== except)
  21            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  22      }
  23      return to;
  24    };
  25    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  26      // If the importer is in node compatibility mode or this is not an ESM
  27      // file that has been converted to a CommonJS file using a Babel-
  28      // compatible transform (i.e. "__esModule" has not been set), then set
  29      // "default" to the CommonJS "module.exports" for node compatibility.
  30      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  31      mod
  32    ));
  33    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  34  
  35    // package-external:@wordpress/deprecated
  36    var require_deprecated = __commonJS({
  37      "package-external:@wordpress/deprecated"(exports, module) {
  38        module.exports = window.wp.deprecated;
  39      }
  40    });
  41  
  42    // node_modules/equivalent-key-map/equivalent-key-map.js
  43    var require_equivalent_key_map = __commonJS({
  44      "node_modules/equivalent-key-map/equivalent-key-map.js"(exports, module) {
  45        "use strict";
  46        function _typeof(obj) {
  47          if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
  48            _typeof = function(obj2) {
  49              return typeof obj2;
  50            };
  51          } else {
  52            _typeof = function(obj2) {
  53              return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
  54            };
  55          }
  56          return _typeof(obj);
  57        }
  58        function _classCallCheck(instance, Constructor) {
  59          if (!(instance instanceof Constructor)) {
  60            throw new TypeError("Cannot call a class as a function");
  61          }
  62        }
  63        function _defineProperties(target, props) {
  64          for (var i = 0; i < props.length; i++) {
  65            var descriptor = props[i];
  66            descriptor.enumerable = descriptor.enumerable || false;
  67            descriptor.configurable = true;
  68            if ("value" in descriptor) descriptor.writable = true;
  69            Object.defineProperty(target, descriptor.key, descriptor);
  70          }
  71        }
  72        function _createClass(Constructor, protoProps, staticProps) {
  73          if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  74          if (staticProps) _defineProperties(Constructor, staticProps);
  75          return Constructor;
  76        }
  77        function getValuePair(instance, key) {
  78          var _map = instance._map, _arrayTreeMap = instance._arrayTreeMap, _objectTreeMap = instance._objectTreeMap;
  79          if (_map.has(key)) {
  80            return _map.get(key);
  81          }
  82          var properties = Object.keys(key).sort();
  83          var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;
  84          for (var i = 0; i < properties.length; i++) {
  85            var property = properties[i];
  86            map = map.get(property);
  87            if (map === void 0) {
  88              return;
  89            }
  90            var propertyValue = key[property];
  91            map = map.get(propertyValue);
  92            if (map === void 0) {
  93              return;
  94            }
  95          }
  96          var valuePair = map.get("_ekm_value");
  97          if (!valuePair) {
  98            return;
  99          }
 100          _map.delete(valuePair[0]);
 101          valuePair[0] = key;
 102          map.set("_ekm_value", valuePair);
 103          _map.set(key, valuePair);
 104          return valuePair;
 105        }
 106        var EquivalentKeyMap3 = /* @__PURE__ */ (function() {
 107          function EquivalentKeyMap4(iterable) {
 108            _classCallCheck(this, EquivalentKeyMap4);
 109            this.clear();
 110            if (iterable instanceof EquivalentKeyMap4) {
 111              var iterablePairs = [];
 112              iterable.forEach(function(value, key) {
 113                iterablePairs.push([key, value]);
 114              });
 115              iterable = iterablePairs;
 116            }
 117            if (iterable != null) {
 118              for (var i = 0; i < iterable.length; i++) {
 119                this.set(iterable[i][0], iterable[i][1]);
 120              }
 121            }
 122          }
 123          _createClass(EquivalentKeyMap4, [{
 124            key: "set",
 125            /**
 126             * Add or update an element with a specified key and value.
 127             *
 128             * @param {*} key   The key of the element to add.
 129             * @param {*} value The value of the element to add.
 130             *
 131             * @return {EquivalentKeyMap} Map instance.
 132             */
 133            value: function set(key, value) {
 134              if (key === null || _typeof(key) !== "object") {
 135                this._map.set(key, value);
 136                return this;
 137              }
 138              var properties = Object.keys(key).sort();
 139              var valuePair = [key, value];
 140              var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;
 141              for (var i = 0; i < properties.length; i++) {
 142                var property = properties[i];
 143                if (!map.has(property)) {
 144                  map.set(property, new EquivalentKeyMap4());
 145                }
 146                map = map.get(property);
 147                var propertyValue = key[property];
 148                if (!map.has(propertyValue)) {
 149                  map.set(propertyValue, new EquivalentKeyMap4());
 150                }
 151                map = map.get(propertyValue);
 152              }
 153              var previousValuePair = map.get("_ekm_value");
 154              if (previousValuePair) {
 155                this._map.delete(previousValuePair[0]);
 156              }
 157              map.set("_ekm_value", valuePair);
 158              this._map.set(key, valuePair);
 159              return this;
 160            }
 161            /**
 162             * Returns a specified element.
 163             *
 164             * @param {*} key The key of the element to return.
 165             *
 166             * @return {?*} The element associated with the specified key or undefined
 167             *              if the key can't be found.
 168             */
 169          }, {
 170            key: "get",
 171            value: function get(key) {
 172              if (key === null || _typeof(key) !== "object") {
 173                return this._map.get(key);
 174              }
 175              var valuePair = getValuePair(this, key);
 176              if (valuePair) {
 177                return valuePair[1];
 178              }
 179            }
 180            /**
 181             * Returns a boolean indicating whether an element with the specified key
 182             * exists or not.
 183             *
 184             * @param {*} key The key of the element to test for presence.
 185             *
 186             * @return {boolean} Whether an element with the specified key exists.
 187             */
 188          }, {
 189            key: "has",
 190            value: function has(key) {
 191              if (key === null || _typeof(key) !== "object") {
 192                return this._map.has(key);
 193              }
 194              return getValuePair(this, key) !== void 0;
 195            }
 196            /**
 197             * Removes the specified element.
 198             *
 199             * @param {*} key The key of the element to remove.
 200             *
 201             * @return {boolean} Returns true if an element existed and has been
 202             *                   removed, or false if the element does not exist.
 203             */
 204          }, {
 205            key: "delete",
 206            value: function _delete(key) {
 207              if (!this.has(key)) {
 208                return false;
 209              }
 210              this.set(key, void 0);
 211              return true;
 212            }
 213            /**
 214             * Executes a provided function once per each key/value pair, in insertion
 215             * order.
 216             *
 217             * @param {Function} callback Function to execute for each element.
 218             * @param {*}        thisArg  Value to use as `this` when executing
 219             *                            `callback`.
 220             */
 221          }, {
 222            key: "forEach",
 223            value: function forEach(callback) {
 224              var _this = this;
 225              var thisArg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this;
 226              this._map.forEach(function(value, key) {
 227                if (key !== null && _typeof(key) === "object") {
 228                  value = value[1];
 229                }
 230                callback.call(thisArg, value, key, _this);
 231              });
 232            }
 233            /**
 234             * Removes all elements.
 235             */
 236          }, {
 237            key: "clear",
 238            value: function clear() {
 239              this._map = /* @__PURE__ */ new Map();
 240              this._arrayTreeMap = /* @__PURE__ */ new Map();
 241              this._objectTreeMap = /* @__PURE__ */ new Map();
 242            }
 243          }, {
 244            key: "size",
 245            get: function get() {
 246              return this._map.size;
 247            }
 248          }]);
 249          return EquivalentKeyMap4;
 250        })();
 251        module.exports = EquivalentKeyMap3;
 252      }
 253    });
 254  
 255    // package-external:@wordpress/redux-routine
 256    var require_redux_routine = __commonJS({
 257      "package-external:@wordpress/redux-routine"(exports, module) {
 258        module.exports = window.wp.reduxRoutine;
 259      }
 260    });
 261  
 262    // package-external:@wordpress/compose
 263    var require_compose = __commonJS({
 264      "package-external:@wordpress/compose"(exports, module) {
 265        module.exports = window.wp.compose;
 266      }
 267    });
 268  
 269    // package-external:@wordpress/private-apis
 270    var require_private_apis = __commonJS({
 271      "package-external:@wordpress/private-apis"(exports, module) {
 272        module.exports = window.wp.privateApis;
 273      }
 274    });
 275  
 276    // node_modules/deepmerge/dist/cjs.js
 277    var require_cjs = __commonJS({
 278      "node_modules/deepmerge/dist/cjs.js"(exports, module) {
 279        "use strict";
 280        var isMergeableObject = function isMergeableObject2(value) {
 281          return isNonNullObject(value) && !isSpecial(value);
 282        };
 283        function isNonNullObject(value) {
 284          return !!value && typeof value === "object";
 285        }
 286        function isSpecial(value) {
 287          var stringValue = Object.prototype.toString.call(value);
 288          return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
 289        }
 290        var canUseSymbol = typeof Symbol === "function" && Symbol.for;
 291        var REACT_ELEMENT_TYPE = canUseSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
 292        function isReactElement(value) {
 293          return value.$$typeof === REACT_ELEMENT_TYPE;
 294        }
 295        function emptyTarget(val) {
 296          return Array.isArray(val) ? [] : {};
 297        }
 298        function cloneUnlessOtherwiseSpecified(value, options) {
 299          return options.clone !== false && options.isMergeableObject(value) ? deepmerge2(emptyTarget(value), value, options) : value;
 300        }
 301        function defaultArrayMerge(target, source, options) {
 302          return target.concat(source).map(function(element) {
 303            return cloneUnlessOtherwiseSpecified(element, options);
 304          });
 305        }
 306        function getMergeFunction(key, options) {
 307          if (!options.customMerge) {
 308            return deepmerge2;
 309          }
 310          var customMerge = options.customMerge(key);
 311          return typeof customMerge === "function" ? customMerge : deepmerge2;
 312        }
 313        function getEnumerableOwnPropertySymbols(target) {
 314          return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
 315            return Object.propertyIsEnumerable.call(target, symbol);
 316          }) : [];
 317        }
 318        function getKeys(target) {
 319          return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
 320        }
 321        function propertyIsOnObject(object, property) {
 322          try {
 323            return property in object;
 324          } catch (_) {
 325            return false;
 326          }
 327        }
 328        function propertyIsUnsafe(target, key) {
 329          return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
 330        }
 331        function mergeObject(target, source, options) {
 332          var destination = {};
 333          if (options.isMergeableObject(target)) {
 334            getKeys(target).forEach(function(key) {
 335              destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
 336            });
 337          }
 338          getKeys(source).forEach(function(key) {
 339            if (propertyIsUnsafe(target, key)) {
 340              return;
 341            }
 342            if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
 343              destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
 344            } else {
 345              destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
 346            }
 347          });
 348          return destination;
 349        }
 350        function deepmerge2(target, source, options) {
 351          options = options || {};
 352          options.arrayMerge = options.arrayMerge || defaultArrayMerge;
 353          options.isMergeableObject = options.isMergeableObject || isMergeableObject;
 354          options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
 355          var sourceIsArray = Array.isArray(source);
 356          var targetIsArray = Array.isArray(target);
 357          var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
 358          if (!sourceAndTargetTypesMatch) {
 359            return cloneUnlessOtherwiseSpecified(source, options);
 360          } else if (sourceIsArray) {
 361            return options.arrayMerge(target, source, options);
 362          } else {
 363            return mergeObject(target, source, options);
 364          }
 365        }
 366        deepmerge2.all = function deepmergeAll(array, options) {
 367          if (!Array.isArray(array)) {
 368            throw new Error("first argument should be an array");
 369          }
 370          return array.reduce(function(prev, next) {
 371            return deepmerge2(prev, next, options);
 372          }, {});
 373        };
 374        var deepmerge_1 = deepmerge2;
 375        module.exports = deepmerge_1;
 376      }
 377    });
 378  
 379    // package-external:@wordpress/priority-queue
 380    var require_priority_queue = __commonJS({
 381      "package-external:@wordpress/priority-queue"(exports, module) {
 382        module.exports = window.wp.priorityQueue;
 383      }
 384    });
 385  
 386    // package-external:@wordpress/element
 387    var require_element = __commonJS({
 388      "package-external:@wordpress/element"(exports, module) {
 389        module.exports = window.wp.element;
 390      }
 391    });
 392  
 393    // package-external:@wordpress/is-shallow-equal
 394    var require_is_shallow_equal = __commonJS({
 395      "package-external:@wordpress/is-shallow-equal"(exports, module) {
 396        module.exports = window.wp.isShallowEqual;
 397      }
 398    });
 399  
 400    // vendor-external:react/jsx-runtime
 401    var require_jsx_runtime = __commonJS({
 402      "vendor-external:react/jsx-runtime"(exports, module) {
 403        module.exports = window.ReactJSXRuntime;
 404      }
 405    });
 406  
 407    // packages/data/build-module/index.mjs
 408    var index_exports = {};
 409    __export(index_exports, {
 410      AsyncModeProvider: () => context_default2,
 411      RegistryConsumer: () => RegistryConsumer,
 412      RegistryProvider: () => context_default,
 413      combineReducers: () => combineReducers2,
 414      controls: () => controls,
 415      createReduxStore: () => createReduxStore,
 416      createRegistry: () => createRegistry,
 417      createRegistryControl: () => createRegistryControl,
 418      createRegistrySelector: () => createRegistrySelector,
 419      createSelector: () => rememo_default,
 420      dispatch: () => dispatch2,
 421      plugins: () => plugins_exports,
 422      register: () => register,
 423      registerGenericStore: () => registerGenericStore,
 424      registerStore: () => registerStore,
 425      resolveSelect: () => resolveSelect2,
 426      select: () => select2,
 427      subscribe: () => subscribe,
 428      suspendSelect: () => suspendSelect,
 429      use: () => use,
 430      useDispatch: () => use_dispatch_default,
 431      useRegistry: () => useRegistry,
 432      useSelect: () => useSelect,
 433      useSuspenseSelect: () => useSuspenseSelect,
 434      withDispatch: () => with_dispatch_default,
 435      withRegistry: () => with_registry_default,
 436      withSelect: () => with_select_default
 437    });
 438  
 439    // packages/data/build-module/registry.mjs
 440    var import_deprecated2 = __toESM(require_deprecated(), 1);
 441  
 442    // node_modules/redux/dist/redux.mjs
 443    var $$observable = /* @__PURE__ */ (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
 444    var symbol_observable_default = $$observable;
 445    var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
 446    var ActionTypes = {
 447      INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
 448      REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
 449      PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION$randomString()}`
 450    };
 451    var actionTypes_default = ActionTypes;
 452    function isPlainObject(obj) {
 453      if (typeof obj !== "object" || obj === null)
 454        return false;
 455      let proto = obj;
 456      while (Object.getPrototypeOf(proto) !== null) {
 457        proto = Object.getPrototypeOf(proto);
 458      }
 459      return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
 460    }
 461    function miniKindOf(val) {
 462      if (val === void 0)
 463        return "undefined";
 464      if (val === null)
 465        return "null";
 466      const type = typeof val;
 467      switch (type) {
 468        case "boolean":
 469        case "string":
 470        case "number":
 471        case "symbol":
 472        case "function": {
 473          return type;
 474        }
 475      }
 476      if (Array.isArray(val))
 477        return "array";
 478      if (isDate(val))
 479        return "date";
 480      if (isError(val))
 481        return "error";
 482      const constructorName = ctorName(val);
 483      switch (constructorName) {
 484        case "Symbol":
 485        case "Promise":
 486        case "WeakMap":
 487        case "WeakSet":
 488        case "Map":
 489        case "Set":
 490          return constructorName;
 491      }
 492      return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
 493    }
 494    function ctorName(val) {
 495      return typeof val.constructor === "function" ? val.constructor.name : null;
 496    }
 497    function isError(val) {
 498      return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
 499    }
 500    function isDate(val) {
 501      if (val instanceof Date)
 502        return true;
 503      return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
 504    }
 505    function kindOf(val) {
 506      let typeOfVal = typeof val;
 507      if (true) {
 508        typeOfVal = miniKindOf(val);
 509      }
 510      return typeOfVal;
 511    }
 512    function createStore(reducer, preloadedState, enhancer) {
 513      if (typeof reducer !== "function") {
 514        throw new Error(false ? formatProdErrorMessage(2) : `Expected the root reducer to be a function. Instead, received: '$kindOf(reducer)}'`);
 515      }
 516      if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") {
 517        throw new Error(false ? formatProdErrorMessage(0) : "It looks like you are passing several store enhancers to createStore(). This is not supported. Instead, compose them together to a single function. See https://redux.js.org/tutorials/fundamentals/part-4-store#creating-a-store-with-enhancers for an example.");
 518      }
 519      if (typeof preloadedState === "function" && typeof enhancer === "undefined") {
 520        enhancer = preloadedState;
 521        preloadedState = void 0;
 522      }
 523      if (typeof enhancer !== "undefined") {
 524        if (typeof enhancer !== "function") {
 525          throw new Error(false ? formatProdErrorMessage(1) : `Expected the enhancer to be a function. Instead, received: '$kindOf(enhancer)}'`);
 526        }
 527        return enhancer(createStore)(reducer, preloadedState);
 528      }
 529      let currentReducer = reducer;
 530      let currentState = preloadedState;
 531      let currentListeners = /* @__PURE__ */ new Map();
 532      let nextListeners = currentListeners;
 533      let listenerIdCounter = 0;
 534      let isDispatching = false;
 535      function ensureCanMutateNextListeners() {
 536        if (nextListeners === currentListeners) {
 537          nextListeners = /* @__PURE__ */ new Map();
 538          currentListeners.forEach((listener, key) => {
 539            nextListeners.set(key, listener);
 540          });
 541        }
 542      }
 543      function getState() {
 544        if (isDispatching) {
 545          throw new Error(false ? formatProdErrorMessage(3) : "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.");
 546        }
 547        return currentState;
 548      }
 549      function subscribe2(listener) {
 550        if (typeof listener !== "function") {
 551          throw new Error(false ? formatProdErrorMessage(4) : `Expected the listener to be a function. Instead, received: '$kindOf(listener)}'`);
 552        }
 553        if (isDispatching) {
 554          throw new Error(false ? formatProdErrorMessage(5) : "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/store#subscribelistener for more details.");
 555        }
 556        let isSubscribed = true;
 557        ensureCanMutateNextListeners();
 558        const listenerId = listenerIdCounter++;
 559        nextListeners.set(listenerId, listener);
 560        return function unsubscribe() {
 561          if (!isSubscribed) {
 562            return;
 563          }
 564          if (isDispatching) {
 565            throw new Error(false ? formatProdErrorMessage(6) : "You may not unsubscribe from a store listener while the reducer is executing. See https://redux.js.org/api/store#subscribelistener for more details.");
 566          }
 567          isSubscribed = false;
 568          ensureCanMutateNextListeners();
 569          nextListeners.delete(listenerId);
 570          currentListeners = null;
 571        };
 572      }
 573      function dispatch3(action) {
 574        if (!isPlainObject(action)) {
 575          throw new Error(false ? formatProdErrorMessage(7) : `Actions must be plain objects. Instead, the actual type was: '$kindOf(action)}'. You may need to add middleware to your store setup to handle dispatching other values, such as 'redux-thunk' to handle dispatching functions. See https://redux.js.org/tutorials/fundamentals/part-4-store#middleware and https://redux.js.org/tutorials/fundamentals/part-6-async-logic#using-the-redux-thunk-middleware for examples.`);
 576        }
 577        if (typeof action.type === "undefined") {
 578          throw new Error(false ? formatProdErrorMessage(8) : 'Actions may not have an undefined "type" property. You may have misspelled an action type string constant.');
 579        }
 580        if (typeof action.type !== "string") {
 581          throw new Error(false ? formatProdErrorMessage(17) : `Action "type" property must be a string. Instead, the actual type was: '$kindOf(action.type)}'. Value was: '$action.type}' (stringified)`);
 582        }
 583        if (isDispatching) {
 584          throw new Error(false ? formatProdErrorMessage(9) : "Reducers may not dispatch actions.");
 585        }
 586        try {
 587          isDispatching = true;
 588          currentState = currentReducer(currentState, action);
 589        } finally {
 590          isDispatching = false;
 591        }
 592        const listeners = currentListeners = nextListeners;
 593        listeners.forEach((listener) => {
 594          listener();
 595        });
 596        return action;
 597      }
 598      function replaceReducer(nextReducer) {
 599        if (typeof nextReducer !== "function") {
 600          throw new Error(false ? formatProdErrorMessage(10) : `Expected the nextReducer to be a function. Instead, received: '$kindOf(nextReducer)}`);
 601        }
 602        currentReducer = nextReducer;
 603        dispatch3({
 604          type: actionTypes_default.REPLACE
 605        });
 606      }
 607      function observable() {
 608        const outerSubscribe = subscribe2;
 609        return {
 610          /**
 611           * The minimal observable subscription method.
 612           * @param observer Any object that can be used as an observer.
 613           * The observer object should have a `next` method.
 614           * @returns An object with an `unsubscribe` method that can
 615           * be used to unsubscribe the observable from the store, and prevent further
 616           * emission of values from the observable.
 617           */
 618          subscribe(observer) {
 619            if (typeof observer !== "object" || observer === null) {
 620              throw new Error(false ? formatProdErrorMessage(11) : `Expected the observer to be an object. Instead, received: '$kindOf(observer)}'`);
 621            }
 622            function observeState() {
 623              const observerAsObserver = observer;
 624              if (observerAsObserver.next) {
 625                observerAsObserver.next(getState());
 626              }
 627            }
 628            observeState();
 629            const unsubscribe = outerSubscribe(observeState);
 630            return {
 631              unsubscribe
 632            };
 633          },
 634          [symbol_observable_default]() {
 635            return this;
 636          }
 637        };
 638      }
 639      dispatch3({
 640        type: actionTypes_default.INIT
 641      });
 642      const store = {
 643        dispatch: dispatch3,
 644        subscribe: subscribe2,
 645        getState,
 646        replaceReducer,
 647        [symbol_observable_default]: observable
 648      };
 649      return store;
 650    }
 651    function compose(...funcs) {
 652      if (funcs.length === 0) {
 653        return (arg) => arg;
 654      }
 655      if (funcs.length === 1) {
 656        return funcs[0];
 657      }
 658      return funcs.reduce((a, b) => (...args) => a(b(...args)));
 659    }
 660    function applyMiddleware(...middlewares) {
 661      return (createStore2) => (reducer, preloadedState) => {
 662        const store = createStore2(reducer, preloadedState);
 663        let dispatch3 = () => {
 664          throw new Error(false ? formatProdErrorMessage(15) : "Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch.");
 665        };
 666        const middlewareAPI = {
 667          getState: store.getState,
 668          dispatch: (action, ...args) => dispatch3(action, ...args)
 669        };
 670        const chain = middlewares.map((middleware) => middleware(middlewareAPI));
 671        dispatch3 = compose(...chain)(store.dispatch);
 672        return {
 673          ...store,
 674          dispatch: dispatch3
 675        };
 676      };
 677    }
 678  
 679    // packages/data/build-module/redux-store/index.mjs
 680    var import_equivalent_key_map2 = __toESM(require_equivalent_key_map(), 1);
 681    var import_redux_routine = __toESM(require_redux_routine(), 1);
 682    var import_compose = __toESM(require_compose(), 1);
 683  
 684    // packages/data/build-module/redux-store/combine-reducers.mjs
 685    function combineReducers(reducers) {
 686      const keys = Object.keys(reducers);
 687      return function combinedReducer(state = {}, action) {
 688        const nextState = {};
 689        let hasChanged = false;
 690        for (const key of keys) {
 691          const reducer = reducers[key];
 692          const prevStateForKey = state[key];
 693          const nextStateForKey = reducer(prevStateForKey, action);
 694          nextState[key] = nextStateForKey;
 695          hasChanged = hasChanged || nextStateForKey !== prevStateForKey;
 696        }
 697        return hasChanged ? nextState : state;
 698      };
 699    }
 700  
 701    // packages/data/build-module/factory.mjs
 702    function createRegistrySelector(registrySelector) {
 703      const selectorsByRegistry = /* @__PURE__ */ new WeakMap();
 704      const wrappedSelector = (...args) => {
 705        let selector = selectorsByRegistry.get(wrappedSelector.registry);
 706        if (!selector) {
 707          selector = registrySelector(wrappedSelector.registry.select);
 708          selectorsByRegistry.set(wrappedSelector.registry, selector);
 709        }
 710        return selector(...args);
 711      };
 712      wrappedSelector.isRegistrySelector = true;
 713      return wrappedSelector;
 714    }
 715    function createRegistryControl(registryControl) {
 716      registryControl.isRegistryControl = true;
 717      return registryControl;
 718    }
 719  
 720    // packages/data/build-module/controls.mjs
 721    var SELECT = "@@data/SELECT";
 722    var RESOLVE_SELECT = "@@data/RESOLVE_SELECT";
 723    var DISPATCH = "@@data/DISPATCH";
 724    function isObject(object) {
 725      return object !== null && typeof object === "object";
 726    }
 727    function select(storeNameOrDescriptor, selectorName, ...args) {
 728      return {
 729        type: SELECT,
 730        storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
 731        selectorName,
 732        args
 733      };
 734    }
 735    function resolveSelect(storeNameOrDescriptor, selectorName, ...args) {
 736      return {
 737        type: RESOLVE_SELECT,
 738        storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
 739        selectorName,
 740        args
 741      };
 742    }
 743    function dispatch(storeNameOrDescriptor, actionName, ...args) {
 744      return {
 745        type: DISPATCH,
 746        storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
 747        actionName,
 748        args
 749      };
 750    }
 751    var controls = { select, resolveSelect, dispatch };
 752    var builtinControls = {
 753      [SELECT]: createRegistryControl(
 754        (registry) => ({ storeKey, selectorName, args }) => registry.select(storeKey)[selectorName](...args)
 755      ),
 756      [RESOLVE_SELECT]: createRegistryControl(
 757        (registry) => ({ storeKey, selectorName, args }) => {
 758          const method = registry.select(storeKey)[selectorName].hasResolver ? "resolveSelect" : "select";
 759          return registry[method](storeKey)[selectorName](
 760            ...args
 761          );
 762        }
 763      ),
 764      [DISPATCH]: createRegistryControl(
 765        (registry) => ({ storeKey, actionName, args }) => registry.dispatch(storeKey)[actionName](...args)
 766      )
 767    };
 768  
 769    // packages/data/build-module/lock-unlock.mjs
 770    var import_private_apis = __toESM(require_private_apis(), 1);
 771    var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
 772      "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
 773      "@wordpress/data"
 774    );
 775  
 776    // node_modules/is-promise/index.mjs
 777    function isPromise(obj) {
 778      return !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
 779    }
 780  
 781    // packages/data/build-module/promise-middleware.mjs
 782    var promiseMiddleware = () => (next) => (action) => {
 783      if (isPromise(action)) {
 784        return action.then((resolvedAction) => {
 785          if (resolvedAction) {
 786            return next(resolvedAction);
 787          }
 788        });
 789      }
 790      return next(action);
 791    };
 792    var promise_middleware_default = promiseMiddleware;
 793  
 794    // packages/data/build-module/resolvers-cache-middleware.mjs
 795    var createResolversCacheMiddleware = (registry, storeName) => () => (next) => (action) => {
 796      const resolvers = registry.select(storeName).getCachedResolvers();
 797      const resolverEntries = Object.entries(resolvers);
 798      resolverEntries.forEach(([selectorName, resolversByArgs]) => {
 799        const resolver = registry.stores[storeName]?.resolvers?.[selectorName];
 800        if (!resolver || !resolver.shouldInvalidate) {
 801          return;
 802        }
 803        resolversByArgs.forEach((value, args) => {
 804          if (value === void 0) {
 805            return;
 806          }
 807          if (value.status !== "finished" && value.status !== "error") {
 808            return;
 809          }
 810          if (!resolver.shouldInvalidate(action, ...args)) {
 811            return;
 812          }
 813          registry.dispatch(storeName).invalidateResolution(selectorName, args);
 814        });
 815      });
 816      return next(action);
 817    };
 818    var resolvers_cache_middleware_default = createResolversCacheMiddleware;
 819  
 820    // packages/data/build-module/redux-store/thunk-middleware.mjs
 821    function createThunkMiddleware(args) {
 822      return () => (next) => (action) => {
 823        if (typeof action === "function") {
 824          return action(args);
 825        }
 826        return next(action);
 827      };
 828    }
 829  
 830    // packages/data/build-module/redux-store/metadata/reducer.mjs
 831    var import_equivalent_key_map = __toESM(require_equivalent_key_map(), 1);
 832  
 833    // packages/data/build-module/redux-store/metadata/utils.mjs
 834    var onSubKey = (actionProperty) => (reducer) => (state = {}, action) => {
 835      const key = action[actionProperty];
 836      if (key === void 0) {
 837        return state;
 838      }
 839      const nextKeyState = reducer(state[key], action);
 840      if (nextKeyState === state[key]) {
 841        return state;
 842      }
 843      return {
 844        ...state,
 845        [key]: nextKeyState
 846      };
 847    };
 848    function selectorArgsToStateKey(args) {
 849      if (args === void 0 || args === null) {
 850        return [];
 851      }
 852      const len = args.length;
 853      let idx = len;
 854      while (idx > 0 && args[idx - 1] === void 0) {
 855        idx--;
 856      }
 857      return idx === len ? args : args.slice(0, idx);
 858    }
 859  
 860    // packages/data/build-module/redux-store/metadata/reducer.mjs
 861    var subKeysIsResolved = onSubKey("selectorName")((state = new import_equivalent_key_map.default(), action) => {
 862      switch (action.type) {
 863        case "START_RESOLUTION": {
 864          const nextState = new import_equivalent_key_map.default(state);
 865          nextState.set(selectorArgsToStateKey(action.args), {
 866            status: "resolving"
 867          });
 868          return nextState;
 869        }
 870        case "FINISH_RESOLUTION": {
 871          const nextState = new import_equivalent_key_map.default(state);
 872          nextState.set(selectorArgsToStateKey(action.args), {
 873            status: "finished"
 874          });
 875          return nextState;
 876        }
 877        case "FAIL_RESOLUTION": {
 878          const nextState = new import_equivalent_key_map.default(state);
 879          nextState.set(selectorArgsToStateKey(action.args), {
 880            status: "error",
 881            error: action.error
 882          });
 883          return nextState;
 884        }
 885        case "START_RESOLUTIONS": {
 886          const nextState = new import_equivalent_key_map.default(state);
 887          for (const resolutionArgs of action.args) {
 888            nextState.set(selectorArgsToStateKey(resolutionArgs), {
 889              status: "resolving"
 890            });
 891          }
 892          return nextState;
 893        }
 894        case "FINISH_RESOLUTIONS": {
 895          const nextState = new import_equivalent_key_map.default(state);
 896          for (const resolutionArgs of action.args) {
 897            nextState.set(selectorArgsToStateKey(resolutionArgs), {
 898              status: "finished"
 899            });
 900          }
 901          return nextState;
 902        }
 903        case "FAIL_RESOLUTIONS": {
 904          const nextState = new import_equivalent_key_map.default(state);
 905          action.args.forEach((resolutionArgs, idx) => {
 906            const resolutionState = {
 907              status: "error",
 908              error: void 0
 909            };
 910            const error = action.errors[idx];
 911            if (error) {
 912              resolutionState.error = error;
 913            }
 914            nextState.set(
 915              selectorArgsToStateKey(resolutionArgs),
 916              resolutionState
 917            );
 918          });
 919          return nextState;
 920        }
 921        case "INVALIDATE_RESOLUTION": {
 922          const nextState = new import_equivalent_key_map.default(state);
 923          nextState.delete(selectorArgsToStateKey(action.args));
 924          return nextState;
 925        }
 926      }
 927      return state;
 928    });
 929    var isResolved = (state = {}, action) => {
 930      switch (action.type) {
 931        case "INVALIDATE_RESOLUTION_FOR_STORE":
 932          return {};
 933        case "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR": {
 934          if (action.selectorName in state) {
 935            const {
 936              [action.selectorName]: removedSelector,
 937              ...restState
 938            } = state;
 939            return restState;
 940          }
 941          return state;
 942        }
 943        case "START_RESOLUTION":
 944        case "FINISH_RESOLUTION":
 945        case "FAIL_RESOLUTION":
 946        case "START_RESOLUTIONS":
 947        case "FINISH_RESOLUTIONS":
 948        case "FAIL_RESOLUTIONS":
 949        case "INVALIDATE_RESOLUTION":
 950          return subKeysIsResolved(state, action);
 951        default:
 952          return state;
 953      }
 954    };
 955    var reducer_default = isResolved;
 956  
 957    // packages/data/build-module/redux-store/metadata/selectors.mjs
 958    var selectors_exports = {};
 959    __export(selectors_exports, {
 960      countSelectorsByStatus: () => countSelectorsByStatus,
 961      getCachedResolvers: () => getCachedResolvers,
 962      getIsResolving: () => getIsResolving,
 963      getResolutionError: () => getResolutionError,
 964      getResolutionState: () => getResolutionState,
 965      hasFinishedResolution: () => hasFinishedResolution,
 966      hasResolutionFailed: () => hasResolutionFailed,
 967      hasResolvingSelectors: () => hasResolvingSelectors,
 968      hasStartedResolution: () => hasStartedResolution,
 969      isResolving: () => isResolving
 970    });
 971    var import_deprecated = __toESM(require_deprecated(), 1);
 972  
 973    // node_modules/rememo/rememo.js
 974    var LEAF_KEY = {};
 975    function arrayOf(value) {
 976      return [value];
 977    }
 978    function isObjectLike(value) {
 979      return !!value && "object" === typeof value;
 980    }
 981    function createCache() {
 982      var cache = {
 983        clear: function() {
 984          cache.head = null;
 985        }
 986      };
 987      return cache;
 988    }
 989    function isShallowEqual(a, b, fromIndex) {
 990      var i;
 991      if (a.length !== b.length) {
 992        return false;
 993      }
 994      for (i = fromIndex; i < a.length; i++) {
 995        if (a[i] !== b[i]) {
 996          return false;
 997        }
 998      }
 999      return true;
1000    }
1001    function rememo_default(selector, getDependants) {
1002      var rootCache;
1003      var normalizedGetDependants = getDependants ? getDependants : arrayOf;
1004      function getCache(dependants) {
1005        var caches = rootCache, isUniqueByDependants = true, i, dependant, map, cache;
1006        for (i = 0; i < dependants.length; i++) {
1007          dependant = dependants[i];
1008          if (!isObjectLike(dependant)) {
1009            isUniqueByDependants = false;
1010            break;
1011          }
1012          if (caches.has(dependant)) {
1013            caches = caches.get(dependant);
1014          } else {
1015            map = /* @__PURE__ */ new WeakMap();
1016            caches.set(dependant, map);
1017            caches = map;
1018          }
1019        }
1020        if (!caches.has(LEAF_KEY)) {
1021          cache = createCache();
1022          cache.isUniqueByDependants = isUniqueByDependants;
1023          caches.set(LEAF_KEY, cache);
1024        }
1025        return caches.get(LEAF_KEY);
1026      }
1027      function clear() {
1028        rootCache = /* @__PURE__ */ new WeakMap();
1029      }
1030      function callSelector() {
1031        var len = arguments.length, cache, node, i, args, dependants;
1032        args = new Array(len);
1033        for (i = 0; i < len; i++) {
1034          args[i] = arguments[i];
1035        }
1036        dependants = normalizedGetDependants.apply(null, args);
1037        cache = getCache(dependants);
1038        if (!cache.isUniqueByDependants) {
1039          if (cache.lastDependants && !isShallowEqual(dependants, cache.lastDependants, 0)) {
1040            cache.clear();
1041          }
1042          cache.lastDependants = dependants;
1043        }
1044        node = cache.head;
1045        while (node) {
1046          if (!isShallowEqual(node.args, args, 1)) {
1047            node = node.next;
1048            continue;
1049          }
1050          if (node !== cache.head) {
1051            node.prev.next = node.next;
1052            if (node.next) {
1053              node.next.prev = node.prev;
1054            }
1055            node.next = cache.head;
1056            node.prev = null;
1057            cache.head.prev = node;
1058            cache.head = node;
1059          }
1060          return node.val;
1061        }
1062        node = /** @type {CacheNode} */
1063        {
1064          // Generate the result from original function
1065          val: selector.apply(null, args)
1066        };
1067        args[0] = null;
1068        node.args = args;
1069        if (cache.head) {
1070          cache.head.prev = node;
1071          node.next = cache.head;
1072        }
1073        cache.head = node;
1074        return node.val;
1075      }
1076      callSelector.getDependants = normalizedGetDependants;
1077      callSelector.clear = clear;
1078      clear();
1079      return (
1080        /** @type {S & EnhancedSelector} */
1081        callSelector
1082      );
1083    }
1084  
1085    // packages/data/build-module/redux-store/metadata/selectors.mjs
1086    function getResolutionState(state, selectorName, args) {
1087      const map = state[selectorName];
1088      if (!map) {
1089        return;
1090      }
1091      return map.get(selectorArgsToStateKey(args));
1092    }
1093    function getIsResolving(state, selectorName, args) {
1094      (0, import_deprecated.default)("wp.data.select( store ).getIsResolving", {
1095        since: "6.6",
1096        version: "6.8",
1097        alternative: "wp.data.select( store ).getResolutionState"
1098      });
1099      const resolutionState = getResolutionState(state, selectorName, args);
1100      return resolutionState && resolutionState.status === "resolving";
1101    }
1102    function hasStartedResolution(state, selectorName, args) {
1103      return getResolutionState(state, selectorName, args) !== void 0;
1104    }
1105    function hasFinishedResolution(state, selectorName, args) {
1106      const status = getResolutionState(state, selectorName, args)?.status;
1107      return status === "finished" || status === "error";
1108    }
1109    function hasResolutionFailed(state, selectorName, args) {
1110      return getResolutionState(state, selectorName, args)?.status === "error";
1111    }
1112    function getResolutionError(state, selectorName, args) {
1113      const resolutionState = getResolutionState(state, selectorName, args);
1114      return resolutionState?.status === "error" ? resolutionState.error : null;
1115    }
1116    function isResolving(state, selectorName, args) {
1117      return getResolutionState(state, selectorName, args)?.status === "resolving";
1118    }
1119    function getCachedResolvers(state) {
1120      return state;
1121    }
1122    function hasResolvingSelectors(state) {
1123      return Object.values(state).some(
1124        (selectorState) => (
1125          /**
1126           * This uses the internal `_map` property of `EquivalentKeyMap` for
1127           * optimization purposes, since the `EquivalentKeyMap` implementation
1128           * does not support a `.values()` implementation.
1129           *
1130           * @see https://github.com/aduth/equivalent-key-map
1131           */
1132          Array.from(selectorState._map.values()).some(
1133            (resolution) => resolution[1]?.status === "resolving"
1134          )
1135        )
1136      );
1137    }
1138    var countSelectorsByStatus = rememo_default(
1139      (state) => {
1140        const selectorsByStatus = {};
1141        Object.values(state).forEach(
1142          (selectorState) => (
1143            /**
1144             * This uses the internal `_map` property of `EquivalentKeyMap` for
1145             * optimization purposes, since the `EquivalentKeyMap` implementation
1146             * does not support a `.values()` implementation.
1147             *
1148             * @see https://github.com/aduth/equivalent-key-map
1149             */
1150            Array.from(selectorState._map.values()).forEach(
1151              (resolution) => {
1152                const currentStatus = resolution[1]?.status ?? "error";
1153                if (!selectorsByStatus[currentStatus]) {
1154                  selectorsByStatus[currentStatus] = 0;
1155                }
1156                selectorsByStatus[currentStatus]++;
1157              }
1158            )
1159          )
1160        );
1161        return selectorsByStatus;
1162      },
1163      (state) => [state]
1164    );
1165  
1166    // packages/data/build-module/redux-store/metadata/actions.mjs
1167    var actions_exports = {};
1168    __export(actions_exports, {
1169      failResolution: () => failResolution,
1170      failResolutions: () => failResolutions,
1171      finishResolution: () => finishResolution,
1172      finishResolutions: () => finishResolutions,
1173      invalidateResolution: () => invalidateResolution,
1174      invalidateResolutionForStore: () => invalidateResolutionForStore,
1175      invalidateResolutionForStoreSelector: () => invalidateResolutionForStoreSelector,
1176      startResolution: () => startResolution,
1177      startResolutions: () => startResolutions
1178    });
1179    function startResolution(selectorName, args) {
1180      return {
1181        type: "START_RESOLUTION",
1182        selectorName,
1183        args
1184      };
1185    }
1186    function finishResolution(selectorName, args) {
1187      return {
1188        type: "FINISH_RESOLUTION",
1189        selectorName,
1190        args
1191      };
1192    }
1193    function failResolution(selectorName, args, error) {
1194      return {
1195        type: "FAIL_RESOLUTION",
1196        selectorName,
1197        args,
1198        error
1199      };
1200    }
1201    function startResolutions(selectorName, args) {
1202      return {
1203        type: "START_RESOLUTIONS",
1204        selectorName,
1205        args
1206      };
1207    }
1208    function finishResolutions(selectorName, args) {
1209      return {
1210        type: "FINISH_RESOLUTIONS",
1211        selectorName,
1212        args
1213      };
1214    }
1215    function failResolutions(selectorName, args, errors) {
1216      return {
1217        type: "FAIL_RESOLUTIONS",
1218        selectorName,
1219        args,
1220        errors
1221      };
1222    }
1223    function invalidateResolution(selectorName, args) {
1224      return {
1225        type: "INVALIDATE_RESOLUTION",
1226        selectorName,
1227        args
1228      };
1229    }
1230    function invalidateResolutionForStore() {
1231      return {
1232        type: "INVALIDATE_RESOLUTION_FOR_STORE"
1233      };
1234    }
1235    function invalidateResolutionForStoreSelector(selectorName) {
1236      return {
1237        type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR",
1238        selectorName
1239      };
1240    }
1241  
1242    // packages/data/build-module/redux-store/index.mjs
1243    var trimUndefinedValues = (array) => {
1244      const result = [...array];
1245      for (let i = result.length - 1; i >= 0; i--) {
1246        if (result[i] === void 0) {
1247          result.splice(i, 1);
1248        }
1249      }
1250      return result;
1251    };
1252    var mapValues = (obj, callback) => Object.fromEntries(
1253      Object.entries(obj ?? {}).map(([key, value]) => [
1254        key,
1255        callback(value, key)
1256      ])
1257    );
1258    var devToolsReplacer = (key, state) => {
1259      if (state instanceof Map) {
1260        return Object.fromEntries(state);
1261      }
1262      if (state instanceof window.HTMLElement) {
1263        return null;
1264      }
1265      return state;
1266    };
1267    function createResolversCache() {
1268      const cache = {};
1269      return {
1270        isRunning(selectorName, args) {
1271          return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args));
1272        },
1273        clear(selectorName, args) {
1274          if (cache[selectorName]) {
1275            cache[selectorName].delete(trimUndefinedValues(args));
1276          }
1277        },
1278        markAsRunning(selectorName, args) {
1279          if (!cache[selectorName]) {
1280            cache[selectorName] = new import_equivalent_key_map2.default();
1281          }
1282          cache[selectorName].set(trimUndefinedValues(args), true);
1283        }
1284      };
1285    }
1286    function createBindingCache(getItem, bindItem) {
1287      const cache = /* @__PURE__ */ new WeakMap();
1288      return {
1289        get(itemName) {
1290          const item = getItem(itemName);
1291          if (!item) {
1292            return null;
1293          }
1294          let boundItem = cache.get(item);
1295          if (!boundItem) {
1296            boundItem = bindItem(item, itemName);
1297            cache.set(item, boundItem);
1298          }
1299          return boundItem;
1300        }
1301      };
1302    }
1303    function createPrivateProxy(publicItems, privateItems) {
1304      return new Proxy(publicItems, {
1305        get: (target, itemName) => privateItems.get(itemName) || Reflect.get(target, itemName)
1306      });
1307    }
1308    function createReduxStore(key, options) {
1309      const privateActions = {};
1310      const privateSelectors = {};
1311      const privateRegistrationFunctions = {
1312        privateActions,
1313        registerPrivateActions: (actions) => {
1314          Object.assign(privateActions, actions);
1315        },
1316        privateSelectors,
1317        registerPrivateSelectors: (selectors) => {
1318          Object.assign(privateSelectors, selectors);
1319        }
1320      };
1321      const storeDescriptor = {
1322        name: key,
1323        instantiate: (registry) => {
1324          const listeners = /* @__PURE__ */ new Set();
1325          const reducer = options.reducer;
1326          const thunkArgs = {
1327            registry,
1328            get dispatch() {
1329              return thunkDispatch;
1330            },
1331            get select() {
1332              return thunkSelect;
1333            },
1334            get resolveSelect() {
1335              return resolveSelectors;
1336            }
1337          };
1338          const store = instantiateReduxStore(
1339            key,
1340            options,
1341            registry,
1342            thunkArgs
1343          );
1344          lock(store, privateRegistrationFunctions);
1345          const resolversCache = createResolversCache();
1346          function bindAction(action) {
1347            return (...args) => Promise.resolve(store.dispatch(action(...args)));
1348          }
1349          const actions = {
1350            ...mapValues(actions_exports, bindAction),
1351            ...mapValues(options.actions, bindAction)
1352          };
1353          const allActions = createPrivateProxy(
1354            actions,
1355            createBindingCache(
1356              (name) => privateActions[name],
1357              bindAction
1358            )
1359          );
1360          const thunkDispatch = new Proxy(
1361            (action) => store.dispatch(action),
1362            { get: (target, name) => allActions[name] }
1363          );
1364          lock(actions, allActions);
1365          const resolvers = options.resolvers ? mapValues(options.resolvers, mapResolver) : {};
1366          function bindSelector(selector, selectorName) {
1367            if (selector.isRegistrySelector) {
1368              selector.registry = registry;
1369            }
1370            const boundSelector = (...args) => {
1371              args = normalize(selector, args);
1372              const state = store.__unstableOriginalGetState();
1373              if (selector.isRegistrySelector) {
1374                selector.registry = registry;
1375              }
1376              return selector(state.root, ...args);
1377            };
1378            boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
1379            const resolver = resolvers[selectorName];
1380            if (!resolver) {
1381              boundSelector.hasResolver = false;
1382              return boundSelector;
1383            }
1384            return mapSelectorWithResolver(
1385              boundSelector,
1386              selectorName,
1387              resolver,
1388              store,
1389              resolversCache,
1390              boundMetadataSelectors
1391            );
1392          }
1393          function bindMetadataSelector(metaDataSelector) {
1394            const boundSelector = (selectorName, selectorArgs, ...args) => {
1395              if (selectorName) {
1396                const targetSelector = options.selectors?.[selectorName];
1397                if (targetSelector) {
1398                  selectorArgs = normalize(
1399                    targetSelector,
1400                    selectorArgs
1401                  );
1402                }
1403              }
1404              const state = store.__unstableOriginalGetState();
1405              return metaDataSelector(
1406                state.metadata,
1407                selectorName,
1408                selectorArgs,
1409                ...args
1410              );
1411            };
1412            boundSelector.hasResolver = false;
1413            return boundSelector;
1414          }
1415          const boundMetadataSelectors = mapValues(
1416            selectors_exports,
1417            bindMetadataSelector
1418          );
1419          const boundSelectors = mapValues(options.selectors, bindSelector);
1420          const selectors = {
1421            ...boundMetadataSelectors,
1422            ...boundSelectors
1423          };
1424          const boundPrivateSelectors = createBindingCache(
1425            (name) => privateSelectors[name],
1426            bindSelector
1427          );
1428          const allSelectors = createPrivateProxy(
1429            selectors,
1430            boundPrivateSelectors
1431          );
1432          for (const selectorName of Object.keys(privateSelectors)) {
1433            boundPrivateSelectors.get(selectorName);
1434          }
1435          const thunkSelect = new Proxy(
1436            (selector) => selector(store.__unstableOriginalGetState()),
1437            { get: (target, name) => allSelectors[name] }
1438          );
1439          lock(selectors, allSelectors);
1440          const bindResolveSelector = mapResolveSelector(
1441            store,
1442            resolvers,
1443            boundMetadataSelectors
1444          );
1445          const resolveSelectors = mapValues(
1446            boundSelectors,
1447            bindResolveSelector
1448          );
1449          const allResolveSelectors = createPrivateProxy(
1450            resolveSelectors,
1451            createBindingCache(
1452              (name) => boundPrivateSelectors.get(name),
1453              bindResolveSelector
1454            )
1455          );
1456          lock(resolveSelectors, allResolveSelectors);
1457          const bindSuspendSelector = mapSuspendSelector(
1458            store,
1459            boundMetadataSelectors
1460          );
1461          const suspendSelectors = {
1462            ...boundMetadataSelectors,
1463            // no special suspense behavior
1464            ...mapValues(boundSelectors, bindSuspendSelector)
1465          };
1466          const allSuspendSelectors = createPrivateProxy(
1467            suspendSelectors,
1468            createBindingCache(
1469              (name) => boundPrivateSelectors.get(name),
1470              bindSuspendSelector
1471            )
1472          );
1473          lock(suspendSelectors, allSuspendSelectors);
1474          const getSelectors = () => selectors;
1475          const getActions = () => actions;
1476          const getResolveSelectors = () => resolveSelectors;
1477          const getSuspendSelectors = () => suspendSelectors;
1478          store.__unstableOriginalGetState = store.getState;
1479          store.getState = () => store.__unstableOriginalGetState().root;
1480          const subscribe2 = store && ((listener) => {
1481            listeners.add(listener);
1482            return () => listeners.delete(listener);
1483          });
1484          let lastState = store.__unstableOriginalGetState();
1485          store.subscribe(() => {
1486            const state = store.__unstableOriginalGetState();
1487            const hasChanged = state !== lastState;
1488            lastState = state;
1489            if (hasChanged) {
1490              for (const listener of listeners) {
1491                listener();
1492              }
1493            }
1494          });
1495          return {
1496            reducer,
1497            store,
1498            actions,
1499            selectors,
1500            resolvers,
1501            getSelectors,
1502            getResolveSelectors,
1503            getSuspendSelectors,
1504            getActions,
1505            subscribe: subscribe2
1506          };
1507        }
1508      };
1509      lock(storeDescriptor, privateRegistrationFunctions);
1510      return storeDescriptor;
1511    }
1512    function instantiateReduxStore(key, options, registry, thunkArgs) {
1513      const controls2 = {
1514        ...options.controls,
1515        ...builtinControls
1516      };
1517      const normalizedControls = mapValues(
1518        controls2,
1519        (control) => control.isRegistryControl ? control(registry) : control
1520      );
1521      const middlewares = [
1522        resolvers_cache_middleware_default(registry, key),
1523        promise_middleware_default,
1524        (0, import_redux_routine.default)(normalizedControls),
1525        createThunkMiddleware(thunkArgs)
1526      ];
1527      const enhancers = [applyMiddleware(...middlewares)];
1528      if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
1529        enhancers.push(
1530          window.__REDUX_DEVTOOLS_EXTENSION__({
1531            name: key,
1532            instanceId: key,
1533            serialize: {
1534              replacer: devToolsReplacer
1535            }
1536          })
1537        );
1538      }
1539      const { reducer, initialState } = options;
1540      const enhancedReducer = combineReducers({
1541        metadata: reducer_default,
1542        root: reducer
1543      });
1544      return createStore(
1545        enhancedReducer,
1546        { root: initialState },
1547        (0, import_compose.compose)(enhancers)
1548      );
1549    }
1550    function mapResolveSelector(store, resolvers, boundMetadataSelectors) {
1551      return (selector, selectorName) => {
1552        if (!selector.hasResolver) {
1553          return async (...args) => selector.apply(null, args);
1554        }
1555        return (...args) => new Promise((resolve, reject) => {
1556          const resolver = resolvers[selectorName];
1557          const hasFinished = () => {
1558            return boundMetadataSelectors.hasFinishedResolution(
1559              selectorName,
1560              args
1561            ) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args);
1562          };
1563          const finalize = (result2) => {
1564            const hasFailed = boundMetadataSelectors.hasResolutionFailed(
1565              selectorName,
1566              args
1567            );
1568            if (hasFailed) {
1569              const error = boundMetadataSelectors.getResolutionError(
1570                selectorName,
1571                args
1572              );
1573              reject(error);
1574            } else {
1575              resolve(result2);
1576            }
1577          };
1578          const getResult = () => selector.apply(null, args);
1579          const result = getResult();
1580          if (hasFinished()) {
1581            return finalize(result);
1582          }
1583          const unsubscribe = store.subscribe(() => {
1584            if (hasFinished()) {
1585              unsubscribe();
1586              finalize(getResult());
1587            }
1588          });
1589        });
1590      };
1591    }
1592    function mapSuspendSelector(store, boundMetadataSelectors) {
1593      return (selector, selectorName) => {
1594        if (!selector.hasResolver) {
1595          return selector;
1596        }
1597        return (...args) => {
1598          const result = selector.apply(null, args);
1599          if (boundMetadataSelectors.hasFinishedResolution(
1600            selectorName,
1601            args
1602          )) {
1603            if (boundMetadataSelectors.hasResolutionFailed(
1604              selectorName,
1605              args
1606            )) {
1607              throw boundMetadataSelectors.getResolutionError(
1608                selectorName,
1609                args
1610              );
1611            }
1612            return result;
1613          }
1614          throw new Promise((resolve) => {
1615            const unsubscribe = store.subscribe(() => {
1616              if (boundMetadataSelectors.hasFinishedResolution(
1617                selectorName,
1618                args
1619              )) {
1620                resolve();
1621                unsubscribe();
1622              }
1623            });
1624          });
1625        };
1626      };
1627    }
1628    function mapResolver(resolver) {
1629      if (resolver.fulfill) {
1630        return resolver;
1631      }
1632      return {
1633        ...resolver,
1634        // Copy the enumerable properties of the resolver function.
1635        fulfill: resolver
1636        // Add the fulfill method.
1637      };
1638    }
1639    function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
1640      function fulfillSelector(args) {
1641        if (resolversCache.isRunning(selectorName, args) || boundMetadataSelectors.hasStartedResolution(selectorName, args) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args)) {
1642          return;
1643        }
1644        resolversCache.markAsRunning(selectorName, args);
1645        setTimeout(async () => {
1646          resolversCache.clear(selectorName, args);
1647          store.dispatch(
1648            startResolution(selectorName, args)
1649          );
1650          try {
1651            const action = resolver.fulfill(...args);
1652            if (action) {
1653              await store.dispatch(action);
1654            }
1655            store.dispatch(
1656              finishResolution(selectorName, args)
1657            );
1658          } catch (error) {
1659            store.dispatch(
1660              failResolution(selectorName, args, error)
1661            );
1662          }
1663        }, 0);
1664      }
1665      const selectorResolver = (...args) => {
1666        args = normalize(selector, args);
1667        fulfillSelector(args);
1668        return selector(...args);
1669      };
1670      selectorResolver.hasResolver = true;
1671      return selectorResolver;
1672    }
1673    function normalize(selector, args) {
1674      if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) {
1675        return selector.__unstableNormalizeArgs(args);
1676      }
1677      return args;
1678    }
1679  
1680    // packages/data/build-module/store/index.mjs
1681    var coreDataStore = {
1682      name: "core/data",
1683      instantiate(registry) {
1684        const getCoreDataSelector = (selectorName) => (key, ...args) => {
1685          return registry.select(key)[selectorName](...args);
1686        };
1687        const getCoreDataAction = (actionName) => (key, ...args) => {
1688          return registry.dispatch(key)[actionName](...args);
1689        };
1690        return {
1691          getSelectors() {
1692            return Object.fromEntries(
1693              [
1694                "getIsResolving",
1695                "hasStartedResolution",
1696                "hasFinishedResolution",
1697                "isResolving",
1698                "getCachedResolvers"
1699              ].map((selectorName) => [
1700                selectorName,
1701                getCoreDataSelector(selectorName)
1702              ])
1703            );
1704          },
1705          getActions() {
1706            return Object.fromEntries(
1707              [
1708                "startResolution",
1709                "finishResolution",
1710                "invalidateResolution",
1711                "invalidateResolutionForStore",
1712                "invalidateResolutionForStoreSelector"
1713              ].map((actionName) => [
1714                actionName,
1715                getCoreDataAction(actionName)
1716              ])
1717            );
1718          },
1719          subscribe() {
1720            return () => () => {
1721            };
1722          }
1723        };
1724      }
1725    };
1726    var store_default = coreDataStore;
1727  
1728    // packages/data/build-module/utils/emitter.mjs
1729    function createEmitter() {
1730      let isPaused = false;
1731      let isPending = false;
1732      const listeners = /* @__PURE__ */ new Set();
1733      const notifyListeners = () => (
1734        // We use Array.from to clone the listeners Set
1735        // This ensures that we don't run a listener
1736        // that was added as a response to another listener.
1737        Array.from(listeners).forEach((listener) => listener())
1738      );
1739      return {
1740        get isPaused() {
1741          return isPaused;
1742        },
1743        subscribe(listener) {
1744          listeners.add(listener);
1745          return () => listeners.delete(listener);
1746        },
1747        pause() {
1748          isPaused = true;
1749        },
1750        resume() {
1751          isPaused = false;
1752          if (isPending) {
1753            isPending = false;
1754            notifyListeners();
1755          }
1756        },
1757        emit() {
1758          if (isPaused) {
1759            isPending = true;
1760            return;
1761          }
1762          notifyListeners();
1763        }
1764      };
1765    }
1766  
1767    // packages/data/build-module/registry.mjs
1768    function getStoreName(storeNameOrDescriptor) {
1769      return typeof storeNameOrDescriptor === "string" ? storeNameOrDescriptor : storeNameOrDescriptor.name;
1770    }
1771    function createRegistry(storeConfigs = {}, parent = null) {
1772      const stores = {};
1773      const emitter = createEmitter();
1774      let listeningStores = null;
1775      function globalListener() {
1776        emitter.emit();
1777      }
1778      const subscribe2 = (listener, storeNameOrDescriptor) => {
1779        if (!storeNameOrDescriptor) {
1780          return emitter.subscribe(listener);
1781        }
1782        const storeName = getStoreName(storeNameOrDescriptor);
1783        const store = stores[storeName];
1784        if (store) {
1785          return store.subscribe(listener);
1786        }
1787        if (!parent) {
1788          return emitter.subscribe(listener);
1789        }
1790        return parent.subscribe(listener, storeNameOrDescriptor);
1791      };
1792      function select3(storeNameOrDescriptor) {
1793        const storeName = getStoreName(storeNameOrDescriptor);
1794        listeningStores?.add(storeName);
1795        const store = stores[storeName];
1796        if (store) {
1797          return store.getSelectors();
1798        }
1799        return parent?.select(storeName);
1800      }
1801      function __unstableMarkListeningStores(callback, ref) {
1802        listeningStores = /* @__PURE__ */ new Set();
1803        try {
1804          return callback.call(this);
1805        } finally {
1806          ref.current = Array.from(listeningStores);
1807          listeningStores = null;
1808        }
1809      }
1810      function resolveSelect3(storeNameOrDescriptor) {
1811        const storeName = getStoreName(storeNameOrDescriptor);
1812        listeningStores?.add(storeName);
1813        const store = stores[storeName];
1814        if (store) {
1815          return store.getResolveSelectors();
1816        }
1817        return parent && parent.resolveSelect(storeName);
1818      }
1819      function suspendSelect2(storeNameOrDescriptor) {
1820        const storeName = getStoreName(storeNameOrDescriptor);
1821        listeningStores?.add(storeName);
1822        const store = stores[storeName];
1823        if (store) {
1824          return store.getSuspendSelectors();
1825        }
1826        return parent && parent.suspendSelect(storeName);
1827      }
1828      function dispatch3(storeNameOrDescriptor) {
1829        const storeName = getStoreName(storeNameOrDescriptor);
1830        const store = stores[storeName];
1831        if (store) {
1832          return store.getActions();
1833        }
1834        return parent && parent.dispatch(storeName);
1835      }
1836      function withPlugins(attributes) {
1837        return Object.fromEntries(
1838          Object.entries(attributes).map(([key, attribute]) => {
1839            if (typeof attribute !== "function") {
1840              return [key, attribute];
1841            }
1842            return [
1843              key,
1844              function() {
1845                return registry[key].apply(null, arguments);
1846              }
1847            ];
1848          })
1849        );
1850      }
1851      function registerStoreInstance(name, createStore2) {
1852        if (stores[name]) {
1853          console.error('Store "' + name + '" is already registered.');
1854          return stores[name];
1855        }
1856        const store = createStore2();
1857        if (typeof store.getSelectors !== "function") {
1858          throw new TypeError("store.getSelectors must be a function");
1859        }
1860        if (typeof store.getActions !== "function") {
1861          throw new TypeError("store.getActions must be a function");
1862        }
1863        if (typeof store.subscribe !== "function") {
1864          throw new TypeError("store.subscribe must be a function");
1865        }
1866        store.emitter = createEmitter();
1867        const currentSubscribe = store.subscribe;
1868        store.subscribe = (listener) => {
1869          const unsubscribeFromEmitter = store.emitter.subscribe(listener);
1870          const unsubscribeFromStore = currentSubscribe(() => {
1871            if (store.emitter.isPaused) {
1872              store.emitter.emit();
1873              return;
1874            }
1875            listener();
1876          });
1877          return () => {
1878            unsubscribeFromStore?.();
1879            unsubscribeFromEmitter?.();
1880          };
1881        };
1882        stores[name] = store;
1883        store.subscribe(globalListener);
1884        if (parent) {
1885          try {
1886            unlock(store.store).registerPrivateActions(
1887              unlock(parent).privateActionsOf(name)
1888            );
1889            unlock(store.store).registerPrivateSelectors(
1890              unlock(parent).privateSelectorsOf(name)
1891            );
1892          } catch (e) {
1893          }
1894        }
1895        return store;
1896      }
1897      function register2(store) {
1898        registerStoreInstance(
1899          store.name,
1900          () => store.instantiate(registry)
1901        );
1902      }
1903      function registerGenericStore2(name, store) {
1904        (0, import_deprecated2.default)("wp.data.registerGenericStore", {
1905          since: "5.9",
1906          alternative: "wp.data.register( storeDescriptor )"
1907        });
1908        registerStoreInstance(name, () => store);
1909      }
1910      function registerStore2(storeName, options) {
1911        if (!options.reducer) {
1912          throw new TypeError("Must specify store reducer");
1913        }
1914        const store = registerStoreInstance(
1915          storeName,
1916          () => createReduxStore(storeName, options).instantiate(registry)
1917        );
1918        return store.store;
1919      }
1920      function batch(callback) {
1921        if (emitter.isPaused) {
1922          callback();
1923          return;
1924        }
1925        emitter.pause();
1926        Object.values(stores).forEach((store) => store.emitter.pause());
1927        try {
1928          callback();
1929        } finally {
1930          emitter.resume();
1931          Object.values(stores).forEach(
1932            (store) => store.emitter.resume()
1933          );
1934        }
1935      }
1936      let registry = {
1937        batch,
1938        stores,
1939        namespaces: stores,
1940        // TODO: Deprecate/remove this.
1941        subscribe: subscribe2,
1942        select: select3,
1943        resolveSelect: resolveSelect3,
1944        suspendSelect: suspendSelect2,
1945        dispatch: dispatch3,
1946        use: use2,
1947        register: register2,
1948        registerGenericStore: registerGenericStore2,
1949        registerStore: registerStore2,
1950        __unstableMarkListeningStores
1951      };
1952      function use2(plugin, options) {
1953        if (!plugin) {
1954          return;
1955        }
1956        registry = {
1957          ...registry,
1958          ...plugin(registry, options)
1959        };
1960        return registry;
1961      }
1962      registry.register(store_default);
1963      for (const [name, config] of Object.entries(storeConfigs)) {
1964        registry.register(createReduxStore(name, config));
1965      }
1966      if (parent) {
1967        parent.subscribe(globalListener);
1968      }
1969      const registryWithPlugins = withPlugins(registry);
1970      lock(registryWithPlugins, {
1971        privateActionsOf: (name) => {
1972          try {
1973            return unlock(stores[name].store).privateActions;
1974          } catch (e) {
1975            return {};
1976          }
1977        },
1978        privateSelectorsOf: (name) => {
1979          try {
1980            return unlock(stores[name].store).privateSelectors;
1981          } catch (e) {
1982            return {};
1983          }
1984        }
1985      });
1986      return registryWithPlugins;
1987    }
1988  
1989    // packages/data/build-module/default-registry.mjs
1990    var default_registry_default = createRegistry();
1991  
1992    // packages/data/build-module/plugins/index.mjs
1993    var plugins_exports = {};
1994    __export(plugins_exports, {
1995      persistence: () => persistence_default
1996    });
1997  
1998    // node_modules/is-plain-object/dist/is-plain-object.mjs
1999    function isObject2(o) {
2000      return Object.prototype.toString.call(o) === "[object Object]";
2001    }
2002    function isPlainObject2(o) {
2003      var ctor, prot;
2004      if (isObject2(o) === false) return false;
2005      ctor = o.constructor;
2006      if (ctor === void 0) return true;
2007      prot = ctor.prototype;
2008      if (isObject2(prot) === false) return false;
2009      if (prot.hasOwnProperty("isPrototypeOf") === false) {
2010        return false;
2011      }
2012      return true;
2013    }
2014  
2015    // packages/data/build-module/plugins/persistence/index.mjs
2016    var import_deepmerge = __toESM(require_cjs(), 1);
2017  
2018    // packages/data/build-module/plugins/persistence/storage/object.mjs
2019    var objectStorage;
2020    var storage = {
2021      getItem(key) {
2022        if (!objectStorage || !objectStorage[key]) {
2023          return null;
2024        }
2025        return objectStorage[key];
2026      },
2027      setItem(key, value) {
2028        if (!objectStorage) {
2029          storage.clear();
2030        }
2031        objectStorage[key] = String(value);
2032      },
2033      clear() {
2034        objectStorage = /* @__PURE__ */ Object.create(null);
2035      }
2036    };
2037    var object_default = storage;
2038  
2039    // packages/data/build-module/plugins/persistence/storage/default.mjs
2040    var storage2;
2041    try {
2042      storage2 = window.localStorage;
2043      storage2.setItem("__wpDataTestLocalStorage", "");
2044      storage2.removeItem("__wpDataTestLocalStorage");
2045    } catch (error) {
2046      storage2 = object_default;
2047    }
2048    var default_default = storage2;
2049  
2050    // packages/data/build-module/plugins/persistence/index.mjs
2051    var DEFAULT_STORAGE = default_default;
2052    var DEFAULT_STORAGE_KEY = "WP_DATA";
2053    var withLazySameState = (reducer) => (state, action) => {
2054      if (action.nextState === state) {
2055        return state;
2056      }
2057      return reducer(state, action);
2058    };
2059    function createPersistenceInterface(options) {
2060      const { storage: storage3 = DEFAULT_STORAGE, storageKey = DEFAULT_STORAGE_KEY } = options;
2061      let data;
2062      function getData() {
2063        if (data === void 0) {
2064          const persisted = storage3.getItem(storageKey);
2065          if (persisted === null) {
2066            data = {};
2067          } else {
2068            try {
2069              data = JSON.parse(persisted);
2070            } catch (error) {
2071              data = {};
2072            }
2073          }
2074        }
2075        return data;
2076      }
2077      function setData(key, value) {
2078        data = { ...data, [key]: value };
2079        storage3.setItem(storageKey, JSON.stringify(data));
2080      }
2081      return {
2082        get: getData,
2083        set: setData
2084      };
2085    }
2086    function persistencePlugin(registry, pluginOptions) {
2087      const persistence = createPersistenceInterface(pluginOptions);
2088      function createPersistOnChange(getState, storeName, keys) {
2089        let getPersistedState;
2090        if (Array.isArray(keys)) {
2091          const reducers = keys.reduce(
2092            (accumulator, key) => Object.assign(accumulator, {
2093              [key]: (state, action) => action.nextState[key]
2094            }),
2095            {}
2096          );
2097          getPersistedState = withLazySameState(
2098            combineReducers2(reducers)
2099          );
2100        } else {
2101          getPersistedState = (state, action) => action.nextState;
2102        }
2103        let lastState = getPersistedState(void 0, {
2104          nextState: getState()
2105        });
2106        return () => {
2107          const state = getPersistedState(lastState, {
2108            nextState: getState()
2109          });
2110          if (state !== lastState) {
2111            persistence.set(storeName, state);
2112            lastState = state;
2113          }
2114        };
2115      }
2116      return {
2117        registerStore(storeName, options) {
2118          if (!options.persist) {
2119            return registry.registerStore(storeName, options);
2120          }
2121          const persistedState = persistence.get()[storeName];
2122          if (persistedState !== void 0) {
2123            let initialState = options.reducer(options.initialState, {
2124              type: "@@WP/PERSISTENCE_RESTORE"
2125            });
2126            if (isPlainObject2(initialState) && isPlainObject2(persistedState)) {
2127              initialState = (0, import_deepmerge.default)(initialState, persistedState, {
2128                isMergeableObject: isPlainObject2
2129              });
2130            } else {
2131              initialState = persistedState;
2132            }
2133            options = {
2134              ...options,
2135              initialState
2136            };
2137          }
2138          const store = registry.registerStore(storeName, options);
2139          store.subscribe(
2140            createPersistOnChange(
2141              store.getState,
2142              storeName,
2143              options.persist
2144            )
2145          );
2146          return store;
2147        }
2148      };
2149    }
2150    persistencePlugin.__unstableMigrate = () => {
2151    };
2152    var persistence_default = persistencePlugin;
2153  
2154    // packages/data/build-module/components/with-select/index.mjs
2155    var import_compose2 = __toESM(require_compose(), 1);
2156  
2157    // packages/data/build-module/components/use-select/index.mjs
2158    var import_priority_queue = __toESM(require_priority_queue(), 1);
2159    var import_element5 = __toESM(require_element(), 1);
2160    var import_is_shallow_equal = __toESM(require_is_shallow_equal(), 1);
2161  
2162    // packages/data/build-module/components/registry-provider/use-registry.mjs
2163    var import_element2 = __toESM(require_element(), 1);
2164  
2165    // packages/data/build-module/components/registry-provider/context.mjs
2166    var import_element = __toESM(require_element(), 1);
2167    var Context = (0, import_element.createContext)(default_registry_default);
2168    Context.displayName = "RegistryProviderContext";
2169    var { Consumer, Provider } = Context;
2170    var RegistryConsumer = Consumer;
2171    var context_default = Provider;
2172  
2173    // packages/data/build-module/components/registry-provider/use-registry.mjs
2174    function useRegistry() {
2175      return (0, import_element2.useContext)(Context);
2176    }
2177  
2178    // packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2179    var import_element4 = __toESM(require_element(), 1);
2180  
2181    // packages/data/build-module/components/async-mode-provider/context.mjs
2182    var import_element3 = __toESM(require_element(), 1);
2183    var Context2 = (0, import_element3.createContext)(false);
2184    Context2.displayName = "AsyncModeContext";
2185    var { Consumer: Consumer2, Provider: Provider2 } = Context2;
2186    var context_default2 = Provider2;
2187  
2188    // packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2189    function useAsyncMode() {
2190      return (0, import_element4.useContext)(Context2);
2191    }
2192  
2193    // packages/data/build-module/components/use-select/index.mjs
2194    var renderQueue = (0, import_priority_queue.createQueue)();
2195    function warnOnUnstableReference(a, b) {
2196      if (!a || !b) {
2197        return;
2198      }
2199      const keys = typeof a === "object" && typeof b === "object" ? Object.keys(a).filter((k) => a[k] !== b[k]) : [];
2200      console.warn(
2201        "The `useSelect` hook returns different values when called with the same state and parameters.\nThis can lead to unnecessary re-renders and performance issues if not fixed.\n\nNon-equal value keys: %s\n\n",
2202        keys.join(", ")
2203      );
2204    }
2205    function Store(registry, suspense) {
2206      const select3 = suspense ? registry.suspendSelect : registry.select;
2207      const queueContext = {};
2208      let lastMapSelect;
2209      let lastMapResult;
2210      let lastMapResultValid = false;
2211      let lastIsAsync;
2212      let subscriber;
2213      let didWarnUnstableReference;
2214      const storeStatesOnMount = /* @__PURE__ */ new Map();
2215      function getStoreState(name) {
2216        return registry.stores[name]?.store?.getState?.() ?? {};
2217      }
2218      const createSubscriber = (stores) => {
2219        const activeStores = [...stores];
2220        const activeSubscriptions = /* @__PURE__ */ new Set();
2221        function subscribe2(listener) {
2222          if (lastMapResultValid) {
2223            for (const name of activeStores) {
2224              if (storeStatesOnMount.get(name) !== getStoreState(name)) {
2225                lastMapResultValid = false;
2226              }
2227            }
2228          }
2229          storeStatesOnMount.clear();
2230          const onStoreChange = () => {
2231            lastMapResultValid = false;
2232            listener();
2233          };
2234          const onChange = () => {
2235            if (lastIsAsync) {
2236              renderQueue.add(queueContext, onStoreChange);
2237            } else {
2238              onStoreChange();
2239            }
2240          };
2241          const unsubs = [];
2242          function subscribeStore(storeName) {
2243            unsubs.push(registry.subscribe(onChange, storeName));
2244          }
2245          for (const storeName of activeStores) {
2246            subscribeStore(storeName);
2247          }
2248          activeSubscriptions.add(subscribeStore);
2249          return () => {
2250            activeSubscriptions.delete(subscribeStore);
2251            for (const unsub of unsubs.values()) {
2252              unsub?.();
2253            }
2254            renderQueue.cancel(queueContext);
2255          };
2256        }
2257        function updateStores(newStores) {
2258          for (const newStore of newStores) {
2259            if (activeStores.includes(newStore)) {
2260              continue;
2261            }
2262            activeStores.push(newStore);
2263            for (const subscription of activeSubscriptions) {
2264              subscription(newStore);
2265            }
2266          }
2267        }
2268        return { subscribe: subscribe2, updateStores };
2269      };
2270      return (mapSelect, isAsync) => {
2271        function updateValue() {
2272          if (lastMapResultValid && mapSelect === lastMapSelect) {
2273            return lastMapResult;
2274          }
2275          const listeningStores = { current: null };
2276          const mapResult = registry.__unstableMarkListeningStores(
2277            () => mapSelect(select3, registry),
2278            listeningStores
2279          );
2280          if (true) {
2281            if (!didWarnUnstableReference) {
2282              const secondMapResult = mapSelect(select3, registry);
2283              if (!(0, import_is_shallow_equal.isShallowEqual)(mapResult, secondMapResult)) {
2284                warnOnUnstableReference(mapResult, secondMapResult);
2285                didWarnUnstableReference = true;
2286              }
2287            }
2288          }
2289          if (!subscriber) {
2290            for (const name of listeningStores.current) {
2291              storeStatesOnMount.set(name, getStoreState(name));
2292            }
2293            subscriber = createSubscriber(listeningStores.current);
2294          } else {
2295            subscriber.updateStores(listeningStores.current);
2296          }
2297          if (!(0, import_is_shallow_equal.isShallowEqual)(lastMapResult, mapResult)) {
2298            lastMapResult = mapResult;
2299          }
2300          lastMapSelect = mapSelect;
2301          lastMapResultValid = true;
2302        }
2303        function getValue() {
2304          updateValue();
2305          return lastMapResult;
2306        }
2307        if (lastIsAsync && !isAsync) {
2308          lastMapResultValid = false;
2309          renderQueue.cancel(queueContext);
2310        }
2311        updateValue();
2312        lastIsAsync = isAsync;
2313        return { subscribe: subscriber.subscribe, getValue };
2314      };
2315    }
2316    function _useStaticSelect(storeName) {
2317      return useRegistry().select(storeName);
2318    }
2319    function _useMappingSelect(suspense, mapSelect, deps) {
2320      const registry = useRegistry();
2321      const isAsync = useAsyncMode();
2322      const store = (0, import_element5.useMemo)(
2323        () => Store(registry, suspense),
2324        [registry, suspense]
2325      );
2326      const selector = (0, import_element5.useCallback)(mapSelect, deps);
2327      const { subscribe: subscribe2, getValue } = store(selector, isAsync);
2328      const result = (0, import_element5.useSyncExternalStore)(subscribe2, getValue, getValue);
2329      (0, import_element5.useDebugValue)(result);
2330      return result;
2331    }
2332    function useSelect(mapSelect, deps) {
2333      const staticSelectMode = typeof mapSelect !== "function";
2334      const staticSelectModeRef = (0, import_element5.useRef)(staticSelectMode);
2335      if (staticSelectMode !== staticSelectModeRef.current) {
2336        const prevMode = staticSelectModeRef.current ? "static" : "mapping";
2337        const nextMode = staticSelectMode ? "static" : "mapping";
2338        throw new Error(
2339          `Switching useSelect from $prevMode} to $nextMode} is not allowed`
2340        );
2341      }
2342      return staticSelectMode ? _useStaticSelect(mapSelect) : _useMappingSelect(false, mapSelect, deps);
2343    }
2344    function useSuspenseSelect(mapSelect, deps) {
2345      return _useMappingSelect(true, mapSelect, deps);
2346    }
2347  
2348    // packages/data/build-module/components/with-select/index.mjs
2349    var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
2350    var withSelect = (mapSelectToProps) => (0, import_compose2.createHigherOrderComponent)(
2351      (WrappedComponent) => (0, import_compose2.pure)((ownProps) => {
2352        const mapSelect = (select3, registry) => mapSelectToProps(select3, ownProps, registry);
2353        const mergeProps = useSelect(mapSelect);
2354        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WrappedComponent, { ...ownProps, ...mergeProps });
2355      }),
2356      "withSelect"
2357    );
2358    var with_select_default = withSelect;
2359  
2360    // packages/data/build-module/components/with-dispatch/index.mjs
2361    var import_compose4 = __toESM(require_compose(), 1);
2362  
2363    // packages/data/build-module/components/use-dispatch/use-dispatch.mjs
2364    var useDispatch = (storeNameOrDescriptor) => {
2365      const { dispatch: dispatch3 } = useRegistry();
2366      return storeNameOrDescriptor === void 0 ? dispatch3 : dispatch3(storeNameOrDescriptor);
2367    };
2368    var use_dispatch_default = useDispatch;
2369  
2370    // packages/data/build-module/components/use-dispatch/use-dispatch-with-map.mjs
2371    var import_element6 = __toESM(require_element(), 1);
2372    var import_compose3 = __toESM(require_compose(), 1);
2373    var useDispatchWithMap = (dispatchMap, deps) => {
2374      const registry = useRegistry();
2375      const currentDispatchMapRef = (0, import_element6.useRef)(dispatchMap);
2376      (0, import_compose3.useIsomorphicLayoutEffect)(() => {
2377        currentDispatchMapRef.current = dispatchMap;
2378      });
2379      return (0, import_element6.useMemo)(() => {
2380        const currentDispatchProps = currentDispatchMapRef.current(
2381          registry.dispatch,
2382          registry
2383        );
2384        return Object.fromEntries(
2385          Object.entries(currentDispatchProps).map(
2386            ([propName, dispatcher]) => {
2387              if (typeof dispatcher !== "function") {
2388                console.warn(
2389                  `Property $propName} returned from dispatchMap in useDispatchWithMap must be a function.`
2390                );
2391              }
2392              return [
2393                propName,
2394                (...args) => currentDispatchMapRef.current(registry.dispatch, registry)[propName](...args)
2395              ];
2396            }
2397          )
2398        );
2399      }, [registry, ...deps]);
2400    };
2401    var use_dispatch_with_map_default = useDispatchWithMap;
2402  
2403    // packages/data/build-module/components/with-dispatch/index.mjs
2404    var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
2405    var withDispatch = (mapDispatchToProps) => (0, import_compose4.createHigherOrderComponent)(
2406      (WrappedComponent) => (ownProps) => {
2407        const mapDispatch = (dispatch3, registry) => mapDispatchToProps(dispatch3, ownProps, registry);
2408        const dispatchProps = use_dispatch_with_map_default(mapDispatch, []);
2409        return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WrappedComponent, { ...ownProps, ...dispatchProps });
2410      },
2411      "withDispatch"
2412    );
2413    var with_dispatch_default = withDispatch;
2414  
2415    // packages/data/build-module/components/with-registry/index.mjs
2416    var import_compose5 = __toESM(require_compose(), 1);
2417    var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
2418    var withRegistry = (0, import_compose5.createHigherOrderComponent)(
2419      (OriginalComponent) => (props) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(RegistryConsumer, { children: (registry) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(OriginalComponent, { ...props, registry }) }),
2420      "withRegistry"
2421    );
2422    var with_registry_default = withRegistry;
2423  
2424    // packages/data/build-module/dispatch.mjs
2425    function dispatch2(storeNameOrDescriptor) {
2426      return default_registry_default.dispatch(storeNameOrDescriptor);
2427    }
2428  
2429    // packages/data/build-module/select.mjs
2430    function select2(storeNameOrDescriptor) {
2431      return default_registry_default.select(storeNameOrDescriptor);
2432    }
2433  
2434    // packages/data/build-module/index.mjs
2435    var defaultRegistry = default_registry_default;
2436    var combineReducers2 = combineReducers;
2437    function resolveSelect2(storeNameOrDescriptor) {
2438      return defaultRegistry.resolveSelect(storeNameOrDescriptor);
2439    }
2440    var suspendSelect = (storeNameOrDescriptor) => defaultRegistry.suspendSelect(storeNameOrDescriptor);
2441    var subscribe = (listener, storeNameOrDescriptor) => defaultRegistry.subscribe(listener, storeNameOrDescriptor);
2442    var registerGenericStore = defaultRegistry.registerGenericStore;
2443    var registerStore = defaultRegistry.registerStore;
2444    var use = defaultRegistry.use;
2445    var register = (store) => defaultRegistry.register(store);
2446    return __toCommonJS(index_exports);
2447  })();
2448  /*! Bundled license information:
2449  
2450  is-plain-object/dist/is-plain-object.mjs:
2451    (*!
2452     * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
2453     *
2454     * Copyright (c) 2014-2017, Jon Schlinkert.
2455     * Released under the MIT License.
2456     *)
2457  */