https://riffmagazine.com/wp-includes/js/dist/data.js?ver=c64d89d47908ae6c6928

1/******/ (() => { // webpackBootstrap
2/******/ 	"use strict";
3/******/ 	var __webpack_modules__ = ({
4
5/***/ 66:
6/***/ ((module) => {
7
8
9
10var isMergeableObject = function isMergeableObject(value) {
11	return isNonNullObject(value)
12		&& !isSpecial(value)
13};
14
15function isNonNullObject(value) {
16	return !!value && typeof value === 'object'
17}
18
19function isSpecial(value) {
20	var stringValue = Object.prototype.toString.call(value);
21
22	return stringValue === '[object RegExp]'
23		|| stringValue === '[object Date]'
24		|| isReactElement(value)
25}
26
27// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
28var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
29var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
30
31function isReactElement(value) {
32	return value.$$typeof === REACT_ELEMENT_TYPE
33}
34
35function emptyTarget(val) {
36	return Array.isArray(val) ? [] : {}
37}
38
39function cloneUnlessOtherwiseSpecified(value, options) {
40	return (options.clone !== false && options.isMergeableObject(value))
41		? deepmerge(emptyTarget(value), value, options)
42		: value
43}
44
45function defaultArrayMerge(target, source, options) {
46	return target.concat(source).map(function(element) {
47		return cloneUnlessOtherwiseSpecified(element, options)
48	})
49}
50
51function getMergeFunction(key, options) {
52	if (!options.customMerge) {
53		return deepmerge
54	}
55	var customMerge = options.customMerge(key);
56	return typeof customMerge === 'function' ? customMerge : deepmerge
57}
58
59function getEnumerableOwnPropertySymbols(target) {
60	return Object.getOwnPropertySymbols
61		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
62			return Object.propertyIsEnumerable.call(target, symbol)
63		})
64		: []
65}
66
67function getKeys(target) {
68	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
69}
70
71function propertyIsOnObject(object, property) {
72	try {
73		return property in object
74	} catch(_) {
75		return false
76	}
77}
78
79// Protects from prototype poisoning and unexpected merging up the prototype chain.
80function propertyIsUnsafe(target, key) {
81	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
82		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
83			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
84}
85
86function mergeObject(target, source, options) {
87	var destination = {};
88	if (options.isMergeableObject(target)) {
89		getKeys(target).forEach(function(key) {
90			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
91		});
92	}
93	getKeys(source).forEach(function(key) {
94		if (propertyIsUnsafe(target, key)) {
95			return
96		}
97
98		if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
99			destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
100		} else {
101			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
102		}
103	});
104	return destination
105}
106
107function deepmerge(target, source, options) {
108	options = options || {};
109	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
110	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
111	// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
112	// implementations can use it. The caller may not replace it.
113	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
114
115	var sourceIsArray = Array.isArray(source);
116	var targetIsArray = Array.isArray(target);
117	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
118
119	if (!sourceAndTargetTypesMatch) {
120		return cloneUnlessOtherwiseSpecified(source, options)
121	} else if (sourceIsArray) {
122		return options.arrayMerge(target, source, options)
123	} else {
124		return mergeObject(target, source, options)
125	}
126}
127
128deepmerge.all = function deepmergeAll(array, options) {
129	if (!Array.isArray(array)) {
130		throw new Error('first argument should be an array')
131	}
132
133	return array.reduce(function(prev, next) {
134		return deepmerge(prev, next, options)
135	}, {})
136};
137
138var deepmerge_1 = deepmerge;
139
140module.exports = deepmerge_1;
141
142
143/***/ }),
144
145/***/ 3249:
146/***/ ((module) => {
147
148
149
150function _typeof(obj) {
151  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
152    _typeof = function (obj) {
153      return typeof obj;
154    };
155  } else {
156    _typeof = function (obj) {
157      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
158    };
159  }
160
161  return _typeof(obj);
162}
163
164function _classCallCheck(instance, Constructor) {
165  if (!(instance instanceof Constructor)) {
166    throw new TypeError("Cannot call a class as a function");
167  }
168}
169
170function _defineProperties(target, props) {
171  for (var i = 0; i < props.length; i++) {
172    var descriptor = props[i];
173    descriptor.enumerable = descriptor.enumerable || false;
174    descriptor.configurable = true;
175    if ("value" in descriptor) descriptor.writable = true;
176    Object.defineProperty(target, descriptor.key, descriptor);
177  }
178}
179
180function _createClass(Constructor, protoProps, staticProps) {
181  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
182  if (staticProps) _defineProperties(Constructor, staticProps);
183  return Constructor;
184}
185

186/**
187 * Given an instance of EquivalentKeyMap, returns its internal value pair tuple
188 * for a key, if one exists. The tuple members consist of the last reference
189 * value for the key (used in efficient subsequent lookups) and the value
190 * assigned for the key at the leaf node.
191 *
192 * @param {EquivalentKeyMap} instance EquivalentKeyMap instance.
193 * @param {*} key                     The key for which to return value pair.
194 *
195 * @return {?Array} Value pair, if exists.
196 */
197function getValuePair(instance, key) {
198  var _map = instance._map,
199      _arrayTreeMap = instance._arrayTreeMap,
200      _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the
201  // value, which can be used to shortcut immediately to the value.
202
203  if (_map.has(key)) {
204    return _map.get(key);
205  } // Sort keys to ensure stable retrieval from tree.
206
207
208  var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value.
209
210  var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;
211
212  for (var i = 0; i < properties.length; i++) {
213    var property = properties[i];
214    map = map.get(property);
215
216    if (map === undefined) {
217      return;
218    }
219
220    var propertyValue = key[property];
221    map = map.get(propertyValue);
222
223    if (map === undefined) {
224      return;
225    }
226  }
227
228  var valuePair = map.get('_ekm_value');
229
230  if (!valuePair) {
231    return;
232  } // If reached, it implies that an object-like key was set with another
233  // reference, so delete the reference and replace with the current.
234
235
236  _map.delete(valuePair[0]);
237
238  valuePair[0] = key;
239  map.set('_ekm_value', valuePair);
240
241  _map.set(key, valuePair);
242
243  return valuePair;
244}
245/**
246 * Variant of a Map object which enables lookup by equivalent (deeply equal)
247 * object and array keys.
248 */
249
250
251var EquivalentKeyMap =
252/*#__PURE__*/
253function () {
254  /**
255   * Constructs a new instance of EquivalentKeyMap.
256   *
257   * @param {Iterable.<*>} iterable Initial pair of key, value for map.
258   */
259  function EquivalentKeyMap(iterable) {
260    _classCallCheck(this, EquivalentKeyMap);
261
262    this.clear();
263
264    if (iterable instanceof EquivalentKeyMap) {
265      // Map#forEach is only means of iterating with support for IE11.
266      var iterablePairs = [];
267      iterable.forEach(function (value, key) {
268        iterablePairs.push([key, value]);
269      });
270      iterable = iterablePairs;
271    }
272
273    if (iterable != null) {
274      for (var i = 0; i < iterable.length; i++) {
275        this.set(iterable[i][0], iterable[i][1]);
276      }
277    }
278  }
279  /**
280   * Accessor property returning the number of elements.
281   *
282   * @return {number} Number of elements.
283   */
284
285
286  _createClass(EquivalentKeyMap, [{
287    key: "set",
288
289    /**
290     * Add or update an element with a specified key and value.
291     *
292     * @param {*} key   The key of the element to add.
293     * @param {*} value The value of the element to add.
294     *
295     * @return {EquivalentKeyMap} Map instance.
296     */
297    value: function set(key, value) {
298      // Shortcut non-object-like to set on internal Map.
299      if (key === null || _typeof(key) !== 'object') {
300        this._map.set(key, value);
301
302        return this;
303      } // Sort keys to ensure stable assignment into tree.
304
305
306      var properties = Object.keys(key).sort();
307      var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value.
308
309      var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;
310
311      for (var i = 0; i < properties.length; i++) {
312        var property = properties[i];
313
314        if (!map.has(property)) {
315          map.set(property, new EquivalentKeyMap());
316        }
317
318        map = map.get(property);
319        var propertyValue = key[property];
320
321        if (!map.has(propertyValue)) {
322          map.set(propertyValue, new EquivalentKeyMap());
323        }
324
325        map = map.get(propertyValue);
326      } // If an _ekm_value exists, there was already an equivalent key. Before
327      // overriding, ensure that the old key reference is removed from map to
328      // avoid memory leak of accumulating equivalent keys. This is, in a
329      // sense, a poor man's WeakMap, while still enabling iterability.
330
331
332      var previousValuePair = map.get('_ekm_value');
333
334      if (previousValuePair) {
335        this._map.delete(previousValuePair[0]);
336      }
337

338      map.set('_ekm_value', valuePair);
339
340      this._map.set(key, valuePair);
341
342      return this;
343    }
344    /**
345     * Returns a specified element.
346     *
347     * @param {*} key The key of the element to return.
348     *
349     * @return {?*} The element associated with the specified key or undefined
350     *              if the key can't be found.
351     */
352
353  }, {
354    key: "get",
355    value: function get(key) {
356      // Shortcut non-object-like to get from internal Map.
357      if (key === null || _typeof(key) !== 'object') {
358        return this._map.get(key);
359      }
360
361      var valuePair = getValuePair(this, key);
362
363      if (valuePair) {
364        return valuePair[1];
365      }
366    }
367    /**
368     * Returns a boolean indicating whether an element with the specified key
369     * exists or not.
370     *
371     * @param {*} key The key of the element to test for presence.
372     *
373     * @return {boolean} Whether an element with the specified key exists.
374     */
375
376  }, {
377    key: "has",
378    value: function has(key) {
379      if (key === null || _typeof(key) !== 'object') {
380        return this._map.has(key);
381      } // Test on the _presence_ of the pair, not its value, as even undefined
382      // can be a valid member value for a key.
383
384
385      return getValuePair(this, key) !== undefined;
386    }
387    /**
388     * Removes the specified element.
389     *
390     * @param {*} key The key of the element to remove.
391     *
392     * @return {boolean} Returns true if an element existed and has been
393     *                   removed, or false if the element does not exist.
394     */
395
396  }, {
397    key: "delete",
398    value: function _delete(key) {
399      if (!this.has(key)) {
400        return false;
401      } // This naive implementation will leave orphaned child trees. A better
402      // implementation should traverse and remove orphans.
403
404
405      this.set(key, undefined);
406      return true;
407    }
408    /**
409     * Executes a provided function once per each key/value pair, in insertion
410     * order.
411     *
412     * @param {Function} callback Function to execute for each element.
413     * @param {*}        thisArg  Value to use as `this` when executing
414     *                            `callback`.
415     */
416
417  }, {
418    key: "forEach",
419    value: function forEach(callback) {
420      var _this = this;
421
422      var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;
423
424      this._map.forEach(function (value, key) {
425        // Unwrap value from object-like value pair.
426        if (key !== null && _typeof(key) === 'object') {
427          value = value[1];
428        }
429
430        callback.call(thisArg, value, key, _this);
431      });
432    }
433    /**
434     * Removes all elements.
435     */
436
437  }, {
438    key: "clear",
439    value: function clear() {
440      this._map = new Map();
441      this._arrayTreeMap = new Map();
442      this._objectTreeMap = new Map();
443    }
444  }, {
445    key: "size",
446    get: function get() {
447      return this._map.size;
448    }
449  }]);
450
451  return EquivalentKeyMap;
452}();
453
454module.exports = EquivalentKeyMap;
455
456
457/***/ })
458
459/******/ 	});
460/************************************************************************/
461/******/ 	// The module cache
462/******/ 	var __webpack_module_cache__ = {};
463/******/ 	
464/******/ 	// The require function
465/******/ 	function __webpack_require__(moduleId) {
466/******/ 		// Check if module is in cache
467/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
468/******/ 		if (cachedModule !== undefined) {
469/******/ 			return cachedModule.exports;
470/******/ 		}
471/******/ 		// Create a new module (and put it into the cache)
472/******/ 		var module = __webpack_module_cache__[moduleId] = {
473/******/ 			// no module.id needed
474/******/ 			// no module.loaded needed
475/******/ 			exports: {}
476/******/ 		};
477/******/ 	
478/******/ 		// Execute the module function
479/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
480/******/ 	
481/******/ 		// Return the exports of the module
482/******/ 		return module.exports;
483/******/ 	}
484/******/ 	
485/************************************************************************/
486/******/ 	/* webpack/runtime/compat get default export */
487/******/ 	(() => {
488/******/ 		// getDefaultExport function for compatibility with non-harmony modules
489/******/ 		__webpack_require__.n = (module) => {

490/******/ 			var getter = module && module.__esModule ?
491/******/ 				() => (module['default']) :
492/******/ 				() => (module);
493/******/ 			__webpack_require__.d(getter, { a: getter });
494/******/ 			return getter;
495/******/ 		};
496/******/ 	})();
497/******/ 	
498/******/ 	/* webpack/runtime/define property getters */
499/******/ 	(() => {
500/******/ 		// define getter functions for harmony exports
501/******/ 		__webpack_require__.d = (exports, definition) => {
502/******/ 			for(var key in definition) {
503/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
504/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
505/******/ 				}
506/******/ 			}
507/******/ 		};
508/******/ 	})();
509/******/ 	
510/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
511/******/ 	(() => {
512/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
513/******/ 	})();
514/******/ 	
515/******/ 	/* webpack/runtime/make namespace object */
516/******/ 	(() => {
517/******/ 		// define __esModule on exports
518/******/ 		__webpack_require__.r = (exports) => {
519/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
520/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
521/******/ 			}
522/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
523/******/ 		};
524/******/ 	})();
525/******/ 	
526/************************************************************************/
527var __webpack_exports__ = {};
528// ESM COMPAT FLAG
529__webpack_require__.r(__webpack_exports__);
530
531// EXPORTS
532__webpack_require__.d(__webpack_exports__, {
533  AsyncModeProvider: () => (/* reexport */ context_context_default),
534  RegistryConsumer: () => (/* reexport */ RegistryConsumer),
535  RegistryProvider: () => (/* reexport */ context_default),
536  combineReducers: () => (/* binding */ build_module_combineReducers),
537  controls: () => (/* reexport */ controls),
538  createReduxStore: () => (/* reexport */ createReduxStore),
539  createRegistry: () => (/* reexport */ createRegistry),
540  createRegistryControl: () => (/* reexport */ createRegistryControl),
541  createRegistrySelector: () => (/* reexport */ createRegistrySelector),
542  createSelector: () => (/* reexport */ rememo),
543  dispatch: () => (/* reexport */ dispatch_dispatch),
544  plugins: () => (/* reexport */ plugins_namespaceObject),
545  register: () => (/* binding */ register),
546  registerGenericStore: () => (/* binding */ registerGenericStore),
547  registerStore: () => (/* binding */ registerStore),
548  resolveSelect: () => (/* binding */ build_module_resolveSelect),
549  select: () => (/* reexport */ select_select),
550  subscribe: () => (/* binding */ subscribe),
551  suspendSelect: () => (/* binding */ suspendSelect),
552  use: () => (/* binding */ use),
553  useDispatch: () => (/* reexport */ use_dispatch_default),
554  useRegistry: () => (/* reexport */ useRegistry),
555  useSelect: () => (/* reexport */ useSelect),
556  useSuspenseSelect: () => (/* reexport */ useSuspenseSelect),
557  withDispatch: () => (/* reexport */ with_dispatch_default),
558  withRegistry: () => (/* reexport */ with_registry_default),
559  withSelect: () => (/* reexport */ with_select_default)
560});
561
562// NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js
563var selectors_namespaceObject = {};
564__webpack_require__.r(selectors_namespaceObject);
565__webpack_require__.d(selectors_namespaceObject, {
566  countSelectorsByStatus: () => (countSelectorsByStatus),
567  getCachedResolvers: () => (getCachedResolvers),
568  getIsResolving: () => (getIsResolving),
569  getResolutionError: () => (getResolutionError),
570  getResolutionState: () => (getResolutionState),
571  hasFinishedResolution: () => (hasFinishedResolution),
572  hasResolutionFailed: () => (hasResolutionFailed),
573  hasResolvingSelectors: () => (hasResolvingSelectors),
574  hasStartedResolution: () => (hasStartedResolution),
575  isResolving: () => (isResolving)
576});
577
578// NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js
579var actions_namespaceObject = {};
580__webpack_require__.r(actions_namespaceObject);
581__webpack_require__.d(actions_namespaceObject, {
582  failResolution: () => (failResolution),
583  failResolutions: () => (failResolutions),
584  finishResolution: () => (finishResolution),
585  finishResolutions: () => (finishResolutions),
586  invalidateResolution: () => (invalidateResolution),
587  invalidateResolutionForStore: () => (invalidateResolutionForStore),
588  invalidateResolutionForStoreSelector: () => (invalidateResolutionForStoreSelector),
589  startResolution: () => (startResolution),
590  startResolutions: () => (startResolutions)
591});
592
593// NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/plugins/index.js
594var plugins_namespaceObject = {};
595__webpack_require__.r(plugins_namespaceObject);
596__webpack_require__.d(plugins_namespaceObject, {
597  persistence: () => (persistence_default)
598});
599
600;

600// external ["wp","deprecated"]
601const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
602var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
603;// ./node_modules/redux/dist/redux.mjs

604// src/utils/formatProdErrorMessage.ts
605function formatProdErrorMessage(code) {
606  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
607}
608

609// src/utils/symbol-observable.ts
610var $$observable = /* @__PURE__ */ (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
611var symbol_observable_default = $$observable;
612
613// src/utils/actionTypes.ts
614var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
615var ActionTypes = {
616  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
617  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
618  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
619};
620var actionTypes_default = ActionTypes;
621

622// src/utils/isPlainObject.ts
623function isPlainObject(obj) {
624  if (typeof obj !== "object" || obj === null)
625    return false;
626  let proto = obj;
627  while (Object.getPrototypeOf(proto) !== null) {
628    proto = Object.getPrototypeOf(proto);
629  }
630  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
631}
632
633// src/utils/kindOf.ts
634function miniKindOf(val) {
635  if (val === void 0)
636    return "undefined";
637  if (val === null)
638    return "null";
639  const type = typeof val;
640  switch (type) {
641    case "boolean":
642    case "string":
643    case "number":
644    case "symbol":
645    case "function": {
646      return type;
647    }
648  }
649  if (Array.isArray(val))
650    return "array";
651  if (isDate(val))
652    return "date";
653  if (isError(val))
654    return "error";
655  const constructorName = ctorName(val);
656  switch (constructorName) {
657    case "Symbol":
658    case "Promise":
659    case "WeakMap":
660    case "WeakSet":
661    case "Map":
662    case "Set":
663      return constructorName;
664  }
665  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
666}
667function ctorName(val) {
668  return typeof val.constructor === "function" ? val.constructor.name : null;
669}
670function isError(val) {
671  return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
672}
673function isDate(val) {
674  if (val instanceof Date)
675    return true;
676  return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
677}
678function kindOf(val) {
679  let typeOfVal = typeof val;
680  if (

680false) {}
681  return typeOfVal;
682}
683

684// src/createStore.ts
685function createStore(reducer, preloadedState, enhancer) {
686  if (typeof reducer !== "function") {
687    throw new Error( true ? formatProdErrorMessage(2) : 0);
688  }
689  if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") {
690    throw new Error( true ? formatProdErrorMessage(0) : 0);
691  }
692  if (typeof preloadedState === "function" && typeof enhancer === "undefined") {
693    enhancer = preloadedState;
694    preloadedState = void 0;
695  }
696  if (typeof enhancer !== "undefined") {
697    if (typeof enhancer !== "function") {
698      throw new Error( true ? formatProdErrorMessage(1) : 0);
699    }
700    return enhancer(createStore)(reducer, preloadedState);
701  }
702  let currentReducer = reducer;
703  let currentState = preloadedState;
704  let currentListeners = /* @__PURE__ */ new Map();
705  let nextListeners = currentListeners;
706  let listenerIdCounter = 0;
707  let isDispatching = false;
708  function ensureCanMutateNextListeners() {
709    if (nextListeners === currentListeners) {
710      nextListeners = /* @__PURE__ */ new Map();
711      currentListeners.forEach((listener, key) => {
712        nextListeners.set(key, listener);
713      });
714    }
715  }
716  function getState() {
717    if (isDispatching) {
718      throw new Error( true ? formatProdErrorMessage(3) : 0);
719    }
720    return currentState;
721  }
722  function subscribe(listener) {
723    if (typeof listener !== "function") {
724      throw new Error( true ? formatProdErrorMessage(4) : 0);
725    }
726    if (isDispatching) {
727      throw new Error( true ? formatProdErrorMessage(5) : 0);
728    }
729    let isSubscribed = true;
730    ensureCanMutateNextListeners();
731    const listenerId = listenerIdCounter++;
732    nextListeners.set(listenerId, listener);
733    return function unsubscribe() {
734      if (!isSubscribed) {
735        return;
736      }
737      if (isDispatching) {
738        throw new Error( true ? formatProdErrorMessage(6) : 0);
739      }
740      isSubscribed = false;
741      ensureCanMutateNextListeners();
742      nextListeners.delete(listenerId);
743      currentListeners = null;
744    };
745  }
746  function dispatch(action) {
747    if (!isPlainObject(action)) {
748      throw new Error( true ? formatProdErrorMessage(7) : 0);
749    }
750    if (typeof action.type === "undefined") {
751      throw new Error( true ? formatProdErrorMessage(8) : 0);
752    }
753    if (typeof action.type !== "string") {
754      throw new Error( true ? formatProdErrorMessage(17) : 0);
755    }
756    if (isDispatching) {
757      throw new Error( true ? formatProdErrorMessage(9) : 0);
758    }
759    try {
760      isDispatching = true;
761      currentState = currentReducer(currentState, action);
762    } finally {
763      isDispatching = false;
764    }
765    const listeners = currentListeners = nextListeners;
766    listeners.forEach((listener) => {
767      listener();
768    });
769    return action;
770  }
771  function replaceReducer(nextReducer) {
772    if (typeof nextReducer !== "function") {
773      throw new Error( true ? formatProdErrorMessage(10) : 0);
774    }
775    currentReducer = nextReducer;
776    dispatch({
777      type: actionTypes_default.REPLACE
778    });
779  }
780  function observable() {
781    const outerSubscribe = subscribe;
782    return {
783      /**
784       * The minimal observable subscription method.
785       * @param observer Any object that can be used as an observer.
786       * The observer object should have a `next` method.
787       * @returns An object with an `unsubscribe` method that can
788       * be used to unsubscribe the observable from the store, and prevent further
789       * emission of values from the observable.
790       */
791      subscribe(observer) {
792        if (typeof observer !== "object" || observer === null) {
793          throw new Error( true ? formatProdErrorMessage(11) : 0

793);
794        }
795        function observeState() {
796          const observerAsObserver = observer;
797          if (observerAsObserver.next) {
798            observerAsObserver.next(getState());
799          }
800        }
801        observeState();
802        const unsubscribe = outerSubscribe(observeState);
803        return {
804          unsubscribe
805        };
806      },
807      [symbol_observable_default]() {
808        return this;
809      }
810    };
811  }
812  dispatch({
813    type: actionTypes_default.INIT
814  });
815  const store = {
816    dispatch,
817    subscribe,
818    getState,
819    replaceReducer,
820    [symbol_observable_default]: observable
821  };
822  return store;
823}
824function legacy_createStore(reducer, preloadedState, enhancer) {
825  return createStore(reducer, preloadedState, enhancer);
826}
827
828// src/utils/warning.ts
829function warning(message) {
830  if (typeof console !== "undefined" && typeof console.error === "function") {
831    console.error(message);
832  }
833  try {
834    throw new Error(message);
835  } catch (e) {
836  }
837}
838
839// src/combineReducers.ts
840function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
841  const reducerKeys = Object.keys(reducers);
842  const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer";
843  if (reducerKeys.length === 0) {
844    return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.";
845  }
846  if (!isPlainObject(inputState)) {
847    return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`;
848  }
849  const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);
850  unexpectedKeys.forEach((key) => {
851    unexpectedKeyCache[key] = true;
852  });
853  if (action && action.type === actionTypes_default.REPLACE)
854    return;
855  if (unexpectedKeys.length > 0) {
856    return `Unexpected ${unexpectedKeys.length > 1 ? "keys" : "key"} "${unexpectedKeys.join('", "')}" found in ${argumentName}. Expected to find one of the known reducer keys instead: "${reducerKeys.join('", "')}". Unexpected keys will be ignored.`;
857  }
858}
859function assertReducerShape(reducers) {
860  Object.keys(reducers).forEach((key) => {
861    const reducer = reducers[key];
862    const initialState = reducer(void 0, {
863      type: actionTypes_default.INIT
864    });
865    if (typeof initialState === "undefined") {
866      throw new Error(

866 true ? formatProdErrorMessage(12) : 0);
867    }
868    if (typeof reducer(void 0, {
869      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
870    }) === "undefined") {
871      throw new Error( true ? formatProdErrorMessage(13) : 0);
872    }
873  });
874}
875function combineReducers(reducers) {
876  const reducerKeys = Object.keys(reducers);
877  const finalReducers = {};
878  for (let i = 0; i < reducerKeys.length; i++) {
879    const key = reducerKeys[i];
880    if (false) {}
881    if (typeof reducers[key] === "function") {
882      finalReducers[key] = reducers[key];
883    }
884  }
885  const finalReducerKeys = Object.keys(finalReducers);
886  let unexpectedKeyCache;
887  if (false) {}
888  let shapeAssertionError;
889  try {
890    assertReducerShape(finalReducers);
891  } catch (e) {
892    shapeAssertionError = e;
893  }
894  return function combination(state = {}, action) {
895    if (shapeAssertionError) {
896      throw shapeAssertionError;
897    }
898    if (false) {}
899    let hasChanged = false;
900    const nextState = {};
901    for (let i = 0; i < finalReducerKeys.length; i++) {
902      const key = finalReducerKeys[i];
903      const reducer = finalReducers[key];
904      const previousStateForKey = state[key];
905      const nextStateForKey = reducer(previousStateForKey, action);
906      if (typeof nextStateForKey === "undefined") {
907        const actionType = action && action.type;
908        throw new Error( true ? formatProdErrorMessage(14) : 0);
909      }
910      nextState[key] = nextStateForKey;
911      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
912    }
913    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
914    return hasChanged ? nextState : state;
915  };
916}
917

918// src/bindActionCreators.ts
919function bindActionCreator(actionCreator, dispatch) {
920  return function(...args) {
921    return dispatch(actionCreator.apply(this, args));
922  };
923}
924function bindActionCreators(actionCreators, dispatch) {
925  if (typeof actionCreators === "function") {
926    return bindActionCreator(actionCreators, dispatch);
927  }
928  if (typeof actionCreators !== "object" || actionCreators === null) {
929    throw new Error( true ? formatProdErrorMessage(16) : 0);
930  }
931  const boundActionCreators = {};
932  for (const key in actionCreators) {
933    const actionCreator = actionCreators[key];
934    if (typeof actionCreator === "function") {
935      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
936    }
937  }
938  return boundActionCreators

938;
939}
940
941// src/compose.ts
942function compose(...funcs) {
943  if (funcs.length === 0) {
944    return (arg) => arg;
945  }
946  if (funcs.length === 1) {
947    return funcs[0];
948  }
949  return funcs.reduce((a, b) => (...args) => a(b(...args)));
950}
951
952// src/applyMiddleware.ts
953function applyMiddleware(...middlewares) {
954  return (createStore2) => (reducer, preloadedState) => {
955    const store = createStore2(reducer, preloadedState);
956    let dispatch = () => {
957      throw new Error(

957 true ? formatProdErrorMessage(15) : 0);
958    };
959    const middlewareAPI = {
960      getState: store.getState,
961      dispatch: (action, ...args) => dispatch(action, ...args)
962    };
963    const chain = middlewares.map((middleware) => middleware(middlewareAPI));
964    dispatch = compose(...chain)(store.dispatch);
965    return {
966      ...store,
967      dispatch
968    };
969  };
970}
971

972// src/utils/isAction.ts
973function isAction(action) {
974  return isPlainObject(action) && "type" in action && typeof action.type === "string";
975}
976
977//# sourceMappingURL=redux.mjs.map
978// EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js
979var equivalent_key_map = __webpack_require__(3249);
980var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map);
981;// external ["wp","reduxRoutine"]
982const external_wp_reduxRoutine_namespaceObject = window["wp"]["reduxRoutine"];
983var external_wp_reduxRoutine_default = /*#__PURE__*/__webpack_require__.n(external_wp_reduxRoutine_namespaceObject);
984;// external ["wp","compose"]
985const external_wp_compose_namespaceObject = window["wp"]["compose"];
986;// ./node_modules/@wordpress/data/build-module/redux-store/combine-reducers.js
987function combine_reducers_combineReducers(reducers) {
988  const keys = Object.keys(reducers);
989  return function combinedReducer(state = {}, action) {
990    const nextState = {};
991    let hasChanged = false;
992    for (const key of keys) {
993      const reducer = reducers[key];
994      const prevStateForKey = state[key];
995      const nextStateForKey = reducer(prevStateForKey, action);
996      nextState[key] = nextStateForKey;
997      hasChanged = hasChanged || nextStateForKey !== prevStateForKey;
998    }
999    return hasChanged ? nextState : state;
1000  };
1001}
1002
1003
1004;// ./node_modules/@wordpress/data/build-module/factory.js
1005function createRegistrySelector(registrySelector) {
1006  const selectorsByRegistry = /* @__PURE__ */ new WeakMap();
1007  const wrappedSelector = (...args) => {
1008    let selector = selectorsByRegistry.get(wrappedSelector.registry);
1009    if (!selector) {
1010      selector = registrySelector(wrappedSelector.registry.select);
1011      selectorsByRegistry.set(wrappedSelector.registry, selector);
1012    }
1013    return selector(...args);
1014  };
1015  wrappedSelector.isRegistrySelector = true;
1016  return wrappedSelector;
1017}
1018function createRegistryControl(registryControl) {
1019  registryControl.isRegistryControl = true;
1020  return registryControl;
1021}
1022
1023
1024;// ./node_modules/@wordpress/data/build-module/controls.js
1025
1026const SELECT = "@@data/SELECT";
1027const RESOLVE_SELECT = "@@data/RESOLVE_SELECT";
1028const DISPATCH = "@@data/DISPATCH";
1029function isObject(object) {
1030  return object !== null && typeof object === "object";
1031}
1032function controls_select(storeNameOrDescriptor, selectorName, ...args) {
1033  return {
1034    type: SELECT,
1035    storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
1036    selectorName,
1037    args
1038  };
1039}
1040function resolveSelect(storeNameOrDescriptor, selectorName, ...args) {
1041  return {
1042    type: RESOLVE_SELECT,
1043    storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
1044    selectorName,
1045    args
1046  };
1047}
1048function dispatch(storeNameOrDescriptor, actionName, ...args) {
1049  return {
1050    type: DISPATCH,
1051    storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
1052    actionName,
1053    args
1054  };
1055}
1056const controls = { select: controls_select, resolveSelect, dispatch };
1057const builtinControls = {
1058  [SELECT]: createRegistryControl(
1059    (registry) => ({ storeKey, selectorName, args }) => registry.select(storeKey)[selectorName](...args)
1060  ),
1061  [RESOLVE_SELECT]: createRegistryControl(
1062    (registry) => ({ storeKey, selectorName, args }) => {
1063      const method = registry.select(storeKey)[selectorName].hasResolver ? "resolveSelect" : "select";
1064      return registry[method](storeKey)[selectorName](
1065        ...args
1066      );
1067    }
1068  ),
1069  [DISPATCH]: createRegistryControl(
1070    (registry) => ({ storeKey, actionName, args }) => registry.dispatch(storeKey)[actionName](...args)
1071  )
1072};
1073
1074
1075;// external ["wp","privateApis"]
1076const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
1077;// ./node_modules/@wordpress/data/build-module/lock-unlock.js
1078
1079const { lock, unlock } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
1080  "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
1081  "@wordpress/data"
1082);
1083
1084
1085;// ./node_modules/is-promise/index.mjs
1086function isPromise(obj) {
1087  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
1088}
1089
1090;// ./node_modules/@wordpress/data/build-module/promise-middleware.js
1091
1092const promiseMiddleware = () => (next) => (action) => {

1093  if (isPromise(action)) {
1094    return action.then((resolvedAction) => {
1095      if (resolvedAction) {
1096        return next(resolvedAction);
1097      }
1098    });
1099  }
1100  return next(action);
1101};
1102var promise_middleware_default = promiseMiddleware;
1103
1104
1105;// ./node_modules/@wordpress/data/build-module/resolvers-cache-middleware.js
1106const createResolversCacheMiddleware = (registry, storeName) => () => (next) => (action) => {
1107  const resolvers = registry.select(storeName).getCachedResolvers();
1108  const resolverEntries = Object.entries(resolvers);
1109  resolverEntries.forEach(([selectorName, resolversByArgs]) => {
1110    const resolver = registry.stores[storeName]?.resolvers?.[selectorName];
1111    if (!resolver || !resolver.shouldInvalidate) {
1112      return;
1113    }
1114    resolversByArgs.forEach((value, args) => {
1115      if (value === void 0) {
1116        return;
1117      }
1118      if (value.status !== "finished" && value.status !== "error") {
1119        return;
1120      }
1121      if (!resolver.shouldInvalidate(action, ...args)) {
1122        return;
1123      }
1124      registry.dispatch(storeName).invalidateResolution(selectorName, args);
1125    });
1126  });
1127  return next(action);
1128};
1129var resolvers_cache_middleware_default = createResolversCacheMiddleware;
1130
1131
1132;// ./node_modules/@wordpress/data/build-module/redux-store/thunk-middleware.js
1133function createThunkMiddleware(args) {
1134  return () => (next) => (action) => {
1135    if (typeof action === "function") {
1136      return action(args);
1137    }
1138    return next(action);
1139  };
1140}
1141
1142
1143;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/utils.js
1144const onSubKey = (actionProperty) => (reducer) => (state = {}, action) => {
1145  const key = action[actionProperty];
1146  if (key === void 0) {
1147    return state;
1148  }
1149  const nextKeyState = reducer(state[key], action);
1150  if (nextKeyState === state[key]) {
1151    return state;
1152  }
1153  return {
1154    ...state,
1155    [key]: nextKeyState
1156  };
1157};
1158function selectorArgsToStateKey(args) {
1159  if (args === void 0 || args === null) {
1160    return [];
1161  }
1162  const len = args.length;
1163  let idx = len;
1164  while (idx > 0 && args[idx - 1] === void 0) {
1165    idx--;
1166  }
1167  return idx === len ? args : args.slice(0, idx);
1168}
1169
1170
1171;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/reducer.js
1172
1173
1174const subKeysIsResolved = onSubKey("selectorName")((state = new (equivalent_key_map_default())(), action) => {
1175  switch (action.type) {
1176    case "START_RESOLUTION": {
1177      const nextState = new (equivalent_key_map_default())(state);
1178      nextState.set(selectorArgsToStateKey(action.args), {
1179        status: "resolving"
1180      });
1181      return nextState;
1182    }
1183    case "FINISH_RESOLUTION": {
1184      const nextState = new (equivalent_key_map_default())(state);
1185      nextState.set(selectorArgsToStateKey(action.args), {
1186        status: "finished"
1187      });
1188      return nextState;
1189    }
1190    case "FAIL_RESOLUTION": {
1191      const nextState = new (equivalent_key_map_default())(state);
1192      nextState.set(selectorArgsToStateKey(action.args), {
1193        status: "error",
1194        error: action.error
1195      });
1196      return nextState;
1197    }
1198    case "START_RESOLUTIONS": {
1199      const nextState = new (equivalent_key_map_default())(state);

1200      for (const resolutionArgs of action.args) {
1201        nextState.set(selectorArgsToStateKey(resolutionArgs), {
1202          status: "resolving"
1203        });
1204      }
1205      return nextState;
1206    }
1207    case "FINISH_RESOLUTIONS": {
1208      const nextState = new (equivalent_key_map_default())(state);
1209      for (const resolutionArgs of action.args) {
1210        nextState.set(selectorArgsToStateKey(resolutionArgs), {
1211          status: "finished"
1212        });
1213      }
1214      return nextState;
1215    }
1216    case "FAIL_RESOLUTIONS": {
1217      const nextState = new (equivalent_key_map_default())(state);
1218      action.args.forEach((resolutionArgs, idx) => {
1219        const resolutionState = {
1220          status: "error",
1221          error: void 0
1222        };
1223        const error = action.errors[idx];
1224        if (error) {
1225          resolutionState.error = error;
1226        }
1227        nextState.set(
1228          selectorArgsToStateKey(resolutionArgs),
1229          resolutionState
1230        );
1231      });
1232      return nextState;
1233    }
1234    case "INVALIDATE_RESOLUTION": {
1235      const nextState = new (equivalent_key_map_default())(state);
1236      nextState.delete(selectorArgsToStateKey(action.args));
1237      return nextState;
1238    }
1239  }
1240  return state;
1241});
1242const isResolved = (state = {}, action) => {
1243  switch (action.type) {
1244    case "INVALIDATE_RESOLUTION_FOR_STORE":
1245      return {};
1246    case "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR": {
1247      if (action.selectorName in state) {
1248        const {
1249          [action.selectorName]: removedSelector,
1250          ...restState
1251        } = state;
1252        return restState;
1253      }
1254      return state;
1255    }
1256    case "START_RESOLUTION":
1257    case "FINISH_RESOLUTION":
1258    case "FAIL_RESOLUTION":
1259    case "START_RESOLUTIONS":
1260    case "FINISH_RESOLUTIONS":
1261    case "FAIL_RESOLUTIONS":
1262    case "INVALIDATE_RESOLUTION":
1263      return subKeysIsResolved(state, action);
1264  }
1265  return state;
1266};
1267var reducer_default = isResolved;
1268
1269
1270;// ./node_modules/rememo/rememo.js
1271
1272
1273/** @typedef {(...args: any[]) => *[]} GetDependants */
1274
1275/** @typedef {() => void} Clear */
1276
1277/**
1278 * @typedef {{
1279 *   getDependants: GetDependants,
1280 *   clear: Clear
1281 * }} EnhancedSelector
1282 */
1283
1284/**
1285 * Internal cache entry.
1286 *
1287 * @typedef CacheNode
1288 *
1289 * @property {?CacheNode|undefined} [prev] Previous node.
1290 * @property {?CacheNode|undefined} [next] Next node.
1291 * @property {*[]} args Function arguments for cache entry.
1292 * @property {*} val Function result.
1293 */
1294
1295/**
1296 * @typedef Cache
1297 *
1298 * @property {Clear} clear Function to clear cache.
1299 * @property {boolean} [isUniqueByDependants] Whether dependants are valid in
1300 * considering cache uniqueness. A cache is unique if dependents are all arrays
1301 * or objects.
1302 * @property {CacheNode?} [head] Cache head.
1303 * @property {*[]} [lastDependants] Dependants from previous invocation.
1304 */
1305
1306/**
1307 * Arbitrary value used as key for referencing cache object in WeakMap tree.
1308 *
1309 * @type {{}}
1310 */
1311var LEAF_KEY = {};
1312
1313/**
1314 * Returns the first argument as the sole entry in an array.
1315 *
1316 * @template T
1317 *
1318 * @param {T} value Value to return.
1319 *
1320 * @return {[T]} Value returned as entry in array.
1321 */
1322function arrayOf(value) {
1323	return [value];
1324}
1325
1326/**
1327 * Returns true if the value passed is object-like, or false otherwise. A value
1328 * is object-like if it can support property assignment, e.g. object or array.
1329 *
1330 * @param {*} value Value to test.
1331 *
1332 * @return {boolean} Whether value is object-like.
1333 */
1334function isObjectLike(value) {
1335	return !!value && 'object' === typeof value;
1336}
1337
1338/**
1339 * Creates and returns a new cache object.
1340 *
1341 * @return {Cache} Cache object.
1342 */
1343function createCache() {
1344	/** @type {Cache} */
1345	var cache = {
1346		clear: function () {
1347			cache.head = null;
1348		},
1349	};
1350
1351	return cache;
1352}
1353
1354/**
1355 * Returns true if entries within the two arrays are strictly equal by
1356 * reference from a starting index.
1357 *
1358 * @param {*[]} a First array.
1359 * @param {*[]} b Second array.
1360 * @param {number} fromIndex Index from which to start comparison.
1361 *
1362 * @return {boolean} Whether arrays are shallowly equal.
1363 */
1364function isShallowEqual(a, b, fromIndex) {
1365	var i;
1366
1367	if (a.length !== b.length) {
1368		return false;

1369	}
1370
1371	for (i = fromIndex; i < a.length; i++) {
1372		if (a[i] !== b[i]) {
1373			return false;
1374		}
1375	}
1376
1377	return true;
1378}
1379
1380/**
1381 * Returns a memoized selector function. The getDependants function argument is
1382 * called before the memoized selector and is expected to return an immutable
1383 * reference or array of references on which the selector depends for computing
1384 * its own return value. The memoize cache is preserved only as long as those
1385 * dependant references remain the same. If getDependants returns a different
1386 * reference(s), the cache is cleared and the selector value regenerated.
1387 *
1388 * @template {(...args: *[]) => *} S
1389 *
1390 * @param {S} selector Selector function.
1391 * @param {GetDependants=} getDependants Dependant getter returning an array of
1392 * references used in cache bust consideration.
1393 */
1394/* harmony default export */ function rememo(selector, getDependants) {
1395	/** @type {WeakMap<*,*>} */
1396	var rootCache;
1397
1398	/** @type {GetDependants} */
1399	var normalizedGetDependants = getDependants ? getDependants : arrayOf;
1400
1401	/**
1402	 * Returns the cache for a given dependants array. When possible, a WeakMap
1403	 * will be used to create a unique cache for each set of dependants. This
1404	 * is feasible due to the nature of WeakMap in allowing garbage collection
1405	 * to occur on entries where the key object is no longer referenced. Since
1406	 * WeakMap requires the key to be an object, this is only possible when the
1407	 * dependant is object-like. The root cache is created as a hierarchy where
1408	 * each top-level key is the first entry in a dependants set, the value a
1409	 * WeakMap where each key is the next dependant, and so on. This continues
1410	 * so long as the dependants are object-like. If no dependants are object-
1411	 * like, then the cache is shared across all invocations.
1412	 *
1413	 * @see isObjectLike
1414	 *
1415	 * @param {*[]}

1415 dependants Selector dependants.
1416	 *
1417	 * @return {Cache} Cache object.
1418	 */
1419	function getCache(dependants) {
1420		var caches = rootCache,
1421			isUniqueByDependants = true,
1422			i,
1423			dependant,
1424			map,
1425			cache;
1426
1427		for (i = 0; i < dependants.length; i++) {
1428			dependant = dependants[i];
1429
1430			// Can only compose WeakMap from object-like key.
1431			if (!isObjectLike(dependant)) {
1432				isUniqueByDependants = false;
1433				break;
1434			}
1435
1436			// Does current segment of cache already have a WeakMap?
1437			if (caches.has(dependant)) {
1438				// Traverse into nested WeakMap.
1439				caches = caches.get(dependant);
1440			} else {
1441				// Create, set, and traverse into a new one.
1442				map = new WeakMap();
1443				caches.set(dependant, map);
1444				caches = map;
1445			}
1446		}
1447
1448		// We use an arbitrary (but consistent) object as key for the last item
1449		// in the WeakMap to serve as our running cache.
1450		if (!caches.has(LEAF_KEY)) {
1451			cache = createCache();
1452			cache.isUniqueByDependants = isUniqueByDependants;
1453			caches.set(LEAF_KEY, cache);
1454		}
1455
1456		return caches.get(LEAF_KEY);
1457	}
1458
1459	/**
1460	 * Resets root memoization cache.
1461	 */
1462	function clear() {
1463		rootCache = new WeakMap();
1464	}
1465
1466	/* eslint-disable jsdoc/check-param-names */
1467	/**
1468	 * The augmented selector call, considering first whether dependants have
1469	 * changed before passing it to underlying memoize function.
1470	 *
1471	 * @param {*}    source    Source object for derivation.
1472	 * @param {...*} extraArgs Additional arguments to pass to selector.
1473	 *
1474	 * @return {*} Selector result.
1475	 */
1476	/* eslint-enable jsdoc/check-param-names */
1477	function callSelector(/* source, ...extraArgs */) {
1478		var len = arguments.length,
1479			cache,
1480			node,
1481			i,
1482			args,
1483			dependants;
1484
1485		// Create copy of arguments (avoid leaking deoptimization).
1486		args = new Array(len);
1487		for (i = 0; i < len; i++) {
1488			args[i] = arguments[i];
1489		}
1490
1491		dependants = normalizedGetDependants.apply(null, args);
1492		cache = getCache(dependants);
1493
1494		// If not guaranteed uniqueness by dependants (primitive type), shallow
1495		// compare against last dependants and, if references have changed,
1496		// destroy cache to recalculate result.
1497		if (!cache.isUniqueByDependants) {
1498			if (
1499				cache.lastDependants &&
1500				!isShallowEqual(dependants, cache.lastDependants, 0)
1501			) {
1502				cache.clear();
1503			}
1504
1505			cache.lastDependants = dependants;
1506		}
1507
1508		node = cache.head;
1509		while (node) {
1510			// Check whether node arguments match arguments
1511			if (!isShallowEqual(node.args, args, 1)) {
1512				node = node.next;
1513				continue;
1514			}
1515
1516			// At this point we can assume we've found a match
1517
1518			// Surface matched node to head if not already
1519			if (node !== cache.head) {
1520				// Adjust siblings to point to each other.
1521				/** @type {CacheNode} */ (node.prev).next = node.next;
1522				if (node.next) {
1523					node.next.prev = node.prev;
1524				}
1525
1526				node.next = cache.head;
1527				node.prev = null;
1528				/** @type {CacheNode} */ (cache.head).prev = node;
1529				cache.head = node;
1530			}
1531
1532			// Return immediately
1533			return node.val;
1534		}
1535
1536		// No cached value found. Continue to insertion phase:
1537
1538		node = /** @type {CacheNode} */ ({
1539			// Generate the result from original function
1540			val: selector.apply(null, args),
1541		});
1542
1543		// Avoid including the source object in the cache.
1544		args[0] = null;
1545		node.args = args;
1546
1547		// Don't need to check whether node is already head, since it would
1548		// have been returned above already if it was
1549
1550		// Shift existing head down list
1551		if (cache.head) {
1552			cache.head.prev = node;
1553			node.next = cache.head;
1554		}
1555
1556		cache.head = node;
1557
1558		return node.val;
1559	}
1560
1561	callSelector.getDependants = normalizedGetDependants;
1562	callSelector.clear = clear;
1563	clear();
1564
1565	return /** @type {S & EnhancedSelector} */ (callSelector);
1566}
1567
1568;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js
1569
1570
1571
1572function getResolutionState(state, selectorName, args) {
1573  const map = state[selectorName];
1574  if (!map) {
1575    return;
1576  }
1577  return map.get(selectorArgsToStateKey(args));
1578}
1579function getIsResolving(state, selectorName, args) {
1580  external_wp_deprecated_default()("wp.data.select( store ).getIsResolving", {
1581    since: "6.6",
1582    version: "6.8",

1583    alternative: "wp.data.select( store ).getResolutionState"
1584  });
1585  const resolutionState = getResolutionState(state, selectorName, args);
1586  return resolutionState && resolutionState.status === "resolving";
1587}
1588function hasStartedResolution(state, selectorName, args) {
1589  return getResolutionState(state, selectorName, args) !== void 0;
1590}
1591function hasFinishedResolution(state, selectorName, args) {
1592  const status = getResolutionState(state, selectorName, args)?.status;
1593  return status === "finished" || status === "error";
1594}
1595function hasResolutionFailed(state, selectorName, args) {
1596  return getResolutionState(state, selectorName, args)?.status === "error";
1597}
1598function getResolutionError(state, selectorName, args) {
1599  const resolutionState = getResolutionState(state, selectorName, args);
1600  return resolutionState?.status === "error" ? resolutionState.error : null;
1601}
1602function isResolving(state, selectorName, args) {
1603  return getResolutionState(state, selectorName, args)?.status === "resolving";
1604}
1605function getCachedResolvers(state) {
1606  return state;
1607}
1608function hasResolvingSelectors(state) {
1609  return Object.values(state).some(
1610    (selectorState) => (
1611      /**
1612       * This uses the internal `_map` property of `EquivalentKeyMap` for
1613       * optimization purposes, since the `EquivalentKeyMap` implementation
1614       * does not support a `.values()` implementation.
1615       *
1616       * @see https://github.com/aduth/equivalent-key-map
1617       */
1618      Array.from(selectorState._map.values()).some(
1619        (resolution) => resolution[1]?.status === "resolving"
1620      )
1621    )
1622  );
1623}
1624const countSelectorsByStatus = rememo(
1625  (state) => {
1626    const selectorsByStatus = {};
1627    Object.values(state).forEach(
1628      (selectorState) => (
1629        /**
1630         * This uses the internal `_map` property of `EquivalentKeyMap` for
1631         * optimization purposes, since the `EquivalentKeyMap` implementation
1632         * does not support a `.values()` implementation.
1633         *
1634         * @see https://github.com/aduth/equivalent-key-map
1635         */
1636        Array.from(selectorState._map.values()).forEach(
1637          (resolution) => {
1638            const currentStatus = resolution[1]?.status ?? "error";
1639            if (!selectorsByStatus[currentStatus]) {
1640              selectorsByStatus[currentStatus] = 0;
1641            }
1642            selectorsByStatus[currentStatus]++;
1643          }
1644        )
1645      )
1646    );
1647    return selectorsByStatus;
1648  },
1649  (state) => [state]
1650);
1651
1652
1653;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js
1654function startResolution(selectorName, args) {
1655  return {
1656    type: "START_RESOLUTION",
1657    selectorName,
1658    args
1659  };
1660}
1661function finishResolution(selectorName, args) {
1662  return {
1663    type: "FINISH_RESOLUTION",
1664    selectorName,
1665    args
1666  };
1667}
1668function failResolution(selectorName, args, error) {
1669  return {
1670    type: "FAIL_RESOLUTION",
1671    selectorName,
1672    args,
1673    error
1674  };
1675}
1676function startResolutions(selectorName, args) {
1677  return {
1678    type: "START_RESOLUTIONS",
1679    selectorName,
1680    args
1681  };
1682}
1683function finishResolutions(selectorName, args) {
1684  return {
1685    type: "FINISH_RESOLUTIONS",
1686    selectorName,
1687    args
1688  };
1689}
1690function failResolutions(selectorName, args, errors) {
1691  return {
1692    type: "FAIL_RESOLUTIONS",
1693    selectorName,
1694    args,
1695    errors
1696  };
1697}

1698function invalidateResolution(selectorName, args) {
1699  return {
1700    type: "INVALIDATE_RESOLUTION",
1701    selectorName,
1702    args
1703  };
1704}
1705function invalidateResolutionForStore() {
1706  return {
1707    type: "INVALIDATE_RESOLUTION_FOR_STORE"
1708  };
1709}
1710function invalidateResolutionForStoreSelector(selectorName) {
1711  return {
1712    type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR",
1713    selectorName
1714  };
1715}
1716
1717
1718;// ./node_modules/@wordpress/data/build-module/redux-store/index.js
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732const trimUndefinedValues = (array) => {
1733  const result = [...array];
1734  for (let i = result.length - 1; i >= 0; i--) {
1735    if (result[i] === void 0) {
1736      result.splice(i, 1);
1737    }
1738  }
1739  return result;
1740};
1741const mapValues = (obj, callback) => Object.fromEntries(
1742  Object.entries(obj ?? {}).map(([key, value]) => [
1743    key,
1744    callback(value, key)
1745  ])
1746);
1747const devToolsReplacer = (key, state) => {
1748  if (state instanceof Map) {
1749    return Object.fromEntries(state);
1750  }
1751  if (state instanceof window.HTMLElement) {
1752    return null;
1753  }
1754  return state;
1755};
1756function createResolversCache() {
1757  const cache = {};
1758  return {
1759    isRunning(selectorName, args) {
1760      return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args));
1761    },
1762    clear(selectorName, args) {
1763      if (cache[selectorName]) {
1764        cache[selectorName].delete(trimUndefinedValues(args));
1765      }
1766    },
1767    markAsRunning(selectorName, args) {
1768      if (!cache[selectorName]) {
1769        cache[selectorName] = new (equivalent_key_map_default())();
1770      }
1771      cache[selectorName].set(trimUndefinedValues(args), true);
1772    }
1773  };
1774}
1775function createBindingCache(getItem, bindItem) {
1776  const cache = /* @__PURE__ */ new WeakMap();
1777  return {
1778    get(itemName) {
1779      const item = getItem(itemName);
1780      if (!item) {
1781        return null;
1782      }
1783      let boundItem = cache.get(item);
1784      if (!boundItem) {
1785        boundItem = bindItem(item, itemName);
1786        cache.set(item, boundItem);
1787      }
1788      return boundItem;
1789    }
1790  };
1791}
1792function createPrivateProxy(publicItems, privateItems) {
1793  return new Proxy(publicItems, {
1794    get: (target, itemName) => privateItems.get(itemName) || Reflect.get(target, itemName)
1795  });
1796}
1797function createReduxStore(key, options) {
1798  const privateActions = {};
1799  const privateSelectors = {};
1800  const privateRegistrationFunctions = {
1801    privateActions,
1802    registerPrivateActions: (actions) => {
1803      Object.assign(privateActions, actions);
1804    },
1805    privateSelectors,
1806    registerPrivateSelectors: (selectors) => {
1807      Object.assign(privateSelectors, selectors);
1808    }
1809  };
1810  const storeDescriptor = {
1811    name: key,
1812    instantiate: (registry) => {
1813      const listeners = /* @__PURE__ */ new Set();
1814      const reducer = options.reducer;
1815      const thunkArgs = {
1816        registry,
1817        get dispatch() {
1818          return thunkDispatch;
1819        },
1820        get select() {
1821          return thunkSelect;
1822        },
1823        get resolveSelect() {
1824          return resolveSelectors;
1825        }
1826      };
1827      const store = instantiateReduxStore(
1828        key,
1829        options,
1830        registry,
1831        thunkArgs
1832      );
1833      lock(store, privateRegistrationFunctions);
1834      const resolversCache = createResolversCache();
1835      function bindAction(action) {
1836        return (...args) => Promise.resolve(store.dispatch(action(...args)));
1837      }
1838      const actions = {
1839        ...mapValues(actions_namespaceObject, bindAction),
1840        ...mapValues(options.actions, bindAction)
1841      };
1842      const allActions = createPrivateProxy(
1843        actions,
1844        createBindingCache(
1845          (name) => privateActions[name],
1846          bindAction
1847        )
1848      );
1849      const thunkDispatch = new Proxy(
1850        (action) => store.dispatch(action),
1851        { get: (target, name) => allActions[name] }
1852      );
1853      lock(actions, allActions);
1854      const resolvers = options.resolvers ? mapValues(options.resolvers, mapResolver) : {};
1855      function bindSelector(selector, selectorName) {
1856        if (selector.isRegistrySelector) {
1857          selector.registry = registry;
1858        }
1859        const boundSelector = (...args) => {
1860          args = normalize(selector, args);
1861          const state = store.__unstableOriginalGetState();
1862          if (selector.isRegistrySelector) {
1863            selector.registry = registry;
1864          }
1865          return selector(state.root, ...args);
1866        };
1867        boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
1868        const resolver = resolvers[selectorName];
1869        if (!resolver) {
1870          boundSelector.hasResolver = false;

1871          return boundSelector;
1872        }
1873        return mapSelectorWithResolver(
1874          boundSelector,
1875          selectorName,
1876          resolver,
1877          store,
1878          resolversCache,
1879          boundMetadataSelectors
1880        );
1881      }
1882      function bindMetadataSelector(metaDataSelector) {
1883        const boundSelector = (selectorName, selectorArgs, ...args) => {
1884          if (selectorName) {
1885            const targetSelector = options.selectors?.[selectorName];
1886            if (targetSelector) {
1887              selectorArgs = normalize(
1888                targetSelector,
1889                selectorArgs
1890              );
1891            }
1892          }
1893          const state = store.__unstableOriginalGetState();
1894          return metaDataSelector(
1895            state.metadata,
1896            selectorName,
1897            selectorArgs,
1898            ...args
1899          );
1900        };
1901        boundSelector.hasResolver = false;
1902        return boundSelector;
1903      }
1904      const boundMetadataSelectors = mapValues(
1905        selectors_namespaceObject,
1906        bindMetadataSelector
1907      );
1908      const boundSelectors = mapValues(options.selectors, bindSelector);
1909      const selectors = {
1910        ...boundMetadataSelectors,
1911        ...boundSelectors
1912      };
1913      const boundPrivateSelectors = createBindingCache(
1914        (name) => privateSelectors[name],
1915        bindSelector
1916      );
1917      const allSelectors = createPrivateProxy(
1918        selectors,
1919        boundPrivateSelectors
1920      );
1921      for (const selectorName of Object.keys(privateSelectors)) {
1922        boundPrivateSelectors.get(selectorName);
1923      }
1924      const thunkSelect = new Proxy(
1925        (selector) => selector(store.__unstableOriginalGetState()),
1926        { get: (target, name) => allSelectors[name] }
1927      );
1928      lock(selectors, allSelectors);
1929      const bindResolveSelector = mapResolveSelector(
1930        store,
1931        boundMetadataSelectors
1932      );
1933      const resolveSelectors = mapValues(
1934        boundSelectors,
1935        bindResolveSelector
1936      );
1937      const allResolveSelectors = createPrivateProxy(
1938        resolveSelectors,
1939        createBindingCache(
1940          (name) => boundPrivateSelectors.get(name),
1941          bindResolveSelector
1942        )
1943      );
1944      lock(resolveSelectors, allResolveSelectors);
1945      const bindSuspendSelector = mapSuspendSelector(
1946        store,
1947        boundMetadataSelectors
1948      );
1949      const suspendSelectors = {
1950        ...boundMetadataSelectors,
1951        // no special suspense behavior
1952        ...mapValues(boundSelectors, bindSuspendSelector)
1953      };
1954      const allSuspendSelectors = createPrivateProxy(
1955        suspendSelectors,
1956        createBindingCache(
1957          (name) => boundPrivateSelectors.get(name),
1958          bindSuspendSelector
1959        )
1960      );
1961      lock(suspendSelectors, allSuspendSelectors);
1962      const getSelectors = () => selectors;
1963      const getActions = () => actions;
1964      const getResolveSelectors = () => resolveSelectors;
1965      const getSuspendSelectors = () => suspendSelectors;
1966      store.__unstableOriginalGetState = store.getState;
1967      store.getState = () => store.__unstableOriginalGetState().root;
1968      const subscribe = store && ((listener) => {
1969        listeners.add(listener);
1970        return () => listeners.delete(listener);
1971      });
1972      let lastState = store.__unstableOriginalGetState();
1973      store.subscribe(() => {
1974        const state = store.__unstableOriginalGetState();
1975        const hasChanged = state !== lastState;
1976        lastState = state;
1977        if (hasChanged) {
1978          for (const listener of listeners) {
1979            listener();
1980          }
1981        }
1982      });
1983      return {
1984        reducer,
1985        store,
1986        actions,
1987        selectors,
1988        resolvers,
1989        getSelectors,
1990        getResolveSelectors,
1991        getSuspendSelectors,
1992        getActions,
1993        subscribe
1994      };
1995    }
1996  };
1997  lock(storeDescriptor, privateRegistrationFunctions);
1998  return storeDescriptor;
1999}
2000function instantiateReduxStore(key, options, registry, thunkArgs) {
2001  const controls = {
2002    ...options.controls,
2003    ...builtinControls
2004  };
2005  const normalizedControls = mapValues(
2006    controls,

2007    (control) => control.isRegistryControl ? control(registry) : control
2008  );
2009  const middlewares = [
2010    resolvers_cache_middleware_default(registry, key),
2011    promise_middleware_default,
2012    external_wp_reduxRoutine_default()(normalizedControls),
2013    createThunkMiddleware(thunkArgs)
2014  ];
2015  const enhancers = [applyMiddleware(...middlewares)];
2016  if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
2017    enhancers.push(
2018      window.__REDUX_DEVTOOLS_EXTENSION__({
2019        name: key,
2020        instanceId: key,
2021        serialize: {
2022          replacer: devToolsReplacer
2023        }
2024      })
2025    );
2026  }
2027  const { reducer, initialState } = options;
2028  const enhancedReducer = combine_reducers_combineReducers({
2029    metadata: reducer_default,
2030    root: reducer
2031  });
2032  return createStore(
2033    enhancedReducer,
2034    { root: initialState },
2035    (0,external_wp_compose_namespaceObject.compose)(enhancers)
2036  );
2037}
2038function mapResolveSelector(store, boundMetadataSelectors) {
2039  return (selector, selectorName) => {
2040    if (!selector.hasResolver) {
2041      return async (...args) => selector.apply(null, args);
2042    }
2043    return (...args) => new Promise((resolve, reject) => {
2044      const hasFinished = () => {
2045        return boundMetadataSelectors.hasFinishedResolution(
2046          selectorName,
2047          args
2048        );
2049      };
2050      const finalize = (result2) => {
2051        const hasFailed = boundMetadataSelectors.hasResolutionFailed(
2052          selectorName,
2053          args
2054        );
2055        if (hasFailed) {
2056          const error = boundMetadataSelectors.getResolutionError(
2057            selectorName,
2058            args
2059          );
2060          reject(error);
2061        } else {
2062          resolve(result2);
2063        }
2064      };
2065      const getResult = () => selector.apply(null, args);
2066      const result = getResult();
2067      if (hasFinished()) {
2068        return finalize(result);
2069      }
2070      const unsubscribe = store.subscribe(() => {
2071        if (hasFinished()) {
2072          unsubscribe();
2073          finalize(getResult());
2074        }
2075      });
2076    });
2077  };
2078}
2079function mapSuspendSelector(store, boundMetadataSelectors) {
2080  return (selector, selectorName) => {
2081    if (!selector.hasResolver) {
2082      return selector;
2083    }
2084    return (...args) => {
2085      const result = selector.apply(null, args);
2086      if (boundMetadataSelectors.hasFinishedResolution(
2087        selectorName,
2088        args
2089      )) {
2090        if (boundMetadataSelectors.hasResolutionFailed(
2091          selectorName,
2092          args
2093        )) {
2094          throw boundMetadataSelectors.getResolutionError(
2095            selectorName,
2096            args
2097          );
2098        }
2099        return result;
2100      }
2101      throw new Promise((resolve) => {
2102        const unsubscribe = store.subscribe(() => {
2103          if (boundMetadataSelectors.hasFinishedResolution(
2104            selectorName,
2105            args
2106          )) {
2107            resolve();
2108            unsubscribe();
2109          }
2110        });
2111      });
2112    };
2113  };
2114}
2115function mapResolver(resolver) {
2116  if (resolver.fulfill) {
2117    return resolver;
2118  }
2119  return {
2120    ...resolver,
2121    // Copy the enumerable properties of the resolver function.
2122    fulfill: resolver
2123    // Add the fulfill method.
2124  };
2125}
2126function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
2127  function fulfillSelector(args) {
2128    const state = store.getState();
2129    if (resolversCache.isRunning(selectorName, args) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(state, ...args)) {
2130      return;
2131    }
2132    if (boundMetadataSelectors.hasStartedResolution(selectorName, args)) {
2133      return;
2134    }
2135    resolversCache.markAsRunning(selectorName, args);
2136    setTimeout(async () => {
2137      resolversCache.clear(selectorName, args);
2138      store.dispatch(
2139        startResolution(selectorName, args)
2140      );

2141      try {
2142        const action = resolver.fulfill(...args);
2143        if (action) {
2144          await store.dispatch(action);
2145        }
2146        store.dispatch(
2147          finishResolution(selectorName, args)
2148        );
2149      } catch (error) {
2150        store.dispatch(
2151          failResolution(selectorName, args, error)
2152        );
2153      }
2154    }, 0);
2155  }
2156  const selectorResolver = (...args) => {
2157    args = normalize(selector, args);
2158    fulfillSelector(args);
2159    return selector(...args);
2160  };
2161  selectorResolver.hasResolver = true;
2162  return selectorResolver;
2163}
2164function normalize(selector, args) {
2165  if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) {
2166    return selector.__unstableNormalizeArgs(args);
2167  }
2168  return args;
2169}
2170
2171
2172;// ./node_modules/@wordpress/data/build-module/store/index.js
2173const coreDataStore = {
2174  name: "core/data",
2175  instantiate(registry) {
2176    const getCoreDataSelector = (selectorName) => (key, ...args) => {
2177      return registry.select(key)[selectorName](...args);
2178    };
2179    const getCoreDataAction = (actionName) => (key, ...args) => {
2180      return registry.dispatch(key)[actionName](...args);
2181    };
2182    return {
2183      getSelectors() {
2184        return Object.fromEntries(
2185          [
2186            "getIsResolving",
2187            "hasStartedResolution",
2188            "hasFinishedResolution",
2189            "isResolving",
2190            "getCachedResolvers"
2191          ].map((selectorName) => [
2192            selectorName,
2193            getCoreDataSelector(selectorName)
2194          ])
2195        );
2196      },
2197      getActions() {
2198        return Object.fromEntries(
2199          [
2200            "startResolution",
2201            "finishResolution",
2202            "invalidateResolution",
2203            "invalidateResolutionForStore",
2204            "invalidateResolutionForStoreSelector"
2205          ].map((actionName) => [
2206            actionName,
2207            getCoreDataAction(actionName)
2208          ])
2209        );
2210      },
2211      subscribe() {
2212        return () => () => {
2213        };
2214      }
2215    };
2216  }
2217};
2218var store_default = coreDataStore;
2219
2220
2221;// ./node_modules/@wordpress/data/build-module/utils/emitter.js
2222function createEmitter() {
2223  let isPaused = false;
2224  let isPending = false;
2225  const listeners = /* @__PURE__ */ new Set();
2226  const notifyListeners = () => (
2227    // We use Array.from to clone the listeners Set
2228    // This ensures that we don't run a listener
2229    // that was added as a response to another listener.
2230    Array.from(listeners).forEach((listener) => listener())
2231  );
2232  return {
2233    get isPaused() {
2234      return isPaused;
2235    },
2236    subscribe(listener) {
2237      listeners.add(listener);
2238      return () => listeners.delete(listener);
2239    },
2240    pause() {
2241      isPaused = true;
2242    },
2243    resume() {
2244      isPaused = false;
2245      if (isPending) {
2246        isPending = false;
2247        notifyListeners();
2248      }
2249    },
2250    emit() {
2251      if (isPaused) {
2252        isPending = true;
2253        return;
2254      }
2255      notifyListeners();
2256    }
2257  };
2258}
2259
2260
2261;// ./node_modules/@wordpress/data/build-module/registry.js
2262
2263
2264
2265
2266
2267function getStoreName(storeNameOrDescriptor) {
2268  return typeof storeNameOrDescriptor === "string" ? storeNameOrDescriptor : storeNameOrDescriptor.name;
2269}
2270function createRegistry(storeConfigs = {}, parent = null) {
2271  const stores = {};
2272  const emitter = createEmitter();
2273  let listeningStores = null;
2274  function globalListener() {
2275    emitter.emit();
2276  }
2277  const subscribe = (listener, storeNameOrDescriptor) => {
2278    if (!storeNameOrDescriptor) {
2279      return emitter.subscribe(listener);
2280    }
2281    const storeName = getStoreName(storeNameOrDescriptor);
2282    const store = stores[storeName];
2283    if (store) {
2284      return store.subscribe(listener);
2285    }
2286    if (!parent) {
2287      return emitter.subscribe(listener);
2288    }
2289    return parent.subscribe(listener, storeNameOrDescriptor);
2290  };
2291  function select(storeNameOrDescriptor) {
2292    const storeName = getStoreName(storeNameOrDescriptor);
2293    listeningStores?.add(storeName);
2294    const store = stores[storeName];
2295    if (store) {
2296      return store.getSelectors();
2297    }
2298    return parent?.select(storeName);
2299  }
2300  function __unstableMarkListeningStores(callback, ref) {
2301    listeningStores = /* @__PURE__ */ new Set();
2302    try {
2303      return callback.call(this);
2304    } finally {
2305      ref.current = Array.from(listeningStores);
2306      listeningStores = null;
2307    }
2308  }
2309  function resolveSelect(storeNameOrDescriptor) {
2310    const storeName = getStoreName(storeNameOrDescriptor);
2311    listeningStores?.add(storeName);
2312    const store = stores[storeName];
2313    if (store) {
2314      return store.getResolveSelectors();
2315    }
2316    return parent && parent.resolveSelect(storeName);
2317  }
2318  function suspendSelect(storeNameOrDescriptor) {
2319    const storeName = getStoreName(storeNameOrDescriptor);
2320    listeningStores?.add(storeName);
2321    const store = stores[storeName];
2322    if (store) {
2323      return store.getSuspendSelectors();
2324    }
2325    return parent && parent.suspendSelect(storeName);
2326  }
2327  function dispatch(storeNameOrDescriptor) {
2328    const storeName = getStoreName(storeNameOrDescriptor);
2329    const store = stores[storeName];
2330    if (store) {
2331      return store.getActions();
2332    }
2333    return parent && parent.dispatch(storeName);
2334  }
2335  function withPlugins(attributes) {
2336    return Object.fromEntries(
2337      Object.entries(attributes).map(([key, attribute]) => {
2338        if (typeof attribute !== "function") {
2339          return [key, attribute];
2340        }
2341        return [
2342          key,
2343          function() {
2344            return registry[key].apply(null, arguments);
2345          }
2346        ];
2347      })
2348    );
2349  }
2350  function registerStoreInstance(name, createStore) {
2351    if (stores[name]) {
2352      console.error('Store "' + name + '" is already registered.');
2353      return stores[name];
2354    }

2355    const store = createStore();
2356    if (typeof store.getSelectors !== "function") {
2357      throw new TypeError("store.getSelectors must be a function");
2358    }
2359    if (typeof store.getActions !== "function") {
2360      throw new TypeError("store.getActions must be a function");
2361    }
2362    if (typeof store.subscribe !== "function") {
2363      throw new TypeError("store.subscribe must be a function");
2364    }
2365    store.emitter = createEmitter();
2366    const currentSubscribe = store.subscribe;
2367    store.subscribe = (listener) => {
2368      const unsubscribeFromEmitter = store.emitter.subscribe(listener);
2369      const unsubscribeFromStore = currentSubscribe(() => {
2370        if (store.emitter.isPaused) {
2371          store.emitter.emit();
2372          return;
2373        }
2374        listener();
2375      });
2376      return () => {
2377        unsubscribeFromStore?.();
2378        unsubscribeFromEmitter?.();
2379      };
2380    };
2381    stores[name] = store;
2382    store.subscribe(globalListener);
2383    if (parent) {
2384      try {
2385        unlock(store.store).registerPrivateActions(
2386          unlock(parent).privateActionsOf(name)
2387        );
2388        unlock(store.store).registerPrivateSelectors(
2389          unlock(parent).privateSelectorsOf(name)
2390        );
2391      } catch (e) {
2392      }
2393    }
2394    return store;
2395  }
2396  function register(store) {
2397    registerStoreInstance(
2398      store.name,
2399      () => store.instantiate(registry)
2400    );
2401  }
2402  function registerGenericStore(name, store) {
2403    external_wp_deprecated_default()("wp.data.registerGenericStore", {
2404      since: "5.9",
2405      alternative: "wp.data.register( storeDescriptor )"
2406    });
2407    registerStoreInstance(name, () => store);
2408  }
2409  function registerStore(storeName, options) {
2410    if (!options.reducer) {
2411      throw new TypeError("Must specify store reducer");
2412    }
2413    const store = registerStoreInstance(
2414      storeName,
2415      () => createReduxStore(storeName, options).instantiate(registry)
2416    );
2417    return store.store;
2418  }
2419  function batch(callback) {
2420    if (emitter.isPaused) {
2421      callback();
2422      return;
2423    }
2424    emitter.pause();

2425    Object.values(stores).forEach((store) => store.emitter.pause());
2426    try {
2427      callback();
2428    } finally {
2429      emitter.resume();
2430      Object.values(stores).forEach(
2431        (store) => store.emitter.resume()
2432      );
2433    }
2434  }
2435  let registry = {
2436    batch,
2437    stores,
2438    namespaces: stores,
2439    // TODO: Deprecate/remove this.
2440    subscribe,
2441    select,
2442    resolveSelect,
2443    suspendSelect,
2444    dispatch,
2445    use,
2446    register,
2447    registerGenericStore,
2448    registerStore,
2449    __unstableMarkListeningStores
2450  };
2451  function use(plugin, options) {
2452    if (!plugin) {
2453      return;
2454    }
2455    registry = {
2456      ...registry,
2457      ...plugin(registry, options)
2458    };
2459    return registry;
2460  }
2461  registry.register(store_default);
2462  for (const [name, config] of Object.entries(storeConfigs)) {
2463    registry.register(createReduxStore(name, config));
2464  }
2465  if (parent) {
2466    parent.subscribe(globalListener);
2467  }
2468  const registryWithPlugins = withPlugins(registry);
2469  lock(registryWithPlugins, {
2470    privateActionsOf: (name) => {
2471      try {
2472        return unlock(stores[name].store).privateActions;
2473      } catch (e) {
2474        return {};
2475      }
2476    },
2477    privateSelectorsOf: (name) => {
2478      try {
2479        return unlock(stores[name].store).privateSelectors;
2480      } catch (e) {
2481        return {};
2482      }
2483    }
2484  });
2485  return registryWithPlugins;
2486}
2487
2488
2489;// ./node_modules/@wordpress/data/build-module/default-registry.js
2490
2491var default_registry_default = createRegistry();
2492
2493
2494;// ./node_modules/is-plain-object/dist/is-plain-object.mjs
2495/*!
2496 * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
2497 *
2498 * Copyright (c) 2014-2017, Jon Schlinkert.
2499 * Released under the MIT License.
2500 */
2501
2502function is_plain_object_isObject(o) {
2503  return Object.prototype.toString.call(o) === '[object Object]';
2504}
2505
2506function is_plain_object_isPlainObject(o) {
2507  var ctor,prot;
2508
2509  if (is_plain_object_isObject(o) === false) return false;
2510
2511  // If has modified constructor
2512  ctor = o.constructor;
2513  if (ctor === undefined) return true;
2514
2515  // If has modified prototype
2516  prot = ctor.prototype;
2517  if (is_plain_object_isObject(prot) === false) return false;
2518
2519  // If constructor does not have an Object-specific method
2520  if (prot.hasOwnProperty('isPrototypeOf') === false) {
2521    return false;
2522  }
2523
2524  // Most likely a plain Object
2525  return true;
2526}
2527
2528
2529
2530// EXTERNAL MODULE: ./node_modules/deepmerge/dist/cjs.js
2531var cjs = __webpack_require__(66);
2532var cjs_default = /*#__PURE__*/__webpack_require__.n(cjs);
2533;// ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/object.js
2534let objectStorage;
2535const storage = {
2536  getItem(key) {
2537    if (!objectStorage || !objectStorage[key]) {
2538      return null;
2539    }
2540    return objectStorage[key];
2541  },
2542  setItem(key, value) {
2543    if (!objectStorage) {
2544      storage.clear();
2545    }
2546    objectStorage[key] = String(value);
2547  },
2548  clear() {
2549    objectStorage = /* @__PURE__ */ Object.create(null);
2550  }
2551};
2552var object_default = storage;
2553
2554
2555;// ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/default.js
2556
2557let default_storage;
2558try {
2559  default_storage = window.localStorage;
2560  default_storage.setItem("__wpDataTestLocalStorage", "");
2561  default_storage.removeItem("__wpDataTestLocalStorage");
2562} catch (error) {
2563  default_storage = object_default;
2564}
2565var default_default = default_storage;
2566
2567
2568;// ./node_modules/@wordpress/data/build-module/plugins/persistence/index.js
2569
2570
2571
2572
2573const DEFAULT_STORAGE = default_default;
2574const DEFAULT_STORAGE_KEY = "WP_DATA";
2575const withLazySameState = (reducer) => (state, action) => {
2576  if (action.nextState === state) {
2577    return state;
2578  }
2579  return reducer(state, action);
2580};
2581function createPersistenceInterface(options) {
2582  const { storage = DEFAULT_STORAGE, storageKey = DEFAULT_STORAGE_KEY } = options;
2583  let data;
2584  function getData() {
2585    if (data === void 0) {
2586      const persisted = storage.getItem(storageKey);
2587      if (persisted === null) {
2588        data = {};
2589      } else {
2590        try {
2591          data = JSON.parse(persisted);
2592        } catch (error) {
2593          data = {};
2594        }
2595      }
2596    }
2597    return data;
2598  }
2599  function setData(key, value) {
2600    data = { ...data, [key]: value };
2601    storage.setItem(storageKey, JSON.stringify(data));
2602  }
2603  return {
2604    get: getData,
2605    set: setData
2606  };
2607}
2608function persistencePlugin(registry, pluginOptions) {
2609  const persistence = createPersistenceInterface(pluginOptions);
2610  function createPersistOnChange(getState, storeName, keys) {
2611    let getPersistedState;
2612    if (Array.isArray(keys)) {
2613      const reducers = keys.reduce(
2614        (accumulator, key) => Object.assign(accumulator, {
2615          [key]: (state, action) => action.nextState[key]
2616        }),
2617        {}
2618      );
2619      getPersistedState = withLazySameState(
2620        build_module_combineReducers(reducers)
2621      );
2622    } else {
2623      getPersistedState = (state, action) => action.nextState;
2624    }
2625    let lastState = getPersistedState(void 0, {
2626      nextState: getState()
2627    });
2628    return () => {
2629      const state = getPersistedState(lastState, {
2630        nextState: getState()
2631      });
2632      if (state !== lastState) {
2633        persistence.set(storeName, state);
2634        lastState = state;
2635      }
2636    };
2637  }
2638  return {
2639    registerStore(storeName, options) {
2640      if (!options.persist) {
2641        return registry.registerStore(storeName, options);
2642      }
2643      const persistedState = persistence.get()[storeName];
2644      if (persistedState !== void 0) {
2645        let initialState = options.reducer(options.initialState, {
2646          type: "@@WP/PERSISTENCE_RESTORE"
2647        });
2648        if (is_plain_object_isPlainObject(initialState) && is_plain_object_isPlainObject(persistedState)) {
2649          initialState = cjs_default()(initialState, persistedState, {
2650            isMergeableObject: is_plain_object_isPlainObject
2651          });
2652        } else {
2653          initialState = persistedState;
2654        }
2655        options = {
2656          ...options,
2657          initialState
2658        };
2659      }
2660      const store = registry.registerStore(storeName, options);
2661      store.subscribe(
2662        createPersistOnChange(
2663          store.getState,
2664          storeName,
2665          options.persist
2666        )
2667      );
2668      return store;
2669    }
2670  };
2671}
2672persistencePlugin.__unstableMigrate = () => {
2673};
2674var persistence_default = persistencePlugin;
2675
2676
2677;// ./node_modules/@wordpress/data/build-module/plugins/index.js
2678
2679
2680
2681;// external "ReactJSXRuntime"
2682const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
2683;