[Summary view] [Print] [Text view]

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