[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 ? 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.js
 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.js
 440    var import_deprecated2 = __toESM(require_deprecated());
 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.js
 680    var import_equivalent_key_map2 = __toESM(require_equivalent_key_map());
 681    var import_redux_routine = __toESM(require_redux_routine());
 682    var import_compose = __toESM(require_compose());
 683  
 684    // packages/data/build-module/redux-store/combine-reducers.js
 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.js
 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.js
 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.js
 770    var import_private_apis = __toESM(require_private_apis());
 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.js
 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.js
 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.js
 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.js
 831    var import_equivalent_key_map = __toESM(require_equivalent_key_map());
 832  
 833    // packages/data/build-module/redux-store/metadata/utils.js
 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.js
 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      }
 952      return state;
 953    };
 954    var reducer_default = isResolved;
 955  
 956    // packages/data/build-module/redux-store/metadata/selectors.js
 957    var selectors_exports = {};
 958    __export(selectors_exports, {
 959      countSelectorsByStatus: () => countSelectorsByStatus,
 960      getCachedResolvers: () => getCachedResolvers,
 961      getIsResolving: () => getIsResolving,
 962      getResolutionError: () => getResolutionError,
 963      getResolutionState: () => getResolutionState,
 964      hasFinishedResolution: () => hasFinishedResolution,
 965      hasResolutionFailed: () => hasResolutionFailed,
 966      hasResolvingSelectors: () => hasResolvingSelectors,
 967      hasStartedResolution: () => hasStartedResolution,
 968      isResolving: () => isResolving
 969    });
 970    var import_deprecated = __toESM(require_deprecated());
 971  
 972    // node_modules/rememo/rememo.js
 973    var LEAF_KEY = {};
 974    function arrayOf(value) {
 975      return [value];
 976    }
 977    function isObjectLike(value) {
 978      return !!value && "object" === typeof value;
 979    }
 980    function createCache() {
 981      var cache = {
 982        clear: function() {
 983          cache.head = null;
 984        }
 985      };
 986      return cache;
 987    }
 988    function isShallowEqual(a, b, fromIndex) {
 989      var i;
 990      if (a.length !== b.length) {
 991        return false;
 992      }
 993      for (i = fromIndex; i < a.length; i++) {
 994        if (a[i] !== b[i]) {
 995          return false;
 996        }
 997      }
 998      return true;
 999    }
1000    function rememo_default(selector, getDependants) {
1001      var rootCache;
1002      var normalizedGetDependants = getDependants ? getDependants : arrayOf;
1003      function getCache(dependants) {
1004        var caches = rootCache, isUniqueByDependants = true, i, dependant, map, cache;
1005        for (i = 0; i < dependants.length; i++) {
1006          dependant = dependants[i];
1007          if (!isObjectLike(dependant)) {
1008            isUniqueByDependants = false;
1009            break;
1010          }
1011          if (caches.has(dependant)) {
1012            caches = caches.get(dependant);
1013          } else {
1014            map = /* @__PURE__ */ new WeakMap();
1015            caches.set(dependant, map);
1016            caches = map;
1017          }
1018        }
1019        if (!caches.has(LEAF_KEY)) {
1020          cache = createCache();
1021          cache.isUniqueByDependants = isUniqueByDependants;
1022          caches.set(LEAF_KEY, cache);
1023        }
1024        return caches.get(LEAF_KEY);
1025      }
1026      function clear() {
1027        rootCache = /* @__PURE__ */ new WeakMap();
1028      }
1029      function callSelector() {
1030        var len = arguments.length, cache, node, i, args, dependants;
1031        args = new Array(len);
1032        for (i = 0; i < len; i++) {
1033          args[i] = arguments[i];
1034        }
1035        dependants = normalizedGetDependants.apply(null, args);
1036        cache = getCache(dependants);
1037        if (!cache.isUniqueByDependants) {
1038          if (cache.lastDependants && !isShallowEqual(dependants, cache.lastDependants, 0)) {
1039            cache.clear();
1040          }
1041          cache.lastDependants = dependants;
1042        }
1043        node = cache.head;
1044        while (node) {
1045          if (!isShallowEqual(node.args, args, 1)) {
1046            node = node.next;
1047            continue;
1048          }
1049          if (node !== cache.head) {
1050            node.prev.next = node.next;
1051            if (node.next) {
1052              node.next.prev = node.prev;
1053            }
1054            node.next = cache.head;
1055            node.prev = null;
1056            cache.head.prev = node;
1057            cache.head = node;
1058          }
1059          return node.val;
1060        }
1061        node = /** @type {CacheNode} */
1062        {
1063          // Generate the result from original function
1064          val: selector.apply(null, args)
1065        };
1066        args[0] = null;
1067        node.args = args;
1068        if (cache.head) {
1069          cache.head.prev = node;
1070          node.next = cache.head;
1071        }
1072        cache.head = node;
1073        return node.val;
1074      }
1075      callSelector.getDependants = normalizedGetDependants;
1076      callSelector.clear = clear;
1077      clear();
1078      return (
1079        /** @type {S & EnhancedSelector} */
1080        callSelector
1081      );
1082    }
1083  
1084    // packages/data/build-module/redux-store/metadata/selectors.js
1085    function getResolutionState(state, selectorName, args) {
1086      const map = state[selectorName];
1087      if (!map) {
1088        return;
1089      }
1090      return map.get(selectorArgsToStateKey(args));
1091    }
1092    function getIsResolving(state, selectorName, args) {
1093      (0, import_deprecated.default)("wp.data.select( store ).getIsResolving", {
1094        since: "6.6",
1095        version: "6.8",
1096        alternative: "wp.data.select( store ).getResolutionState"
1097      });
1098      const resolutionState = getResolutionState(state, selectorName, args);
1099      return resolutionState && resolutionState.status === "resolving";
1100    }
1101    function hasStartedResolution(state, selectorName, args) {
1102      return getResolutionState(state, selectorName, args) !== void 0;
1103    }
1104    function hasFinishedResolution(state, selectorName, args) {
1105      const status = getResolutionState(state, selectorName, args)?.status;
1106      return status === "finished" || status === "error";
1107    }
1108    function hasResolutionFailed(state, selectorName, args) {
1109      return getResolutionState(state, selectorName, args)?.status === "error";
1110    }
1111    function getResolutionError(state, selectorName, args) {
1112      const resolutionState = getResolutionState(state, selectorName, args);
1113      return resolutionState?.status === "error" ? resolutionState.error : null;
1114    }
1115    function isResolving(state, selectorName, args) {
1116      return getResolutionState(state, selectorName, args)?.status === "resolving";
1117    }
1118    function getCachedResolvers(state) {
1119      return state;
1120    }
1121    function hasResolvingSelectors(state) {
1122      return Object.values(state).some(
1123        (selectorState) => (
1124          /**
1125           * This uses the internal `_map` property of `EquivalentKeyMap` for
1126           * optimization purposes, since the `EquivalentKeyMap` implementation
1127           * does not support a `.values()` implementation.
1128           *
1129           * @see https://github.com/aduth/equivalent-key-map
1130           */
1131          Array.from(selectorState._map.values()).some(
1132            (resolution) => resolution[1]?.status === "resolving"
1133          )
1134        )
1135      );
1136    }
1137    var countSelectorsByStatus = rememo_default(
1138      (state) => {
1139        const selectorsByStatus = {};
1140        Object.values(state).forEach(
1141          (selectorState) => (
1142            /**
1143             * This uses the internal `_map` property of `EquivalentKeyMap` for
1144             * optimization purposes, since the `EquivalentKeyMap` implementation
1145             * does not support a `.values()` implementation.
1146             *
1147             * @see https://github.com/aduth/equivalent-key-map
1148             */
1149            Array.from(selectorState._map.values()).forEach(
1150              (resolution) => {
1151                const currentStatus = resolution[1]?.status ?? "error";
1152                if (!selectorsByStatus[currentStatus]) {
1153                  selectorsByStatus[currentStatus] = 0;
1154                }
1155                selectorsByStatus[currentStatus]++;
1156              }
1157            )
1158          )
1159        );
1160        return selectorsByStatus;
1161      },
1162      (state) => [state]
1163    );
1164  
1165    // packages/data/build-module/redux-store/metadata/actions.js
1166    var actions_exports = {};
1167    __export(actions_exports, {
1168      failResolution: () => failResolution,
1169      failResolutions: () => failResolutions,
1170      finishResolution: () => finishResolution,
1171      finishResolutions: () => finishResolutions,
1172      invalidateResolution: () => invalidateResolution,
1173      invalidateResolutionForStore: () => invalidateResolutionForStore,
1174      invalidateResolutionForStoreSelector: () => invalidateResolutionForStoreSelector,
1175      startResolution: () => startResolution,
1176      startResolutions: () => startResolutions
1177    });
1178    function startResolution(selectorName, args) {
1179      return {
1180        type: "START_RESOLUTION",
1181        selectorName,
1182        args
1183      };
1184    }
1185    function finishResolution(selectorName, args) {
1186      return {
1187        type: "FINISH_RESOLUTION",
1188        selectorName,
1189        args
1190      };
1191    }
1192    function failResolution(selectorName, args, error) {
1193      return {
1194        type: "FAIL_RESOLUTION",
1195        selectorName,
1196        args,
1197        error
1198      };
1199    }
1200    function startResolutions(selectorName, args) {
1201      return {
1202        type: "START_RESOLUTIONS",
1203        selectorName,
1204        args
1205      };
1206    }
1207    function finishResolutions(selectorName, args) {
1208      return {
1209        type: "FINISH_RESOLUTIONS",
1210        selectorName,
1211        args
1212      };
1213    }
1214    function failResolutions(selectorName, args, errors) {
1215      return {
1216        type: "FAIL_RESOLUTIONS",
1217        selectorName,
1218        args,
1219        errors
1220      };
1221    }
1222    function invalidateResolution(selectorName, args) {
1223      return {
1224        type: "INVALIDATE_RESOLUTION",
1225        selectorName,
1226        args
1227      };
1228    }
1229    function invalidateResolutionForStore() {
1230      return {
1231        type: "INVALIDATE_RESOLUTION_FOR_STORE"
1232      };
1233    }
1234    function invalidateResolutionForStoreSelector(selectorName) {
1235      return {
1236        type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR",
1237        selectorName
1238      };
1239    }
1240  
1241    // packages/data/build-module/redux-store/index.js
1242    var trimUndefinedValues = (array) => {
1243      const result = [...array];
1244      for (let i = result.length - 1; i >= 0; i--) {
1245        if (result[i] === void 0) {
1246          result.splice(i, 1);
1247        }
1248      }
1249      return result;
1250    };
1251    var mapValues = (obj, callback) => Object.fromEntries(
1252      Object.entries(obj ?? {}).map(([key, value]) => [
1253        key,
1254        callback(value, key)
1255      ])
1256    );
1257    var devToolsReplacer = (key, state) => {
1258      if (state instanceof Map) {
1259        return Object.fromEntries(state);
1260      }
1261      if (state instanceof window.HTMLElement) {
1262        return null;
1263      }
1264      return state;
1265    };
1266    function createResolversCache() {
1267      const cache = {};
1268      return {
1269        isRunning(selectorName, args) {
1270          return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args));
1271        },
1272        clear(selectorName, args) {
1273          if (cache[selectorName]) {
1274            cache[selectorName].delete(trimUndefinedValues(args));
1275          }
1276        },
1277        markAsRunning(selectorName, args) {
1278          if (!cache[selectorName]) {
1279            cache[selectorName] = new import_equivalent_key_map2.default();
1280          }
1281          cache[selectorName].set(trimUndefinedValues(args), true);
1282        }
1283      };
1284    }
1285    function createBindingCache(getItem, bindItem) {
1286      const cache = /* @__PURE__ */ new WeakMap();
1287      return {
1288        get(itemName) {
1289          const item = getItem(itemName);
1290          if (!item) {
1291            return null;
1292          }
1293          let boundItem = cache.get(item);
1294          if (!boundItem) {
1295            boundItem = bindItem(item, itemName);
1296            cache.set(item, boundItem);
1297          }
1298          return boundItem;
1299        }
1300      };
1301    }
1302    function createPrivateProxy(publicItems, privateItems) {
1303      return new Proxy(publicItems, {
1304        get: (target, itemName) => privateItems.get(itemName) || Reflect.get(target, itemName)
1305      });
1306    }
1307    function createReduxStore(key, options) {
1308      const privateActions = {};
1309      const privateSelectors = {};
1310      const privateRegistrationFunctions = {
1311        privateActions,
1312        registerPrivateActions: (actions) => {
1313          Object.assign(privateActions, actions);
1314        },
1315        privateSelectors,
1316        registerPrivateSelectors: (selectors) => {
1317          Object.assign(privateSelectors, selectors);
1318        }
1319      };
1320      const storeDescriptor = {
1321        name: key,
1322        instantiate: (registry) => {
1323          const listeners = /* @__PURE__ */ new Set();
1324          const reducer = options.reducer;
1325          const thunkArgs = {
1326            registry,
1327            get dispatch() {
1328              return thunkDispatch;
1329            },
1330            get select() {
1331              return thunkSelect;
1332            },
1333            get resolveSelect() {
1334              return resolveSelectors;
1335            }
1336          };
1337          const store = instantiateReduxStore(
1338            key,
1339            options,
1340            registry,
1341            thunkArgs
1342          );
1343          lock(store, privateRegistrationFunctions);
1344          const resolversCache = createResolversCache();
1345          function bindAction(action) {
1346            return (...args) => Promise.resolve(store.dispatch(action(...args)));
1347          }
1348          const actions = {
1349            ...mapValues(actions_exports, bindAction),
1350            ...mapValues(options.actions, bindAction)
1351          };
1352          const allActions = createPrivateProxy(
1353            actions,
1354            createBindingCache(
1355              (name) => privateActions[name],
1356              bindAction
1357            )
1358          );
1359          const thunkDispatch = new Proxy(
1360            (action) => store.dispatch(action),
1361            { get: (target, name) => allActions[name] }
1362          );
1363          lock(actions, allActions);
1364          const resolvers = options.resolvers ? mapValues(options.resolvers, mapResolver) : {};
1365          function bindSelector(selector, selectorName) {
1366            if (selector.isRegistrySelector) {
1367              selector.registry = registry;
1368            }
1369            const boundSelector = (...args) => {
1370              args = normalize(selector, args);
1371              const state = store.__unstableOriginalGetState();
1372              if (selector.isRegistrySelector) {
1373                selector.registry = registry;
1374              }
1375              return selector(state.root, ...args);
1376            };
1377            boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
1378            const resolver = resolvers[selectorName];
1379            if (!resolver) {
1380              boundSelector.hasResolver = false;
1381              return boundSelector;
1382            }
1383            return mapSelectorWithResolver(
1384              boundSelector,
1385              selectorName,
1386              resolver,
1387              store,
1388              resolversCache,
1389              boundMetadataSelectors
1390            );
1391          }
1392          function bindMetadataSelector(metaDataSelector) {
1393            const boundSelector = (selectorName, selectorArgs, ...args) => {
1394              if (selectorName) {
1395                const targetSelector = options.selectors?.[selectorName];
1396                if (targetSelector) {
1397                  selectorArgs = normalize(
1398                    targetSelector,
1399                    selectorArgs
1400                  );
1401                }
1402              }
1403              const state = store.__unstableOriginalGetState();
1404              return metaDataSelector(
1405                state.metadata,
1406                selectorName,
1407                selectorArgs,
1408                ...args
1409              );
1410            };
1411            boundSelector.hasResolver = false;
1412            return boundSelector;
1413          }
1414          const boundMetadataSelectors = mapValues(
1415            selectors_exports,
1416            bindMetadataSelector
1417          );
1418          const boundSelectors = mapValues(options.selectors, bindSelector);
1419          const selectors = {
1420            ...boundMetadataSelectors,
1421            ...boundSelectors
1422          };
1423          const boundPrivateSelectors = createBindingCache(
1424            (name) => privateSelectors[name],
1425            bindSelector
1426          );
1427          const allSelectors = createPrivateProxy(
1428            selectors,
1429            boundPrivateSelectors
1430          );
1431          for (const selectorName of Object.keys(privateSelectors)) {
1432            boundPrivateSelectors.get(selectorName);
1433          }
1434          const thunkSelect = new Proxy(
1435            (selector) => selector(store.__unstableOriginalGetState()),
1436            { get: (target, name) => allSelectors[name] }
1437          );
1438          lock(selectors, allSelectors);
1439          const bindResolveSelector = mapResolveSelector(
1440            store,
1441            boundMetadataSelectors
1442          );
1443          const resolveSelectors = mapValues(
1444            boundSelectors,
1445            bindResolveSelector
1446          );
1447          const allResolveSelectors = createPrivateProxy(
1448            resolveSelectors,
1449            createBindingCache(
1450              (name) => boundPrivateSelectors.get(name),
1451              bindResolveSelector
1452            )
1453          );
1454          lock(resolveSelectors, allResolveSelectors);
1455          const bindSuspendSelector = mapSuspendSelector(
1456            store,
1457            boundMetadataSelectors
1458          );
1459          const suspendSelectors = {
1460            ...boundMetadataSelectors,
1461            // no special suspense behavior
1462            ...mapValues(boundSelectors, bindSuspendSelector)
1463          };
1464          const allSuspendSelectors = createPrivateProxy(
1465            suspendSelectors,
1466            createBindingCache(
1467              (name) => boundPrivateSelectors.get(name),
1468              bindSuspendSelector
1469            )
1470          );
1471          lock(suspendSelectors, allSuspendSelectors);
1472          const getSelectors = () => selectors;
1473          const getActions = () => actions;
1474          const getResolveSelectors = () => resolveSelectors;
1475          const getSuspendSelectors = () => suspendSelectors;
1476          store.__unstableOriginalGetState = store.getState;
1477          store.getState = () => store.__unstableOriginalGetState().root;
1478          const subscribe2 = store && ((listener) => {
1479            listeners.add(listener);
1480            return () => listeners.delete(listener);
1481          });
1482          let lastState = store.__unstableOriginalGetState();
1483          store.subscribe(() => {
1484            const state = store.__unstableOriginalGetState();
1485            const hasChanged = state !== lastState;
1486            lastState = state;
1487            if (hasChanged) {
1488              for (const listener of listeners) {
1489                listener();
1490              }
1491            }
1492          });
1493          return {
1494            reducer,
1495            store,
1496            actions,
1497            selectors,
1498            resolvers,
1499            getSelectors,
1500            getResolveSelectors,
1501            getSuspendSelectors,
1502            getActions,
1503            subscribe: subscribe2
1504          };
1505        }
1506      };
1507      lock(storeDescriptor, privateRegistrationFunctions);
1508      return storeDescriptor;
1509    }
1510    function instantiateReduxStore(key, options, registry, thunkArgs) {
1511      const controls2 = {
1512        ...options.controls,
1513        ...builtinControls
1514      };
1515      const normalizedControls = mapValues(
1516        controls2,
1517        (control) => control.isRegistryControl ? control(registry) : control
1518      );
1519      const middlewares = [
1520        resolvers_cache_middleware_default(registry, key),
1521        promise_middleware_default,
1522        (0, import_redux_routine.default)(normalizedControls),
1523        createThunkMiddleware(thunkArgs)
1524      ];
1525      const enhancers = [applyMiddleware(...middlewares)];
1526      if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
1527        enhancers.push(
1528          window.__REDUX_DEVTOOLS_EXTENSION__({
1529            name: key,
1530            instanceId: key,
1531            serialize: {
1532              replacer: devToolsReplacer
1533            }
1534          })
1535        );
1536      }
1537      const { reducer, initialState } = options;
1538      const enhancedReducer = combineReducers({
1539        metadata: reducer_default,
1540        root: reducer
1541      });
1542      return createStore(
1543        enhancedReducer,
1544        { root: initialState },
1545        (0, import_compose.compose)(enhancers)
1546      );
1547    }
1548    function mapResolveSelector(store, boundMetadataSelectors) {
1549      return (selector, selectorName) => {
1550        if (!selector.hasResolver) {
1551          return async (...args) => selector.apply(null, args);
1552        }
1553        return (...args) => new Promise((resolve, reject) => {
1554          const hasFinished = () => {
1555            return boundMetadataSelectors.hasFinishedResolution(
1556              selectorName,
1557              args
1558            );
1559          };
1560          const finalize = (result2) => {
1561            const hasFailed = boundMetadataSelectors.hasResolutionFailed(
1562              selectorName,
1563              args
1564            );
1565            if (hasFailed) {
1566              const error = boundMetadataSelectors.getResolutionError(
1567                selectorName,
1568                args
1569              );
1570              reject(error);
1571            } else {
1572              resolve(result2);
1573            }
1574          };
1575          const getResult = () => selector.apply(null, args);
1576          const result = getResult();
1577          if (hasFinished()) {
1578            return finalize(result);
1579          }
1580          const unsubscribe = store.subscribe(() => {
1581            if (hasFinished()) {
1582              unsubscribe();
1583              finalize(getResult());
1584            }
1585          });
1586        });
1587      };
1588    }
1589    function mapSuspendSelector(store, boundMetadataSelectors) {
1590      return (selector, selectorName) => {
1591        if (!selector.hasResolver) {
1592          return selector;
1593        }
1594        return (...args) => {
1595          const result = selector.apply(null, args);
1596          if (boundMetadataSelectors.hasFinishedResolution(
1597            selectorName,
1598            args
1599          )) {
1600            if (boundMetadataSelectors.hasResolutionFailed(
1601              selectorName,
1602              args
1603            )) {
1604              throw boundMetadataSelectors.getResolutionError(
1605                selectorName,
1606                args
1607              );
1608            }
1609            return result;
1610          }
1611          throw new Promise((resolve) => {
1612            const unsubscribe = store.subscribe(() => {
1613              if (boundMetadataSelectors.hasFinishedResolution(
1614                selectorName,
1615                args
1616              )) {
1617                resolve();
1618                unsubscribe();
1619              }
1620            });
1621          });
1622        };
1623      };
1624    }
1625    function mapResolver(resolver) {
1626      if (resolver.fulfill) {
1627        return resolver;
1628      }
1629      return {
1630        ...resolver,
1631        // Copy the enumerable properties of the resolver function.
1632        fulfill: resolver
1633        // Add the fulfill method.
1634      };
1635    }
1636    function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
1637      function fulfillSelector(args) {
1638        if (resolversCache.isRunning(selectorName, args) || boundMetadataSelectors.hasStartedResolution(selectorName, args)) {
1639          return;
1640        }
1641        resolversCache.markAsRunning(selectorName, args);
1642        setTimeout(async () => {
1643          resolversCache.clear(selectorName, args);
1644          store.dispatch(
1645            startResolution(selectorName, args)
1646          );
1647          try {
1648            const isFulfilled = typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args);
1649            if (!isFulfilled) {
1650              const action = resolver.fulfill(...args);
1651              if (action) {
1652                await store.dispatch(action);
1653              }
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.js
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.js
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.js
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.js
1990    var default_registry_default = createRegistry();
1991  
1992    // packages/data/build-module/plugins/index.js
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.js
2016    var import_deepmerge = __toESM(require_cjs());
2017  
2018    // packages/data/build-module/plugins/persistence/storage/object.js
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.js
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.js
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.js
2155    var import_compose2 = __toESM(require_compose());
2156  
2157    // packages/data/build-module/components/use-select/index.js
2158    var import_priority_queue = __toESM(require_priority_queue());
2159    var import_element5 = __toESM(require_element());
2160    var import_is_shallow_equal = __toESM(require_is_shallow_equal());
2161  
2162    // packages/data/build-module/components/registry-provider/use-registry.js
2163    var import_element2 = __toESM(require_element());
2164  
2165    // packages/data/build-module/components/registry-provider/context.js
2166    var import_element = __toESM(require_element());
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.js
2174    function useRegistry() {
2175      return (0, import_element2.useContext)(Context);
2176    }
2177  
2178    // packages/data/build-module/components/async-mode-provider/use-async-mode.js
2179    var import_element4 = __toESM(require_element());
2180  
2181    // packages/data/build-module/components/async-mode-provider/context.js
2182    var import_element3 = __toESM(require_element());
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.js
2189    function useAsyncMode() {
2190      return (0, import_element4.useContext)(Context2);
2191    }
2192  
2193    // packages/data/build-module/components/use-select/index.js
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.default)(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.default)(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.js
2349    var import_jsx_runtime = __toESM(require_jsx_runtime());
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.js
2361    var import_compose4 = __toESM(require_compose());
2362  
2363    // packages/data/build-module/components/use-dispatch/use-dispatch.js
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.js
2371    var import_element6 = __toESM(require_element());
2372    var import_compose3 = __toESM(require_compose());
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.js
2404    var import_jsx_runtime2 = __toESM(require_jsx_runtime());
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.js
2416    var import_compose5 = __toESM(require_compose());
2417    var import_jsx_runtime3 = __toESM(require_jsx_runtime());
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.js
2425    function dispatch2(storeNameOrDescriptor) {
2426      return default_registry_default.dispatch(storeNameOrDescriptor);
2427    }
2428  
2429    // packages/data/build-module/select.js
2430    function select2(storeNameOrDescriptor) {
2431      return default_registry_default.select(storeNameOrDescriptor);
2432    }
2433  
2434    // packages/data/build-module/index.js
2435    var defaultRegistry = default_registry_default;
2436    var combineReducers2 = combineReducers;
2437    var resolveSelect2 = (storeNameOrDescriptor) => defaultRegistry.resolveSelect(storeNameOrDescriptor);
2438    var suspendSelect = (storeNameOrDescriptor) => defaultRegistry.suspendSelect(storeNameOrDescriptor);
2439    var subscribe = (listener, storeNameOrDescriptor) => defaultRegistry.subscribe(listener, storeNameOrDescriptor);
2440    var registerGenericStore = defaultRegistry.registerGenericStore;
2441    var registerStore = defaultRegistry.registerStore;
2442    var use = defaultRegistry.use;
2443    var register = (store) => defaultRegistry.register(store);
2444    return __toCommonJS(index_exports);
2445  })();
2446  /*! Bundled license information:
2447  
2448  is-plain-object/dist/is-plain-object.mjs:
2449    (*!
2450     * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
2451     *
2452     * Copyright (c) 2014-2017, Jon Schlinkert.
2453     * Released under the MIT License.
2454     *)
2455  */