[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.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
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              }
1427              const state = store.__unstableOriginalGetState();
1428              return metaDataSelector(
1429                state.metadata,
1430                selectorName,
1431                selectorArgs,
1432                ...args
1433              );
1434            };
1435            boundSelector.hasResolver = false;
1436            return boundSelector;
1437          }
1438          const boundMetadataSelectors = mapValues(
1439            selectors_exports,
1440            bindMetadataSelector
1441          );
1442          const boundSelectors = mapValues(
1443            options.selectors,
1444            bindSelector
1445          );
1446          const selectors = {
1447            ...boundMetadataSelectors,
1448            ...boundSelectors
1449          };
1450          const boundPrivateSelectors = createBindingCache(
1451            (name) => privateSelectors[name],
1452            bindSelector
1453          );
1454          const allSelectors = createPrivateProxy(
1455            selectors,
1456            boundPrivateSelectors
1457          );
1458          for (const selectorName of Object.keys(privateSelectors)) {
1459            boundPrivateSelectors.get(selectorName);
1460          }
1461          const thunkSelect = new Proxy(
1462            (selector) => selector(store.__unstableOriginalGetState()),
1463            {
1464              get: (_target, name) => allSelectors[name]
1465            }
1466          );
1467          lock(selectors, allSelectors);
1468          const bindResolveSelector = mapResolveSelector(
1469            store,
1470            resolvers,
1471            boundMetadataSelectors
1472          );
1473          const resolveSelectors = mapValues(
1474            boundSelectors,
1475            bindResolveSelector
1476          );
1477          const allResolveSelectors = createPrivateProxy(
1478            resolveSelectors,
1479            createBindingCache(
1480              (name) => boundPrivateSelectors.get(name),
1481              bindResolveSelector
1482            )
1483          );
1484          lock(resolveSelectors, allResolveSelectors);
1485          const bindSuspendSelector = mapSuspendSelector(
1486            store,
1487            boundMetadataSelectors
1488          );
1489          const suspendSelectors = {
1490            ...boundMetadataSelectors,
1491            // no special suspense behavior
1492            ...mapValues(boundSelectors, bindSuspendSelector)
1493          };
1494          const allSuspendSelectors = createPrivateProxy(
1495            suspendSelectors,
1496            createBindingCache(
1497              (name) => boundPrivateSelectors.get(name),
1498              bindSuspendSelector
1499            )
1500          );
1501          lock(suspendSelectors, allSuspendSelectors);
1502          const getSelectors = () => selectors;
1503          const getActions = () => actions;
1504          const getResolveSelectors = () => resolveSelectors;
1505          const getSuspendSelectors = () => suspendSelectors;
1506          store.__unstableOriginalGetState = store.getState;
1507          store.getState = () => store.__unstableOriginalGetState().root;
1508          const subscribe2 = (listener) => {
1509            listeners.add(listener);
1510            return () => listeners.delete(listener);
1511          };
1512          let lastState = store.__unstableOriginalGetState();
1513          store.subscribe(() => {
1514            const state = store.__unstableOriginalGetState();
1515            const hasChanged = state !== lastState;
1516            lastState = state;
1517            if (hasChanged) {
1518              for (const listener of listeners) {
1519                listener();
1520              }
1521            }
1522          });
1523          return {
1524            reducer,
1525            store,
1526            actions,
1527            selectors,
1528            resolvers,
1529            getSelectors,
1530            getResolveSelectors,
1531            getSuspendSelectors,
1532            getActions,
1533            subscribe: subscribe2
1534          };
1535        }
1536      };
1537      lock(storeDescriptor, privateRegistrationFunctions);
1538      return storeDescriptor;
1539    }
1540    function instantiateReduxStore(key, options, registry, thunkArgs) {
1541      const controls2 = {
1542        ...options.controls,
1543        ...builtinControls
1544      };
1545      const normalizedControls = mapValues(
1546        controls2,
1547        (control) => control.isRegistryControl ? control(registry) : control
1548      );
1549      const middlewares = [
1550        resolvers_cache_middleware_default(registry, key),
1551        promise_middleware_default,
1552        (0, import_redux_routine.default)(normalizedControls),
1553        createThunkMiddleware(thunkArgs)
1554      ];
1555      const enhancers = [applyMiddleware(...middlewares)];
1556      if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
1557        enhancers.push(
1558          window.__REDUX_DEVTOOLS_EXTENSION__({
1559            name: key,
1560            instanceId: key,
1561            serialize: {
1562              replacer: devToolsReplacer
1563            }
1564          })
1565        );
1566      }
1567      const { reducer, initialState } = options;
1568      const enhancedReducer = combineReducers({
1569        metadata: reducer_default,
1570        root: reducer
1571      });
1572      return createStore(
1573        enhancedReducer,
1574        { root: initialState },
1575        (0, import_compose.compose)(...enhancers)
1576      );
1577    }
1578    function mapResolveSelector(store, resolvers, boundMetadataSelectors) {
1579      return (selector, selectorName) => {
1580        if (!selector.hasResolver) {
1581          return async (...args) => selector(...args);
1582        }
1583        return (...args) => new Promise((resolve, reject) => {
1584          const resolver = resolvers[selectorName];
1585          const hasFinished = () => {
1586            return boundMetadataSelectors.hasFinishedResolution(
1587              selectorName,
1588              args
1589            ) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args);
1590          };
1591          const finalize = (result2) => {
1592            const hasFailed = boundMetadataSelectors.hasResolutionFailed(
1593              selectorName,
1594              args
1595            );
1596            if (hasFailed) {
1597              const error = boundMetadataSelectors.getResolutionError(
1598                selectorName,
1599                args
1600              );
1601              reject(error);
1602            } else {
1603              resolve(result2);
1604            }
1605          };
1606          const getResult = () => selector(...args);
1607          const result = getResult();
1608          if (hasFinished()) {
1609            return finalize(result);
1610          }
1611          const unsubscribe = store.subscribe(() => {
1612            if (hasFinished()) {
1613              unsubscribe();
1614              finalize(getResult());
1615            }
1616          });
1617        });
1618      };
1619    }
1620    function mapSuspendSelector(store, boundMetadataSelectors) {
1621      return (selector, selectorName) => {
1622        if (!selector.hasResolver) {
1623          return selector;
1624        }
1625        return (...args) => {
1626          const result = selector(...args);
1627          if (boundMetadataSelectors.hasFinishedResolution(
1628            selectorName,
1629            args
1630          )) {
1631            if (boundMetadataSelectors.hasResolutionFailed(
1632              selectorName,
1633              args
1634            )) {
1635              throw boundMetadataSelectors.getResolutionError(
1636                selectorName,
1637                args
1638              );
1639            }
1640            return result;
1641          }
1642          throw new Promise((resolve) => {
1643            const unsubscribe = store.subscribe(() => {
1644              if (boundMetadataSelectors.hasFinishedResolution(
1645                selectorName,
1646                args
1647              )) {
1648                resolve();
1649                unsubscribe();
1650              }
1651            });
1652          });
1653        };
1654      };
1655    }
1656    function mapResolver(resolver) {
1657      if (resolver.fulfill) {
1658        return resolver;
1659      }
1660      return {
1661        ...resolver,
1662        // Copy the enumerable properties of the resolver function.
1663        fulfill: resolver
1664        // Add the fulfill method.
1665      };
1666    }
1667    function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
1668      function fulfillSelector(args) {
1669        if (resolversCache.isRunning(selectorName, args) || boundMetadataSelectors.hasStartedResolution(selectorName, args) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args)) {
1670          return;
1671        }
1672        resolversCache.markAsRunning(selectorName, args);
1673        setTimeout(async () => {
1674          resolversCache.clear(selectorName, args);
1675          store.dispatch(
1676            startResolution(selectorName, args)
1677          );
1678          try {
1679            const action = resolver.fulfill(...args);
1680            if (action) {
1681              await store.dispatch(action);
1682            }
1683            store.dispatch(
1684              finishResolution(selectorName, args)
1685            );
1686          } catch (error) {
1687            store.dispatch(
1688              failResolution(selectorName, args, error)
1689            );
1690          }
1691        }, 0);
1692      }
1693      const selectorResolver = (...args) => {
1694        args = normalize(selector, args);
1695        fulfillSelector(args);
1696        return selector(...args);
1697      };
1698      selectorResolver.hasResolver = true;
1699      return selectorResolver;
1700    }
1701    function normalize(selector, args) {
1702      if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) {
1703        return selector.__unstableNormalizeArgs(args);
1704      }
1705      return args;
1706    }
1707  
1708    // packages/data/build-module/store/index.mjs
1709    var coreDataStore = {
1710      name: "core/data",
1711      instantiate(registry) {
1712        const getCoreDataSelector = (selectorName) => (key, ...args) => {
1713          return registry.select(key)[selectorName](...args);
1714        };
1715        const getCoreDataAction = (actionName) => (key, ...args) => {
1716          return registry.dispatch(key)[actionName](...args);
1717        };
1718        return {
1719          getSelectors() {
1720            return Object.fromEntries(
1721              [
1722                "getIsResolving",
1723                "hasStartedResolution",
1724                "hasFinishedResolution",
1725                "isResolving",
1726                "getCachedResolvers"
1727              ].map((selectorName) => [
1728                selectorName,
1729                getCoreDataSelector(selectorName)
1730              ])
1731            );
1732          },
1733          getActions() {
1734            return Object.fromEntries(
1735              [
1736                "startResolution",
1737                "finishResolution",
1738                "invalidateResolution",
1739                "invalidateResolutionForStore",
1740                "invalidateResolutionForStoreSelector"
1741              ].map((actionName) => [
1742                actionName,
1743                getCoreDataAction(actionName)
1744              ])
1745            );
1746          },
1747          subscribe() {
1748            return () => () => {
1749            };
1750          }
1751        };
1752      }
1753    };
1754    var store_default = coreDataStore;
1755  
1756    // packages/data/build-module/utils/emitter.mjs
1757    function createEmitter() {
1758      let isPaused = false;
1759      let isPending = false;
1760      const listeners = /* @__PURE__ */ new Set();
1761      const notifyListeners = () => (
1762        // We use Array.from to clone the listeners Set
1763        // This ensures that we don't run a listener
1764        // that was added as a response to another listener.
1765        Array.from(listeners).forEach((listener) => listener())
1766      );
1767      return {
1768        get isPaused() {
1769          return isPaused;
1770        },
1771        subscribe(listener) {
1772          listeners.add(listener);
1773          return () => listeners.delete(listener);
1774        },
1775        pause() {
1776          isPaused = true;
1777        },
1778        resume() {
1779          isPaused = false;
1780          if (isPending) {
1781            isPending = false;
1782            notifyListeners();
1783          }
1784        },
1785        emit() {
1786          if (isPaused) {
1787            isPending = true;
1788            return;
1789          }
1790          notifyListeners();
1791        }
1792      };
1793    }
1794  
1795    // packages/data/build-module/registry.mjs
1796    function getStoreName(storeNameOrDescriptor) {
1797      return typeof storeNameOrDescriptor === "string" ? storeNameOrDescriptor : storeNameOrDescriptor.name;
1798    }
1799    function createRegistry(storeConfigs = {}, parent = null) {
1800      const stores = {};
1801      const emitter = createEmitter();
1802      let listeningStores = null;
1803      function globalListener() {
1804        emitter.emit();
1805      }
1806      const subscribe2 = (listener, storeNameOrDescriptor) => {
1807        if (!storeNameOrDescriptor) {
1808          return emitter.subscribe(listener);
1809        }
1810        const storeName = getStoreName(storeNameOrDescriptor);
1811        const store = stores[storeName];
1812        if (store) {
1813          return store.subscribe(listener);
1814        }
1815        if (!parent) {
1816          return emitter.subscribe(listener);
1817        }
1818        return parent.subscribe(listener, storeNameOrDescriptor);
1819      };
1820      function select3(storeNameOrDescriptor) {
1821        const storeName = getStoreName(storeNameOrDescriptor);
1822        listeningStores?.add(storeName);
1823        const store = stores[storeName];
1824        if (store) {
1825          return store.getSelectors();
1826        }
1827        return parent?.select(storeName);
1828      }
1829      function __unstableMarkListeningStores(callback, ref) {
1830        listeningStores = /* @__PURE__ */ new Set();
1831        try {
1832          return callback.call(this);
1833        } finally {
1834          ref.current = Array.from(listeningStores);
1835          listeningStores = null;
1836        }
1837      }
1838      function resolveSelect3(storeNameOrDescriptor) {
1839        const storeName = getStoreName(storeNameOrDescriptor);
1840        listeningStores?.add(storeName);
1841        const store = stores[storeName];
1842        if (store) {
1843          return store.getResolveSelectors();
1844        }
1845        return parent && parent.resolveSelect(storeName);
1846      }
1847      function suspendSelect2(storeNameOrDescriptor) {
1848        const storeName = getStoreName(storeNameOrDescriptor);
1849        listeningStores?.add(storeName);
1850        const store = stores[storeName];
1851        if (store) {
1852          return store.getSuspendSelectors();
1853        }
1854        return parent && parent.suspendSelect(storeName);
1855      }
1856      function dispatch3(storeNameOrDescriptor) {
1857        const storeName = getStoreName(storeNameOrDescriptor);
1858        const store = stores[storeName];
1859        if (store) {
1860          return store.getActions();
1861        }
1862        return parent && parent.dispatch(storeName);
1863      }
1864      function withPlugins(attributes) {
1865        return Object.fromEntries(
1866          Object.entries(attributes).map(([key, attribute]) => {
1867            if (typeof attribute !== "function") {
1868              return [key, attribute];
1869            }
1870            return [
1871              key,
1872              (...args) => {
1873                return registry[key](...args);
1874              }
1875            ];
1876          })
1877        );
1878      }
1879      function registerStoreInstance(name, createStoreFunc) {
1880        if (stores[name]) {
1881          console.error('Store "' + name + '" is already registered.');
1882          return stores[name];
1883        }
1884        const store = createStoreFunc();
1885        if (typeof store.getSelectors !== "function") {
1886          throw new TypeError("store.getSelectors must be a function");
1887        }
1888        if (typeof store.getActions !== "function") {
1889          throw new TypeError("store.getActions must be a function");
1890        }
1891        if (typeof store.subscribe !== "function") {
1892          throw new TypeError("store.subscribe must be a function");
1893        }
1894        store.emitter = createEmitter();
1895        const currentSubscribe = store.subscribe;
1896        store.subscribe = (listener) => {
1897          const unsubscribeFromEmitter = store.emitter.subscribe(listener);
1898          const unsubscribeFromStore = currentSubscribe(() => {
1899            if (store.emitter.isPaused) {
1900              store.emitter.emit();
1901              return;
1902            }
1903            listener();
1904          });
1905          return () => {
1906            unsubscribeFromStore?.();
1907            unsubscribeFromEmitter?.();
1908          };
1909        };
1910        stores[name] = store;
1911        store.subscribe(globalListener);
1912        if (parent) {
1913          try {
1914            unlock(store.store).registerPrivateActions(
1915              unlock(parent).privateActionsOf(name)
1916            );
1917            unlock(store.store).registerPrivateSelectors(
1918              unlock(parent).privateSelectorsOf(name)
1919            );
1920          } catch {
1921          }
1922        }
1923        return store;
1924      }
1925      function register2(store) {
1926        registerStoreInstance(
1927          store.name,
1928          () => store.instantiate(registry)
1929        );
1930      }
1931      function registerGenericStore2(name, store) {
1932        (0, import_deprecated2.default)("wp.data.registerGenericStore", {
1933          since: "5.9",
1934          alternative: "wp.data.register( storeDescriptor )"
1935        });
1936        registerStoreInstance(name, () => store);
1937      }
1938      function registerStore2(storeName, options) {
1939        if (!options.reducer) {
1940          throw new TypeError("Must specify store reducer");
1941        }
1942        const store = registerStoreInstance(
1943          storeName,
1944          () => createReduxStore(storeName, options).instantiate(
1945            registry
1946          )
1947        );
1948        return store.store;
1949      }
1950      function batch(callback) {
1951        if (emitter.isPaused) {
1952          callback();
1953          return;
1954        }
1955        emitter.pause();
1956        Object.values(stores).forEach((store) => store.emitter.pause());
1957        try {
1958          callback();
1959        } finally {
1960          emitter.resume();
1961          Object.values(stores).forEach(
1962            (store) => store.emitter.resume()
1963          );
1964        }
1965      }
1966      let registry = {
1967        batch,
1968        stores,
1969        namespaces: stores,
1970        // TODO: Deprecate/remove this.
1971        subscribe: subscribe2,
1972        select: select3,
1973        resolveSelect: resolveSelect3,
1974        suspendSelect: suspendSelect2,
1975        dispatch: dispatch3,
1976        use: use2,
1977        register: register2,
1978        registerGenericStore: registerGenericStore2,
1979        registerStore: registerStore2,
1980        __unstableMarkListeningStores
1981      };
1982      function use2(plugin, options) {
1983        if (!plugin) {
1984          return;
1985        }
1986        registry = {
1987          ...registry,
1988          ...plugin(registry, options)
1989        };
1990        return registry;
1991      }
1992      registry.register(store_default);
1993      for (const [name, config] of Object.entries(storeConfigs)) {
1994        registry.register(createReduxStore(name, config));
1995      }
1996      if (parent) {
1997        parent.subscribe(globalListener);
1998      }
1999      const registryWithPlugins = withPlugins(
2000        registry
2001      );
2002      lock(registryWithPlugins, {
2003        privateActionsOf: (name) => {
2004          try {
2005            return unlock(stores[name].store).privateActions;
2006          } catch {
2007            return {};
2008          }
2009        },
2010        privateSelectorsOf: (name) => {
2011          try {
2012            return unlock(stores[name].store).privateSelectors;
2013          } catch {
2014            return {};
2015          }
2016        }
2017      });
2018      return registryWithPlugins;
2019    }
2020  
2021    // packages/data/build-module/default-registry.mjs
2022    var defaultRegistry = createRegistry();
2023    var default_registry_default = defaultRegistry;
2024  
2025    // packages/data/build-module/plugins/index.mjs
2026    var plugins_exports = {};
2027    __export(plugins_exports, {
2028      persistence: () => persistence_default
2029    });
2030  
2031    // node_modules/is-plain-object/dist/is-plain-object.mjs
2032    function isObject(o) {
2033      return Object.prototype.toString.call(o) === "[object Object]";
2034    }
2035    function isPlainObject2(o) {
2036      var ctor, prot;
2037      if (isObject(o) === false) return false;
2038      ctor = o.constructor;
2039      if (ctor === void 0) return true;
2040      prot = ctor.prototype;
2041      if (isObject(prot) === false) return false;
2042      if (prot.hasOwnProperty("isPrototypeOf") === false) {
2043        return false;
2044      }
2045      return true;
2046    }
2047  
2048    // packages/data/build-module/plugins/persistence/index.mjs
2049    var import_deepmerge = __toESM(require_cjs(), 1);
2050  
2051    // packages/data/build-module/plugins/persistence/storage/object.mjs
2052    var objectStorage;
2053    var storage = {
2054      getItem(key) {
2055        if (!objectStorage || !objectStorage[key]) {
2056          return null;
2057        }
2058        return objectStorage[key];
2059      },
2060      setItem(key, value) {
2061        if (!objectStorage) {
2062          storage.clear();
2063        }
2064        objectStorage[key] = String(value);
2065      },
2066      clear() {
2067        objectStorage = /* @__PURE__ */ Object.create(null);
2068      }
2069    };
2070    var object_default = storage;
2071  
2072    // packages/data/build-module/plugins/persistence/storage/default.mjs
2073    var storage2;
2074    try {
2075      storage2 = window.localStorage;
2076      storage2.setItem("__wpDataTestLocalStorage", "");
2077      storage2.removeItem("__wpDataTestLocalStorage");
2078    } catch {
2079      storage2 = object_default;
2080    }
2081    var default_default = storage2;
2082  
2083    // packages/data/build-module/plugins/persistence/index.mjs
2084    var DEFAULT_STORAGE = default_default;
2085    var DEFAULT_STORAGE_KEY = "WP_DATA";
2086    var withLazySameState = (reducer) => (state, action) => {
2087      if (action.nextState === state) {
2088        return state;
2089      }
2090      return reducer(state, action);
2091    };
2092    function createPersistenceInterface(options) {
2093      const { storage: storage3 = DEFAULT_STORAGE, storageKey = DEFAULT_STORAGE_KEY } = options;
2094      let data;
2095      function getData() {
2096        if (data === void 0) {
2097          const persisted = storage3.getItem(storageKey);
2098          if (persisted === null) {
2099            data = {};
2100          } else {
2101            try {
2102              data = JSON.parse(persisted);
2103            } catch {
2104              data = {};
2105            }
2106          }
2107        }
2108        return data;
2109      }
2110      function setData(key, value) {
2111        data = { ...data, [key]: value };
2112        storage3.setItem(storageKey, JSON.stringify(data));
2113      }
2114      return {
2115        get: getData,
2116        set: setData
2117      };
2118    }
2119    function persistencePlugin(registry, pluginOptions) {
2120      const persistence = createPersistenceInterface(pluginOptions);
2121      function createPersistOnChange(getState, storeName, keys) {
2122        let getPersistedState;
2123        if (Array.isArray(keys)) {
2124          const reducers = keys.reduce(
2125            (accumulator, key) => Object.assign(accumulator, {
2126              [key]: (state, action) => action.nextState[key]
2127            }),
2128            {}
2129          );
2130          getPersistedState = withLazySameState(
2131            combineReducers2(reducers)
2132          );
2133        } else {
2134          getPersistedState = (_state, action) => action.nextState;
2135        }
2136        let lastState = getPersistedState(void 0, {
2137          nextState: getState()
2138        });
2139        return () => {
2140          const state = getPersistedState(lastState, {
2141            nextState: getState()
2142          });
2143          if (state !== lastState) {
2144            persistence.set(storeName, state);
2145            lastState = state;
2146          }
2147        };
2148      }
2149      return {
2150        registerStore(storeName, options) {
2151          if (!options.persist) {
2152            return registry.registerStore(storeName, options);
2153          }
2154          const persistedState = persistence.get()[storeName];
2155          if (persistedState !== void 0) {
2156            let initialState = options.reducer(options.initialState, {
2157              type: "@@WP/PERSISTENCE_RESTORE"
2158            });
2159            if (isPlainObject2(initialState) && isPlainObject2(persistedState)) {
2160              initialState = (0, import_deepmerge.default)(
2161                initialState,
2162                persistedState,
2163                {
2164                  isMergeableObject: isPlainObject2
2165                }
2166              );
2167            } else {
2168              initialState = persistedState;
2169            }
2170            options = {
2171              ...options,
2172              initialState
2173            };
2174          }
2175          const store = registry.registerStore(storeName, options);
2176          store.subscribe(
2177            createPersistOnChange(
2178              store.getState,
2179              storeName,
2180              options.persist
2181            )
2182          );
2183          return store;
2184        }
2185      };
2186    }
2187    var persistence_default = Object.assign(persistencePlugin, {
2188      __unstableMigrate: () => {
2189      }
2190    });
2191  
2192    // packages/data/build-module/components/with-select/index.mjs
2193    var import_compose2 = __toESM(require_compose(), 1);
2194    var import_element6 = __toESM(require_element(), 1);
2195  
2196    // packages/data/build-module/components/use-select/index.mjs
2197    var import_priority_queue = __toESM(require_priority_queue(), 1);
2198    var import_element5 = __toESM(require_element(), 1);
2199    var import_is_shallow_equal = __toESM(require_is_shallow_equal(), 1);
2200  
2201    // packages/data/build-module/components/registry-provider/use-registry.mjs
2202    var import_element2 = __toESM(require_element(), 1);
2203  
2204    // packages/data/build-module/components/registry-provider/context.mjs
2205    var import_element = __toESM(require_element(), 1);
2206    var Context = (0, import_element.createContext)(default_registry_default);
2207    Context.displayName = "RegistryProviderContext";
2208    var { Consumer, Provider } = Context;
2209    var RegistryConsumer = Consumer;
2210    var context_default = Provider;
2211  
2212    // packages/data/build-module/components/registry-provider/use-registry.mjs
2213    function useRegistry() {
2214      return (0, import_element2.useContext)(Context);
2215    }
2216  
2217    // packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2218    var import_element4 = __toESM(require_element(), 1);
2219  
2220    // packages/data/build-module/components/async-mode-provider/context.mjs
2221    var import_element3 = __toESM(require_element(), 1);
2222    var Context2 = (0, import_element3.createContext)(false);
2223    Context2.displayName = "AsyncModeContext";
2224    var { Consumer: Consumer2, Provider: Provider2 } = Context2;
2225    var context_default2 = Provider2;
2226  
2227    // packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2228    function useAsyncMode() {
2229      return (0, import_element4.useContext)(Context2);
2230    }
2231  
2232    // packages/data/build-module/components/use-select/index.mjs
2233    var renderQueue = (0, import_priority_queue.createQueue)();
2234    function warnOnUnstableReference(a, b) {
2235      if (!a || !b) {
2236        return;
2237      }
2238      const keys = typeof a === "object" && typeof b === "object" ? Object.keys(a).filter((k) => a[k] !== b[k]) : [];
2239      console.warn(
2240        "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",
2241        keys.join(", ")
2242      );
2243    }
2244    function Store(registry, suspense) {
2245      const select3 = suspense ? registry.suspendSelect : registry.select;
2246      const queueContext = {};
2247      let lastMapSelect;
2248      let lastMapResult;
2249      let lastMapResultValid = false;
2250      let lastIsAsync;
2251      let subscriber;
2252      let didWarnUnstableReference;
2253      const storeStatesOnMount = /* @__PURE__ */ new Map();
2254      function getStoreState(name) {
2255        return registry.stores[name]?.store?.getState?.() ?? {};
2256      }
2257      const createSubscriber = (stores) => {
2258        const activeStores = [...stores];
2259        const activeSubscriptions = /* @__PURE__ */ new Set();
2260        function subscribe2(listener) {
2261          if (lastMapResultValid) {
2262            for (const name of activeStores) {
2263              if (storeStatesOnMount.get(name) !== getStoreState(name)) {
2264                lastMapResultValid = false;
2265              }
2266            }
2267          }
2268          storeStatesOnMount.clear();
2269          const onStoreChange = () => {
2270            lastMapResultValid = false;
2271            listener();
2272          };
2273          const onChange = () => {
2274            if (lastIsAsync) {
2275              renderQueue.add(queueContext, onStoreChange);
2276            } else {
2277              onStoreChange();
2278            }
2279          };
2280          const unsubs = [];
2281          function subscribeStore(storeName) {
2282            unsubs.push(registry.subscribe(onChange, storeName));
2283          }
2284          for (const storeName of activeStores) {
2285            subscribeStore(storeName);
2286          }
2287          activeSubscriptions.add(subscribeStore);
2288          return () => {
2289            activeSubscriptions.delete(subscribeStore);
2290            for (const unsub of unsubs.values()) {
2291              unsub?.();
2292            }
2293            renderQueue.cancel(queueContext);
2294          };
2295        }
2296        function updateStores(newStores) {
2297          for (const newStore of newStores) {
2298            if (activeStores.includes(newStore)) {
2299              continue;
2300            }
2301            activeStores.push(newStore);
2302            for (const subscription of activeSubscriptions) {
2303              subscription(newStore);
2304            }
2305          }
2306        }
2307        return { subscribe: subscribe2, updateStores };
2308      };
2309      return (mapSelect, isAsync) => {
2310        function updateValue() {
2311          if (lastMapResultValid && mapSelect === lastMapSelect) {
2312            return;
2313          }
2314          const listeningStores = { current: null };
2315          const mapResult = registry.__unstableMarkListeningStores(
2316            () => mapSelect(select3, registry),
2317            listeningStores
2318          );
2319          if (true) {
2320            if (!didWarnUnstableReference) {
2321              const secondMapResult = mapSelect(select3, registry);
2322              if (!(0, import_is_shallow_equal.isShallowEqual)(mapResult, secondMapResult)) {
2323                warnOnUnstableReference(mapResult, secondMapResult);
2324                didWarnUnstableReference = true;
2325              }
2326            }
2327          }
2328          if (!subscriber) {
2329            for (const name of listeningStores.current) {
2330              storeStatesOnMount.set(name, getStoreState(name));
2331            }
2332            subscriber = createSubscriber(listeningStores.current);
2333          } else {
2334            subscriber.updateStores(listeningStores.current);
2335          }
2336          if (!(0, import_is_shallow_equal.isShallowEqual)(lastMapResult, mapResult)) {
2337            lastMapResult = mapResult;
2338          }
2339          lastMapSelect = mapSelect;
2340          lastMapResultValid = true;
2341        }
2342        function getValue() {
2343          updateValue();
2344          return lastMapResult;
2345        }
2346        if (lastIsAsync && !isAsync) {
2347          lastMapResultValid = false;
2348          renderQueue.cancel(queueContext);
2349        }
2350        updateValue();
2351        lastIsAsync = isAsync;
2352        return { subscribe: subscriber.subscribe, getValue };
2353      };
2354    }
2355    function _useStaticSelect(storeName) {
2356      return useRegistry().select(storeName);
2357    }
2358    function _useMappingSelect(suspense, mapSelect, deps) {
2359      const registry = useRegistry();
2360      const isAsync = useAsyncMode();
2361      const store = (0, import_element5.useMemo)(
2362        () => Store(registry, suspense),
2363        [registry, suspense]
2364      );
2365      const selector = (0, import_element5.useCallback)(mapSelect, deps);
2366      const { subscribe: subscribe2, getValue } = store(selector, isAsync);
2367      const result = (0, import_element5.useSyncExternalStore)(subscribe2, getValue, getValue);
2368      (0, import_element5.useDebugValue)(result);
2369      return result;
2370    }
2371    function useSelect(mapSelect, deps) {
2372      const staticSelectMode = typeof mapSelect !== "function";
2373      const staticSelectModeRef = (0, import_element5.useRef)(staticSelectMode);
2374      if (staticSelectMode !== staticSelectModeRef.current) {
2375        const prevMode = staticSelectModeRef.current ? "static" : "mapping";
2376        const nextMode = staticSelectMode ? "static" : "mapping";
2377        throw new Error(
2378          `Switching useSelect from $prevMode} to $nextMode} is not allowed`
2379        );
2380      }
2381      return staticSelectMode ? _useStaticSelect(mapSelect) : _useMappingSelect(false, mapSelect, deps);
2382    }
2383    function useSuspenseSelect(mapSelect, deps) {
2384      return _useMappingSelect(true, mapSelect, deps);
2385    }
2386  
2387    // packages/data/build-module/components/with-select/index.mjs
2388    var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
2389    var withSelect = (mapSelectToProps) => (0, import_compose2.createHigherOrderComponent)(
2390      (WrappedComponent) => (0, import_element6.memo)(
2391        (0, import_element6.forwardRef)(function WithSelect(ownProps, ref) {
2392          const mapSelect = (select3, registry) => mapSelectToProps(select3, ownProps, registry);
2393          const mergeProps = useSelect(mapSelect);
2394          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
2395            WrappedComponent,
2396            {
2397              ref,
2398              ...ownProps,
2399              ...mergeProps
2400            }
2401          );
2402        })
2403      ),
2404      "withSelect"
2405    );
2406    var with_select_default = withSelect;
2407  
2408    // packages/data/build-module/components/with-dispatch/index.mjs
2409    var import_compose4 = __toESM(require_compose(), 1);
2410  
2411    // packages/data/build-module/components/use-dispatch/use-dispatch.mjs
2412    var useDispatch = (storeNameOrDescriptor) => {
2413      const { dispatch: dispatch3 } = useRegistry();
2414      return storeNameOrDescriptor === void 0 ? dispatch3 : dispatch3(storeNameOrDescriptor);
2415    };
2416    var use_dispatch_default = useDispatch;
2417  
2418    // packages/data/build-module/components/use-dispatch/use-dispatch-with-map.mjs
2419    var import_element7 = __toESM(require_element(), 1);
2420    var import_compose3 = __toESM(require_compose(), 1);
2421    var useDispatchWithMap = (dispatchMap, deps) => {
2422      const registry = useRegistry();
2423      const currentDispatchMapRef = (0, import_element7.useRef)(dispatchMap);
2424      (0, import_compose3.useIsomorphicLayoutEffect)(() => {
2425        currentDispatchMapRef.current = dispatchMap;
2426      });
2427      return (0, import_element7.useMemo)(() => {
2428        const currentDispatchProps = currentDispatchMapRef.current(
2429          registry.dispatch,
2430          registry
2431        );
2432        return Object.fromEntries(
2433          Object.entries(currentDispatchProps).map(
2434            ([propName, dispatcher]) => {
2435              if (typeof dispatcher !== "function") {
2436                console.warn(
2437                  `Property $propName} returned from dispatchMap in useDispatchWithMap must be a function.`
2438                );
2439              }
2440              return [
2441                propName,
2442                (...args) => currentDispatchMapRef.current(registry.dispatch, registry)[propName](...args)
2443              ];
2444            }
2445          )
2446        );
2447      }, [registry, ...deps]);
2448    };
2449    var use_dispatch_with_map_default = useDispatchWithMap;
2450  
2451    // packages/data/build-module/components/with-dispatch/index.mjs
2452    var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
2453    var withDispatch = (mapDispatchToProps) => (0, import_compose4.createHigherOrderComponent)(
2454      (WrappedComponent) => (ownProps) => {
2455        const mapDispatch = (dispatch3, registry) => mapDispatchToProps(dispatch3, ownProps, registry);
2456        const dispatchProps = use_dispatch_with_map_default(mapDispatch, []);
2457        return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WrappedComponent, { ...ownProps, ...dispatchProps });
2458      },
2459      "withDispatch"
2460    );
2461    var with_dispatch_default = withDispatch;
2462  
2463    // packages/data/build-module/components/with-registry/index.mjs
2464    var import_compose5 = __toESM(require_compose(), 1);
2465    var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
2466    var withRegistry = (0, import_compose5.createHigherOrderComponent)(
2467      (OriginalComponent) => (props) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(RegistryConsumer, { children: (registry) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(OriginalComponent, { ...props, registry }) }),
2468      "withRegistry"
2469    );
2470    var with_registry_default = withRegistry;
2471  
2472    // packages/data/build-module/dispatch.mjs
2473    function dispatch2(storeNameOrDescriptor) {
2474      return default_registry_default.dispatch(
2475        storeNameOrDescriptor
2476      );
2477    }
2478  
2479    // packages/data/build-module/select.mjs
2480    function select2(storeNameOrDescriptor) {
2481      return default_registry_default.select(
2482        storeNameOrDescriptor
2483      );
2484    }
2485  
2486    // packages/data/build-module/index.mjs
2487    var combineReducers2 = combineReducers;
2488    function resolveSelect2(storeNameOrDescriptor) {
2489      return default_registry_default.resolveSelect(
2490        storeNameOrDescriptor
2491      );
2492    }
2493    var suspendSelect = (storeNameOrDescriptor) => default_registry_default.suspendSelect(storeNameOrDescriptor);
2494    var subscribe = (listener, storeNameOrDescriptor) => default_registry_default.subscribe(listener, storeNameOrDescriptor);
2495    var registerGenericStore = default_registry_default.registerGenericStore;
2496    var registerStore = default_registry_default.registerStore;
2497    var use = default_registry_default.use;
2498    var register = (store) => default_registry_default.register(store);
2499    return __toCommonJS(index_exports);
2500  })();
2501  /*! Bundled license information:
2502  
2503  is-plain-object/dist/is-plain-object.mjs:
2504    (*!
2505     * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
2506     *
2507     * Copyright (c) 2014-2017, Jon Schlinkert.
2508     * Released under the MIT License.
2509     *)
2510  */
2511  (window.wp ||= {}).data = wp.data;
2512  })();