[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: () => createSelector,
 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/create-selector.mjs
1094    var createSelector = rememo_default;
1095  
1096    // packages/data/build-module/redux-store/metadata/selectors.mjs
1097    function getResolutionState(state, selectorName, args) {
1098      const map = state[selectorName];
1099      if (!map) {
1100        return;
1101      }
1102      return map.get(selectorArgsToStateKey(args));
1103    }
1104    function getIsResolving(state, selectorName, args) {
1105      (0, import_deprecated.default)("wp.data.select( store ).getIsResolving", {
1106        since: "6.6",
1107        version: "6.8",
1108        alternative: "wp.data.select( store ).getResolutionState"
1109      });
1110      const resolutionState = getResolutionState(state, selectorName, args);
1111      return resolutionState && resolutionState.status === "resolving";
1112    }
1113    function hasStartedResolution(state, selectorName, args) {
1114      return getResolutionState(state, selectorName, args) !== void 0;
1115    }
1116    function hasFinishedResolution(state, selectorName, args) {
1117      const status = getResolutionState(state, selectorName, args)?.status;
1118      return status === "finished" || status === "error";
1119    }
1120    function hasResolutionFailed(state, selectorName, args) {
1121      return getResolutionState(state, selectorName, args)?.status === "error";
1122    }
1123    function getResolutionError(state, selectorName, args) {
1124      const resolutionState = getResolutionState(state, selectorName, args);
1125      return resolutionState?.status === "error" ? resolutionState.error : null;
1126    }
1127    function isResolving(state, selectorName, args) {
1128      return getResolutionState(state, selectorName, args)?.status === "resolving";
1129    }
1130    function getCachedResolvers(state) {
1131      return state;
1132    }
1133    function hasResolvingSelectors(state) {
1134      return Object.values(state).some(
1135        (selectorState) => (
1136          /**
1137           * This uses the internal `_map` property of `EquivalentKeyMap` for
1138           * optimization purposes, since the `EquivalentKeyMap` implementation
1139           * does not support a `.values()` implementation.
1140           *
1141           * @see https://github.com/aduth/equivalent-key-map
1142           */
1143          Array.from(selectorState._map.values()).some(
1144            (resolution) => resolution[1]?.status === "resolving"
1145          )
1146        )
1147      );
1148    }
1149    var countSelectorsByStatus = createSelector(
1150      (state) => {
1151        const selectorsByStatus = {};
1152        Object.values(state).forEach(
1153          (selectorState) => (
1154            /**
1155             * This uses the internal `_map` property of `EquivalentKeyMap` for
1156             * optimization purposes, since the `EquivalentKeyMap` implementation
1157             * does not support a `.values()` implementation.
1158             *
1159             * @see https://github.com/aduth/equivalent-key-map
1160             */
1161            Array.from(selectorState._map.values()).forEach(
1162              (resolution) => {
1163                const currentStatus = resolution[1]?.status ?? "error";
1164                if (!selectorsByStatus[currentStatus]) {
1165                  selectorsByStatus[currentStatus] = 0;
1166                }
1167                selectorsByStatus[currentStatus]++;
1168              }
1169            )
1170          )
1171        );
1172        return selectorsByStatus;
1173      },
1174      (state) => [state]
1175    );
1176  
1177    // packages/data/build-module/redux-store/metadata/actions.mjs
1178    var actions_exports = {};
1179    __export(actions_exports, {
1180      failResolution: () => failResolution,
1181      failResolutions: () => failResolutions,
1182      finishResolution: () => finishResolution,
1183      finishResolutions: () => finishResolutions,
1184      invalidateResolution: () => invalidateResolution,
1185      invalidateResolutionForStore: () => invalidateResolutionForStore,
1186      invalidateResolutionForStoreSelector: () => invalidateResolutionForStoreSelector,
1187      startResolution: () => startResolution,
1188      startResolutions: () => startResolutions
1189    });
1190    function startResolution(selectorName, args) {
1191      return {
1192        type: "START_RESOLUTION",
1193        selectorName,
1194        args
1195      };
1196    }
1197    function finishResolution(selectorName, args) {
1198      return {
1199        type: "FINISH_RESOLUTION",
1200        selectorName,
1201        args
1202      };
1203    }
1204    function failResolution(selectorName, args, error) {
1205      return {
1206        type: "FAIL_RESOLUTION",
1207        selectorName,
1208        args,
1209        error
1210      };
1211    }
1212    function startResolutions(selectorName, args) {
1213      return {
1214        type: "START_RESOLUTIONS",
1215        selectorName,
1216        args
1217      };
1218    }
1219    function finishResolutions(selectorName, args) {
1220      return {
1221        type: "FINISH_RESOLUTIONS",
1222        selectorName,
1223        args
1224      };
1225    }
1226    function failResolutions(selectorName, args, errors) {
1227      return {
1228        type: "FAIL_RESOLUTIONS",
1229        selectorName,
1230        args,
1231        errors
1232      };
1233    }
1234    function invalidateResolution(selectorName, args) {
1235      return {
1236        type: "INVALIDATE_RESOLUTION",
1237        selectorName,
1238        args
1239      };
1240    }
1241    function invalidateResolutionForStore() {
1242      return {
1243        type: "INVALIDATE_RESOLUTION_FOR_STORE"
1244      };
1245    }
1246    function invalidateResolutionForStoreSelector(selectorName) {
1247      return {
1248        type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR",
1249        selectorName
1250      };
1251    }
1252  
1253    // packages/data/build-module/redux-store/index.mjs
1254    var trimUndefinedValues = (array) => {
1255      const result = [...array];
1256      for (let i = result.length - 1; i >= 0; i--) {
1257        if (result[i] === void 0) {
1258          result.splice(i, 1);
1259        }
1260      }
1261      return result;
1262    };
1263    var mapValues = (obj, callback) => Object.fromEntries(
1264      Object.entries(obj ?? {}).map(([key, value]) => [
1265        key,
1266        callback(value, key)
1267      ])
1268    );
1269    var devToolsReplacer = (_key, state) => {
1270      if (state instanceof Map) {
1271        return Object.fromEntries(state);
1272      }
1273      if (typeof window !== "undefined" && state instanceof window.HTMLElement) {
1274        return null;
1275      }
1276      return state;
1277    };
1278    function createResolversCache() {
1279      const cache = {};
1280      return {
1281        isRunning(selectorName, args) {
1282          return !!(cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args)));
1283        },
1284        clear(selectorName, args) {
1285          if (cache[selectorName]) {
1286            cache[selectorName].delete(trimUndefinedValues(args));
1287          }
1288        },
1289        markAsRunning(selectorName, args) {
1290          if (!cache[selectorName]) {
1291            cache[selectorName] = new import_equivalent_key_map2.default();
1292          }
1293          cache[selectorName].set(trimUndefinedValues(args), true);
1294        }
1295      };
1296    }
1297    function createBindingCache(getItem, bindItem) {
1298      const cache = /* @__PURE__ */ new WeakMap();
1299      return {
1300        get(itemName) {
1301          const item = getItem(itemName);
1302          if (!item) {
1303            return null;
1304          }
1305          let boundItem = cache.get(item);
1306          if (!boundItem) {
1307            boundItem = bindItem(item, itemName);
1308            cache.set(item, boundItem);
1309          }
1310          return boundItem;
1311        }
1312      };
1313    }
1314    function createPrivateProxy(publicItems, privateItems) {
1315      return new Proxy(publicItems, {
1316        get: (target, itemName) => privateItems.get(itemName) || Reflect.get(target, itemName)
1317      });
1318    }
1319    function createReduxStore(key, options) {
1320      const privateActions = {};
1321      const privateSelectors = {};
1322      const privateRegistrationFunctions = {
1323        privateActions,
1324        registerPrivateActions: (actions) => {
1325          Object.assign(privateActions, actions);
1326        },
1327        privateSelectors,
1328        registerPrivateSelectors: (selectors) => {
1329          Object.assign(privateSelectors, selectors);
1330        }
1331      };
1332      const storeDescriptor = {
1333        name: key,
1334        instantiate: (registry) => {
1335          const listeners = /* @__PURE__ */ new Set();
1336          const reducer = options.reducer;
1337          const thunkArgs = {
1338            registry,
1339            get dispatch() {
1340              return thunkDispatch;
1341            },
1342            get select() {
1343              return thunkSelect;
1344            },
1345            get resolveSelect() {
1346              return resolveSelectors;
1347            }
1348          };
1349          const store = instantiateReduxStore(
1350            key,
1351            options,
1352            registry,
1353            thunkArgs
1354          );
1355          lock(store, privateRegistrationFunctions);
1356          const resolversCache = createResolversCache();
1357          function bindAction(action) {
1358            return (...args) => Promise.resolve(store.dispatch(action(...args)));
1359          }
1360          const actions = {
1361            ...mapValues(
1362              actions_exports,
1363              bindAction
1364            ),
1365            ...mapValues(
1366              options.actions,
1367              bindAction
1368            )
1369          };
1370          const allActions = createPrivateProxy(
1371            actions,
1372            createBindingCache(
1373              (name) => privateActions[name],
1374              bindAction
1375            )
1376          );
1377          const thunkDispatch = new Proxy(
1378            (action) => store.dispatch(action),
1379            {
1380              get: (_target, name) => allActions[name]
1381            }
1382          );
1383          lock(actions, allActions);
1384          const resolvers = options.resolvers ? mapValues(
1385            options.resolvers,
1386            mapResolver
1387          ) : {};
1388          function bindSelector(selector, selectorName) {
1389            if (selector.isRegistrySelector) {
1390              selector.registry = registry;
1391            }
1392            const boundSelector = (...args) => {
1393              args = normalize(selector, args);
1394              const state = store.__unstableOriginalGetState();
1395              if (selector.isRegistrySelector) {
1396                selector.registry = registry;
1397              }
1398              return selector(state.root, ...args);
1399            };
1400            boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
1401            const resolver = resolvers[selectorName];
1402            if (!resolver) {
1403              boundSelector.hasResolver = false;
1404              return boundSelector;
1405            }
1406            return mapSelectorWithResolver(
1407              boundSelector,
1408              selectorName,
1409              resolver,
1410              store,
1411              resolversCache,
1412              boundMetadataSelectors
1413            );
1414          }
1415          function bindMetadataSelector(metaDataSelector) {
1416            const boundSelector = (selectorName, selectorArgs, ...args) => {
1417              if (selectorName) {
1418                const targetSelector = options.selectors?.[selectorName];
1419                if (targetSelector) {
1420                  selectorArgs = normalize(
1421                    targetSelector,
1422                    selectorArgs
1423                  );
1424                }
1425              }
1426              const state = store.__unstableOriginalGetState();
1427              return metaDataSelector(
1428                state.metadata,
1429                selectorName,
1430                selectorArgs,
1431                ...args
1432              );
1433            };
1434            boundSelector.hasResolver = false;
1435            return boundSelector;
1436          }
1437          const boundMetadataSelectors = mapValues(
1438            selectors_exports,
1439            bindMetadataSelector
1440          );
1441          const boundSelectors = mapValues(
1442            options.selectors,
1443            bindSelector
1444          );
1445          const selectors = {
1446            ...boundMetadataSelectors,
1447            ...boundSelectors
1448          };
1449          const boundPrivateSelectors = createBindingCache(
1450            (name) => privateSelectors[name],
1451            bindSelector
1452          );
1453          const allSelectors = createPrivateProxy(
1454            selectors,
1455            boundPrivateSelectors
1456          );
1457          for (const selectorName of Object.keys(privateSelectors)) {
1458            boundPrivateSelectors.get(selectorName);
1459          }
1460          const thunkSelect = new Proxy(
1461            (selector) => selector(store.__unstableOriginalGetState()),
1462            {
1463              get: (_target, name) => allSelectors[name]
1464            }
1465          );
1466          lock(selectors, allSelectors);
1467          const bindResolveSelector = mapResolveSelector(
1468            store,
1469            resolvers,
1470            boundMetadataSelectors
1471          );
1472          const resolveSelectors = mapValues(
1473            boundSelectors,
1474            bindResolveSelector
1475          );
1476          const allResolveSelectors = createPrivateProxy(
1477            resolveSelectors,
1478            createBindingCache(
1479              (name) => boundPrivateSelectors.get(name),
1480              bindResolveSelector
1481            )
1482          );
1483          lock(resolveSelectors, allResolveSelectors);
1484          const bindSuspendSelector = mapSuspendSelector(
1485            store,
1486            boundMetadataSelectors
1487          );
1488          const suspendSelectors = {
1489            ...boundMetadataSelectors,
1490            // no special suspense behavior
1491            ...mapValues(boundSelectors, bindSuspendSelector)
1492          };
1493          const allSuspendSelectors = createPrivateProxy(
1494            suspendSelectors,
1495            createBindingCache(
1496              (name) => boundPrivateSelectors.get(name),
1497              bindSuspendSelector
1498            )
1499          );
1500          lock(suspendSelectors, allSuspendSelectors);
1501          const getSelectors = () => selectors;
1502          const getActions = () => actions;
1503          const getResolveSelectors = () => resolveSelectors;
1504          const getSuspendSelectors = () => suspendSelectors;
1505          store.__unstableOriginalGetState = store.getState;
1506          store.getState = () => store.__unstableOriginalGetState().root;
1507          const subscribe2 = (listener) => {
1508            listeners.add(listener);
1509            return () => listeners.delete(listener);
1510          };
1511          let lastState = store.__unstableOriginalGetState();
1512          store.subscribe(() => {
1513            const state = store.__unstableOriginalGetState();
1514            const hasChanged = state !== lastState;
1515            lastState = state;
1516            if (hasChanged) {
1517              for (const listener of listeners) {
1518                listener();
1519              }
1520            }
1521          });
1522          return {
1523            reducer,
1524            store,
1525            actions,
1526            selectors,
1527            resolvers,
1528            getSelectors,
1529            getResolveSelectors,
1530            getSuspendSelectors,
1531            getActions,
1532            subscribe: subscribe2
1533          };
1534        }
1535      };
1536      lock(storeDescriptor, privateRegistrationFunctions);
1537      return storeDescriptor;
1538    }
1539    function instantiateReduxStore(key, options, registry, thunkArgs) {
1540      const controls2 = {
1541        ...options.controls,
1542        ...builtinControls
1543      };
1544      const normalizedControls = mapValues(
1545        controls2,
1546        (control) => control.isRegistryControl ? control(registry) : control
1547      );
1548      const middlewares = [
1549        resolvers_cache_middleware_default(registry, key),
1550        promise_middleware_default,
1551        (0, import_redux_routine.default)(normalizedControls),
1552        createThunkMiddleware(thunkArgs)
1553      ];
1554      const enhancers = [applyMiddleware(...middlewares)];
1555      if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
1556        enhancers.push(
1557          window.__REDUX_DEVTOOLS_EXTENSION__({
1558            name: key,
1559            instanceId: key,
1560            serialize: {
1561              replacer: devToolsReplacer
1562            }
1563          })
1564        );
1565      }
1566      const { reducer, initialState } = options;
1567      const enhancedReducer = combineReducers({
1568        metadata: reducer_default,
1569        root: reducer
1570      });
1571      return createStore(
1572        enhancedReducer,
1573        { root: initialState },
1574        (0, import_compose.compose)(...enhancers)
1575      );
1576    }
1577    function mapResolveSelector(store, resolvers, boundMetadataSelectors) {
1578      return (selector, selectorName) => {
1579        if (!selector.hasResolver) {
1580          return async (...args) => selector(...args);
1581        }
1582        return (...args) => new Promise((resolve, reject) => {
1583          const resolver = resolvers[selectorName];
1584          const hasFinished = () => {
1585            return boundMetadataSelectors.hasFinishedResolution(
1586              selectorName,
1587              args
1588            ) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args);
1589          };
1590          const finalize = (result2) => {
1591            const hasFailed = boundMetadataSelectors.hasResolutionFailed(
1592              selectorName,
1593              args
1594            );
1595            if (hasFailed) {
1596              const error = boundMetadataSelectors.getResolutionError(
1597                selectorName,
1598                args
1599              );
1600              reject(error);
1601            } else {
1602              resolve(result2);
1603            }
1604          };
1605          const getResult = () => selector(...args);
1606          const result = getResult();
1607          if (hasFinished()) {
1608            return finalize(result);
1609          }
1610          const unsubscribe = store.subscribe(() => {
1611            if (hasFinished()) {
1612              unsubscribe();
1613              finalize(getResult());
1614            }
1615          });
1616        });
1617      };
1618    }
1619    function mapSuspendSelector(store, boundMetadataSelectors) {
1620      return (selector, selectorName) => {
1621        if (!selector.hasResolver) {
1622          return selector;
1623        }
1624        return (...args) => {
1625          const result = selector(...args);
1626          if (boundMetadataSelectors.hasFinishedResolution(
1627            selectorName,
1628            args
1629          )) {
1630            if (boundMetadataSelectors.hasResolutionFailed(
1631              selectorName,
1632              args
1633            )) {
1634              throw boundMetadataSelectors.getResolutionError(
1635                selectorName,
1636                args
1637              );
1638            }
1639            return result;
1640          }
1641          throw new Promise((resolve) => {
1642            const unsubscribe = store.subscribe(() => {
1643              if (boundMetadataSelectors.hasFinishedResolution(
1644                selectorName,
1645                args
1646              )) {
1647                resolve();
1648                unsubscribe();
1649              }
1650            });
1651          });
1652        };
1653      };
1654    }
1655    function mapResolver(resolver) {
1656      if (resolver.fulfill) {
1657        return resolver;
1658      }
1659      return {
1660        ...resolver,
1661        // Copy the enumerable properties of the resolver function.
1662        fulfill: resolver
1663        // Add the fulfill method.
1664      };
1665    }
1666    function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
1667      function fulfillSelector(args) {
1668        if (resolversCache.isRunning(selectorName, args) || boundMetadataSelectors.hasStartedResolution(selectorName, args) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args)) {
1669          return;
1670        }
1671        resolversCache.markAsRunning(selectorName, args);
1672        setTimeout(async () => {
1673          resolversCache.clear(selectorName, args);
1674          store.dispatch(
1675            startResolution(selectorName, args)
1676          );
1677          try {
1678            const action = resolver.fulfill(...args);
1679            if (action) {
1680              await store.dispatch(action);
1681            }
1682            store.dispatch(
1683              finishResolution(selectorName, args)
1684            );
1685          } catch (error) {
1686            store.dispatch(
1687              failResolution(selectorName, args, error)
1688            );
1689          }
1690        }, 0);
1691      }
1692      const selectorResolver = (...args) => {
1693        args = normalize(selector, args);
1694        fulfillSelector(args);
1695        return selector(...args);
1696      };
1697      selectorResolver.hasResolver = true;
1698      return selectorResolver;
1699    }
1700    function normalize(selector, args) {
1701      if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) {
1702        return selector.__unstableNormalizeArgs(args);
1703      }
1704      return args;
1705    }
1706  
1707    // packages/data/build-module/store/index.mjs
1708    var coreDataStore = {
1709      name: "core/data",
1710      instantiate(registry) {
1711        const getCoreDataSelector = (selectorName) => (key, ...args) => {
1712          return registry.select(key)[selectorName](...args);
1713        };
1714        const getCoreDataAction = (actionName) => (key, ...args) => {
1715          return registry.dispatch(key)[actionName](...args);
1716        };
1717        return {
1718          getSelectors() {
1719            return Object.fromEntries(
1720              [
1721                "getIsResolving",
1722                "hasStartedResolution",
1723                "hasFinishedResolution",
1724                "isResolving",
1725                "getCachedResolvers"
1726              ].map((selectorName) => [
1727                selectorName,
1728                getCoreDataSelector(selectorName)
1729              ])
1730            );
1731          },
1732          getActions() {
1733            return Object.fromEntries(
1734              [
1735                "startResolution",
1736                "finishResolution",
1737                "invalidateResolution",
1738                "invalidateResolutionForStore",
1739                "invalidateResolutionForStoreSelector"
1740              ].map((actionName) => [
1741                actionName,
1742                getCoreDataAction(actionName)
1743              ])
1744            );
1745          },
1746          subscribe() {
1747            return () => () => {
1748            };
1749          }
1750        };
1751      }
1752    };
1753    var store_default = coreDataStore;
1754  
1755    // packages/data/build-module/utils/emitter.mjs
1756    function createEmitter() {
1757      let isPaused = false;
1758      let isPending = false;
1759      const listeners = /* @__PURE__ */ new Set();
1760      const notifyListeners = () => (
1761        // We use Array.from to clone the listeners Set
1762        // This ensures that we don't run a listener
1763        // that was added as a response to another listener.
1764        Array.from(listeners).forEach((listener) => listener())
1765      );
1766      return {
1767        get isPaused() {
1768          return isPaused;
1769        },
1770        subscribe(listener) {
1771          listeners.add(listener);
1772          return () => listeners.delete(listener);
1773        },
1774        pause() {
1775          isPaused = true;
1776        },
1777        resume() {
1778          isPaused = false;
1779          if (isPending) {
1780            isPending = false;
1781            notifyListeners();
1782          }
1783        },
1784        emit() {
1785          if (isPaused) {
1786            isPending = true;
1787            return;
1788          }
1789          notifyListeners();
1790        }
1791      };
1792    }
1793  
1794    // packages/data/build-module/registry.mjs
1795    function getStoreName(storeNameOrDescriptor) {
1796      return typeof storeNameOrDescriptor === "string" ? storeNameOrDescriptor : storeNameOrDescriptor.name;
1797    }
1798    function createRegistry(storeConfigs = {}, parent = null) {
1799      const stores = {};
1800      const emitter = createEmitter();
1801      let listeningStores = null;
1802      function globalListener() {
1803        emitter.emit();
1804      }
1805      const subscribe2 = (listener, storeNameOrDescriptor) => {
1806        if (!storeNameOrDescriptor) {
1807          return emitter.subscribe(listener);
1808        }
1809        const storeName = getStoreName(storeNameOrDescriptor);
1810        const store = stores[storeName];
1811        if (store) {
1812          return store.subscribe(listener);
1813        }
1814        if (!parent) {
1815          return emitter.subscribe(listener);
1816        }
1817        return parent.subscribe(listener, storeNameOrDescriptor);
1818      };
1819      function select3(storeNameOrDescriptor) {
1820        const storeName = getStoreName(storeNameOrDescriptor);
1821        listeningStores?.add(storeName);
1822        const store = stores[storeName];
1823        if (store) {
1824          return store.getSelectors();
1825        }
1826        return parent?.select(storeName);
1827      }
1828      function __unstableMarkListeningStores(callback, ref) {
1829        listeningStores = /* @__PURE__ */ new Set();
1830        try {
1831          return callback.call(this);
1832        } finally {
1833          ref.current = Array.from(listeningStores);
1834          listeningStores = null;
1835        }
1836      }
1837      function resolveSelect3(storeNameOrDescriptor) {
1838        const storeName = getStoreName(storeNameOrDescriptor);
1839        listeningStores?.add(storeName);
1840        const store = stores[storeName];
1841        if (store) {
1842          return store.getResolveSelectors();
1843        }
1844        return parent && parent.resolveSelect(storeName);
1845      }
1846      function suspendSelect2(storeNameOrDescriptor) {
1847        const storeName = getStoreName(storeNameOrDescriptor);
1848        listeningStores?.add(storeName);
1849        const store = stores[storeName];
1850        if (store) {
1851          return store.getSuspendSelectors();
1852        }
1853        return parent && parent.suspendSelect(storeName);
1854      }
1855      function dispatch3(storeNameOrDescriptor) {
1856        const storeName = getStoreName(storeNameOrDescriptor);
1857        const store = stores[storeName];
1858        if (store) {
1859          return store.getActions();
1860        }
1861        return parent && parent.dispatch(storeName);
1862      }
1863      function withPlugins(attributes) {
1864        return Object.fromEntries(
1865          Object.entries(attributes).map(([key, attribute]) => {
1866            if (typeof attribute !== "function") {
1867              return [key, attribute];
1868            }
1869            return [
1870              key,
1871              (...args) => {
1872                return registry[key](...args);
1873              }
1874            ];
1875          })
1876        );
1877      }
1878      function registerStoreInstance(name, createStoreFunc) {
1879        if (stores[name]) {
1880          console.error('Store "' + name + '" is already registered.');
1881          return stores[name];
1882        }
1883        const store = createStoreFunc();
1884        if (typeof store.getSelectors !== "function") {
1885          throw new TypeError("store.getSelectors must be a function");
1886        }
1887        if (typeof store.getActions !== "function") {
1888          throw new TypeError("store.getActions must be a function");
1889        }
1890        if (typeof store.subscribe !== "function") {
1891          throw new TypeError("store.subscribe must be a function");
1892        }
1893        store.emitter = createEmitter();
1894        const currentSubscribe = store.subscribe;
1895        store.subscribe = (listener) => {
1896          const unsubscribeFromEmitter = store.emitter.subscribe(listener);
1897          const unsubscribeFromStore = currentSubscribe(() => {
1898            if (store.emitter.isPaused) {
1899              store.emitter.emit();
1900              return;
1901            }
1902            listener();
1903          });
1904          return () => {
1905            unsubscribeFromStore?.();
1906            unsubscribeFromEmitter?.();
1907          };
1908        };
1909        stores[name] = store;
1910        store.subscribe(globalListener);
1911        if (parent) {
1912          try {
1913            unlock(store.store).registerPrivateActions(
1914              unlock(parent).privateActionsOf(name)
1915            );
1916            unlock(store.store).registerPrivateSelectors(
1917              unlock(parent).privateSelectorsOf(name)
1918            );
1919          } catch {
1920          }
1921        }
1922        return store;
1923      }
1924      function register2(store) {
1925        registerStoreInstance(
1926          store.name,
1927          () => store.instantiate(registry)
1928        );
1929      }
1930      function registerGenericStore2(name, store) {
1931        (0, import_deprecated2.default)("wp.data.registerGenericStore", {
1932          since: "5.9",
1933          alternative: "wp.data.register( storeDescriptor )"
1934        });
1935        registerStoreInstance(name, () => store);
1936      }
1937      function registerStore2(storeName, options) {
1938        if (!options.reducer) {
1939          throw new TypeError("Must specify store reducer");
1940        }
1941        const store = registerStoreInstance(
1942          storeName,
1943          () => createReduxStore(storeName, options).instantiate(
1944            registry
1945          )
1946        );
1947        return store.store;
1948      }
1949      function batch(callback) {
1950        if (emitter.isPaused) {
1951          callback();
1952          return;
1953        }
1954        emitter.pause();
1955        Object.values(stores).forEach((store) => store.emitter.pause());
1956        try {
1957          callback();
1958        } finally {
1959          emitter.resume();
1960          Object.values(stores).forEach(
1961            (store) => store.emitter.resume()
1962          );
1963        }
1964      }
1965      let registry = {
1966        batch,
1967        stores,
1968        namespaces: stores,
1969        // TODO: Deprecate/remove this.
1970        subscribe: subscribe2,
1971        select: select3,
1972        resolveSelect: resolveSelect3,
1973        suspendSelect: suspendSelect2,
1974        dispatch: dispatch3,
1975        use: use2,
1976        register: register2,
1977        registerGenericStore: registerGenericStore2,
1978        registerStore: registerStore2,
1979        __unstableMarkListeningStores
1980      };
1981      function use2(plugin, options) {
1982        if (!plugin) {
1983          return;
1984        }
1985        registry = {
1986          ...registry,
1987          ...plugin(registry, options)
1988        };
1989        return registry;
1990      }
1991      registry.register(store_default);
1992      for (const [name, config] of Object.entries(storeConfigs)) {
1993        registry.register(createReduxStore(name, config));
1994      }
1995      if (parent) {
1996        parent.subscribe(globalListener);
1997      }
1998      const registryWithPlugins = withPlugins(
1999        registry
2000      );
2001      lock(registryWithPlugins, {
2002        privateActionsOf: (name) => {
2003          try {
2004            return unlock(stores[name].store).privateActions;
2005          } catch {
2006            return {};
2007          }
2008        },
2009        privateSelectorsOf: (name) => {
2010          try {
2011            return unlock(stores[name].store).privateSelectors;
2012          } catch {
2013            return {};
2014          }
2015        }
2016      });
2017      return registryWithPlugins;
2018    }
2019  
2020    // packages/data/build-module/default-registry.mjs
2021    var defaultRegistry = createRegistry();
2022    var default_registry_default = defaultRegistry;
2023  
2024    // packages/data/build-module/plugins/index.mjs
2025    var plugins_exports = {};
2026    __export(plugins_exports, {
2027      persistence: () => persistence_default
2028    });
2029  
2030    // node_modules/is-plain-object/dist/is-plain-object.mjs
2031    function isObject(o) {
2032      return Object.prototype.toString.call(o) === "[object Object]";
2033    }
2034    function isPlainObject2(o) {
2035      var ctor, prot;
2036      if (isObject(o) === false) return false;
2037      ctor = o.constructor;
2038      if (ctor === void 0) return true;
2039      prot = ctor.prototype;
2040      if (isObject(prot) === false) return false;
2041      if (prot.hasOwnProperty("isPrototypeOf") === false) {
2042        return false;
2043      }
2044      return true;
2045    }
2046  
2047    // packages/data/build-module/plugins/persistence/index.mjs
2048    var import_deepmerge = __toESM(require_cjs(), 1);
2049  
2050    // packages/data/build-module/plugins/persistence/storage/object.mjs
2051    var objectStorage;
2052    var storage = {
2053      getItem(key) {
2054        if (!objectStorage || !objectStorage[key]) {
2055          return null;
2056        }
2057        return objectStorage[key];
2058      },
2059      setItem(key, value) {
2060        if (!objectStorage) {
2061          storage.clear();
2062        }
2063        objectStorage[key] = String(value);
2064      },
2065      clear() {
2066        objectStorage = /* @__PURE__ */ Object.create(null);
2067      }
2068    };
2069    var object_default = storage;
2070  
2071    // packages/data/build-module/plugins/persistence/storage/default.mjs
2072    var storage2;
2073    try {
2074      storage2 = window.localStorage;
2075      storage2.setItem("__wpDataTestLocalStorage", "");
2076      storage2.removeItem("__wpDataTestLocalStorage");
2077    } catch {
2078      storage2 = object_default;
2079    }
2080    var default_default = storage2;
2081  
2082    // packages/data/build-module/plugins/persistence/index.mjs
2083    var DEFAULT_STORAGE = default_default;
2084    var DEFAULT_STORAGE_KEY = "WP_DATA";
2085    var withLazySameState = (reducer) => (state, action) => {
2086      if (action.nextState === state) {
2087        return state;
2088      }
2089      return reducer(state, action);
2090    };
2091    function createPersistenceInterface(options) {
2092      const { storage: storage3 = DEFAULT_STORAGE, storageKey = DEFAULT_STORAGE_KEY } = options;
2093      let data;
2094      function getData() {
2095        if (data === void 0) {
2096          const persisted = storage3.getItem(storageKey);
2097          if (persisted === null) {
2098            data = {};
2099          } else {
2100            try {
2101              data = JSON.parse(persisted);
2102            } catch {
2103              data = {};
2104            }
2105          }
2106        }
2107        return data;
2108      }
2109      function setData(key, value) {
2110        data = { ...data, [key]: value };
2111        storage3.setItem(storageKey, JSON.stringify(data));
2112      }
2113      return {
2114        get: getData,
2115        set: setData
2116      };
2117    }
2118    function persistencePlugin(registry, pluginOptions) {
2119      const persistence = createPersistenceInterface(pluginOptions);
2120      function createPersistOnChange(getState, storeName, keys) {
2121        let getPersistedState;
2122        if (Array.isArray(keys)) {
2123          const reducers = keys.reduce(
2124            (accumulator, key) => Object.assign(accumulator, {
2125              [key]: (state, action) => action.nextState[key]
2126            }),
2127            {}
2128          );
2129          getPersistedState = withLazySameState(
2130            combineReducers2(reducers)
2131          );
2132        } else {
2133          getPersistedState = (_state, action) => action.nextState;
2134        }
2135        let lastState = getPersistedState(void 0, {
2136          nextState: getState()
2137        });
2138        return () => {
2139          const state = getPersistedState(lastState, {
2140            nextState: getState()
2141          });
2142          if (state !== lastState) {
2143            persistence.set(storeName, state);
2144            lastState = state;
2145          }
2146        };
2147      }
2148      return {
2149        registerStore(storeName, options) {
2150          if (!options.persist) {
2151            return registry.registerStore(storeName, options);
2152          }
2153          const persistedState = persistence.get()[storeName];
2154          if (persistedState !== void 0) {
2155            let initialState = options.reducer(options.initialState, {
2156              type: "@@WP/PERSISTENCE_RESTORE"
2157            });
2158            if (isPlainObject2(initialState) && isPlainObject2(persistedState)) {
2159              initialState = (0, import_deepmerge.default)(
2160                initialState,
2161                persistedState,
2162                {
2163                  isMergeableObject: isPlainObject2
2164                }
2165              );
2166            } else {
2167              initialState = persistedState;
2168            }
2169            options = {
2170              ...options,
2171              initialState
2172            };
2173          }
2174          const store = registry.registerStore(storeName, options);
2175          store.subscribe(
2176            createPersistOnChange(
2177              store.getState,
2178              storeName,
2179              options.persist
2180            )
2181          );
2182          return store;
2183        }
2184      };
2185    }
2186    var persistence_default = Object.assign(persistencePlugin, {
2187      __unstableMigrate: () => {
2188      }
2189    });
2190  
2191    // packages/data/build-module/components/with-select/index.mjs
2192    var import_compose2 = __toESM(require_compose(), 1);
2193    var import_element6 = __toESM(require_element(), 1);
2194  
2195    // packages/data/build-module/components/use-select/index.mjs
2196    var import_priority_queue = __toESM(require_priority_queue(), 1);
2197    var import_element5 = __toESM(require_element(), 1);
2198    var import_is_shallow_equal = __toESM(require_is_shallow_equal(), 1);
2199  
2200    // packages/data/build-module/components/registry-provider/use-registry.mjs
2201    var import_element2 = __toESM(require_element(), 1);
2202  
2203    // packages/data/build-module/components/registry-provider/context.mjs
2204    var import_element = __toESM(require_element(), 1);
2205    var Context = (0, import_element.createContext)(default_registry_default);
2206    Context.displayName = "RegistryProviderContext";
2207    var { Consumer, Provider } = Context;
2208    var RegistryConsumer = Consumer;
2209    var context_default = Provider;
2210  
2211    // packages/data/build-module/components/registry-provider/use-registry.mjs
2212    function useRegistry() {
2213      return (0, import_element2.useContext)(Context);
2214    }
2215  
2216    // packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2217    var import_element4 = __toESM(require_element(), 1);
2218  
2219    // packages/data/build-module/components/async-mode-provider/context.mjs
2220    var import_element3 = __toESM(require_element(), 1);
2221    var Context2 = (0, import_element3.createContext)(false);
2222    Context2.displayName = "AsyncModeContext";
2223    var { Consumer: Consumer2, Provider: Provider2 } = Context2;
2224    var context_default2 = Provider2;
2225  
2226    // packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2227    function useAsyncMode() {
2228      return (0, import_element4.useContext)(Context2);
2229    }
2230  
2231    // packages/data/build-module/components/use-select/index.mjs
2232    var renderQueue = (0, import_priority_queue.createQueue)();
2233    function warnOnUnstableReference(a, b) {
2234      if (!a || !b) {
2235        return;
2236      }
2237      const keys = typeof a === "object" && typeof b === "object" ? Object.keys(a).filter((k) => a[k] !== b[k]) : [];
2238      console.warn(
2239        "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",
2240        keys.join(", ")
2241      );
2242    }
2243    function Store(registry, suspense) {
2244      const select3 = suspense ? registry.suspendSelect : registry.select;
2245      const queueContext = {};
2246      let lastMapSelect;
2247      let lastMapResult;
2248      let lastMapResultValid = false;
2249      let lastIsAsync;
2250      let subscriber;
2251      let didWarnUnstableReference;
2252      const storeStatesOnMount = /* @__PURE__ */ new Map();
2253      function getStoreState(name) {
2254        return registry.stores[name]?.store?.getState?.() ?? {};
2255      }
2256      const createSubscriber = (stores) => {
2257        const activeStores = [...stores];
2258        const activeSubscriptions = /* @__PURE__ */ new Set();
2259        function subscribe2(listener) {
2260          if (lastMapResultValid) {
2261            for (const name of activeStores) {
2262              if (storeStatesOnMount.get(name) !== getStoreState(name)) {
2263                lastMapResultValid = false;
2264              }
2265            }
2266          }
2267          storeStatesOnMount.clear();
2268          const onStoreChange = () => {
2269            lastMapResultValid = false;
2270            listener();
2271          };
2272          const onChange = () => {
2273            if (lastIsAsync) {
2274              renderQueue.add(queueContext, onStoreChange);
2275            } else {
2276              onStoreChange();
2277            }
2278          };
2279          const unsubs = [];
2280          function subscribeStore(storeName) {
2281            unsubs.push(registry.subscribe(onChange, storeName));
2282          }
2283          for (const storeName of activeStores) {
2284            subscribeStore(storeName);
2285          }
2286          activeSubscriptions.add(subscribeStore);
2287          return () => {
2288            activeSubscriptions.delete(subscribeStore);
2289            for (const unsub of unsubs.values()) {
2290              unsub?.();
2291            }
2292            renderQueue.cancel(queueContext);
2293          };
2294        }
2295        function updateStores(newStores) {
2296          for (const newStore of newStores) {
2297            if (activeStores.includes(newStore)) {
2298              continue;
2299            }
2300            activeStores.push(newStore);
2301            for (const subscription of activeSubscriptions) {
2302              subscription(newStore);
2303            }
2304          }
2305        }
2306        return { subscribe: subscribe2, updateStores };
2307      };
2308      return (mapSelect, isAsync) => {
2309        function updateValue() {
2310          if (lastMapResultValid && mapSelect === lastMapSelect) {
2311            return;
2312          }
2313          const listeningStores = { current: null };
2314          const mapResult = registry.__unstableMarkListeningStores(
2315            () => mapSelect(select3, registry),
2316            listeningStores
2317          );
2318          if (true) {
2319            if (!didWarnUnstableReference) {
2320              const secondMapResult = mapSelect(select3, registry);
2321              if (!(0, import_is_shallow_equal.isShallowEqual)(mapResult, secondMapResult)) {
2322                warnOnUnstableReference(mapResult, secondMapResult);
2323                didWarnUnstableReference = true;
2324              }
2325            }
2326          }
2327          if (!subscriber) {
2328            for (const name of listeningStores.current) {
2329              storeStatesOnMount.set(name, getStoreState(name));
2330            }
2331            subscriber = createSubscriber(listeningStores.current);
2332          } else {
2333            subscriber.updateStores(listeningStores.current);
2334          }
2335          if (!(0, import_is_shallow_equal.isShallowEqual)(lastMapResult, mapResult)) {
2336            lastMapResult = mapResult;
2337          }
2338          lastMapSelect = mapSelect;
2339          lastMapResultValid = true;
2340        }
2341        function getValue() {
2342          updateValue();
2343          return lastMapResult;
2344        }
2345        if (lastIsAsync && !isAsync) {
2346          lastMapResultValid = false;
2347          renderQueue.cancel(queueContext);
2348        }
2349        updateValue();
2350        lastIsAsync = isAsync;
2351        return { subscribe: subscriber.subscribe, getValue };
2352      };
2353    }
2354    function _useStaticSelect(storeName) {
2355      return useRegistry().select(storeName);
2356    }
2357    function _useMappingSelect(suspense, mapSelect, deps) {
2358      const registry = useRegistry();
2359      const isAsync = useAsyncMode();
2360      const store = (0, import_element5.useMemo)(
2361        () => Store(registry, suspense),
2362        [registry, suspense]
2363      );
2364      const selector = (0, import_element5.useCallback)(mapSelect, deps);
2365      const { subscribe: subscribe2, getValue } = store(selector, isAsync);
2366      const result = (0, import_element5.useSyncExternalStore)(subscribe2, getValue, getValue);
2367      (0, import_element5.useDebugValue)(result);
2368      return result;
2369    }
2370    function useSelect(mapSelect, deps) {
2371      const staticSelectMode = typeof mapSelect !== "function";
2372      const staticSelectModeRef = (0, import_element5.useRef)(staticSelectMode);
2373      if (staticSelectMode !== staticSelectModeRef.current) {
2374        const prevMode = staticSelectModeRef.current ? "static" : "mapping";
2375        const nextMode = staticSelectMode ? "static" : "mapping";
2376        throw new Error(
2377          `Switching useSelect from $prevMode} to $nextMode} is not allowed`
2378        );
2379      }
2380      return staticSelectMode ? _useStaticSelect(mapSelect) : _useMappingSelect(false, mapSelect, deps);
2381    }
2382    function useSuspenseSelect(mapSelect, deps) {
2383      return _useMappingSelect(true, mapSelect, deps);
2384    }
2385  
2386    // packages/data/build-module/components/with-select/index.mjs
2387    var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
2388    var withSelect = (mapSelectToProps) => (0, import_compose2.createHigherOrderComponent)(
2389      (WrappedComponent) => (0, import_element6.memo)(
2390        (0, import_element6.forwardRef)(function WithSelect(ownProps, ref) {
2391          const mapSelect = (select3, registry) => mapSelectToProps(select3, ownProps, registry);
2392          const mergeProps = useSelect(mapSelect);
2393          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
2394            WrappedComponent,
2395            {
2396              ref,
2397              ...ownProps,
2398              ...mergeProps
2399            }
2400          );
2401        })
2402      ),
2403      "withSelect"
2404    );
2405    var with_select_default = withSelect;
2406  
2407    // packages/data/build-module/components/with-dispatch/index.mjs
2408    var import_compose4 = __toESM(require_compose(), 1);
2409  
2410    // packages/data/build-module/components/use-dispatch/use-dispatch.mjs
2411    var useDispatch = (storeNameOrDescriptor) => {
2412      const { dispatch: dispatch3 } = useRegistry();
2413      return storeNameOrDescriptor === void 0 ? dispatch3 : dispatch3(storeNameOrDescriptor);
2414    };
2415    var use_dispatch_default = useDispatch;
2416  
2417    // packages/data/build-module/components/use-dispatch/use-dispatch-with-map.mjs
2418    var import_element7 = __toESM(require_element(), 1);
2419    var import_compose3 = __toESM(require_compose(), 1);
2420    var useDispatchWithMap = (dispatchMap, deps) => {
2421      const registry = useRegistry();
2422      const currentDispatchMapRef = (0, import_element7.useRef)(dispatchMap);
2423      (0, import_compose3.useIsomorphicLayoutEffect)(() => {
2424        currentDispatchMapRef.current = dispatchMap;
2425      });
2426      return (0, import_element7.useMemo)(() => {
2427        const currentDispatchProps = currentDispatchMapRef.current(
2428          registry.dispatch,
2429          registry
2430        );
2431        return Object.fromEntries(
2432          Object.entries(currentDispatchProps).map(
2433            ([propName, dispatcher]) => {
2434              if (typeof dispatcher !== "function") {
2435                console.warn(
2436                  `Property $propName} returned from dispatchMap in useDispatchWithMap must be a function.`
2437                );
2438              }
2439              return [
2440                propName,
2441                (...args) => currentDispatchMapRef.current(registry.dispatch, registry)[propName](...args)
2442              ];
2443            }
2444          )
2445        );
2446      }, [registry, ...deps]);
2447    };
2448    var use_dispatch_with_map_default = useDispatchWithMap;
2449  
2450    // packages/data/build-module/components/with-dispatch/index.mjs
2451    var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
2452    var withDispatch = (mapDispatchToProps) => (0, import_compose4.createHigherOrderComponent)(
2453      (WrappedComponent) => (ownProps) => {
2454        const mapDispatch = (dispatch3, registry) => mapDispatchToProps(dispatch3, ownProps, registry);
2455        const dispatchProps = use_dispatch_with_map_default(mapDispatch, []);
2456        return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WrappedComponent, { ...ownProps, ...dispatchProps });
2457      },
2458      "withDispatch"
2459    );
2460    var with_dispatch_default = withDispatch;
2461  
2462    // packages/data/build-module/components/with-registry/index.mjs
2463    var import_compose5 = __toESM(require_compose(), 1);
2464    var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
2465    var withRegistry = (0, import_compose5.createHigherOrderComponent)(
2466      (OriginalComponent) => (props) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(RegistryConsumer, { children: (registry) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(OriginalComponent, { ...props, registry }) }),
2467      "withRegistry"
2468    );
2469    var with_registry_default = withRegistry;
2470  
2471    // packages/data/build-module/dispatch.mjs
2472    function dispatch2(storeNameOrDescriptor) {
2473      return default_registry_default.dispatch(
2474        storeNameOrDescriptor
2475      );
2476    }
2477  
2478    // packages/data/build-module/select.mjs
2479    function select2(storeNameOrDescriptor) {
2480      return default_registry_default.select(
2481        storeNameOrDescriptor
2482      );
2483    }
2484  
2485    // packages/data/build-module/index.mjs
2486    var combineReducers2 = combineReducers;
2487    function resolveSelect2(storeNameOrDescriptor) {
2488      return default_registry_default.resolveSelect(
2489        storeNameOrDescriptor
2490      );
2491    }
2492    var suspendSelect = (storeNameOrDescriptor) => default_registry_default.suspendSelect(storeNameOrDescriptor);
2493    var subscribe = (listener, storeNameOrDescriptor) => default_registry_default.subscribe(listener, storeNameOrDescriptor);
2494    var registerGenericStore = default_registry_default.registerGenericStore;
2495    var registerStore = default_registry_default.registerStore;
2496    var use = default_registry_default.use;
2497    var register = (store) => default_registry_default.register(store);
2498    return __toCommonJS(index_exports);
2499  })();
2500  /*! Bundled license information:
2501  
2502  is-plain-object/dist/is-plain-object.mjs:
2503    (*!
2504     * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
2505     *
2506     * Copyright (c) 2014-2017, Jon Schlinkert.
2507     * Released under the MIT License.
2508     *)
2509  */