[Summary view] [Print] [Text view]

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