https://givewp.bayarcash-demo.com/wp-includes/js/dist/data.js?ver=2797f012cdb7d180a746

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 */ async_mode_provider_context),
534  RegistryConsumer: () => (/* reexport */ RegistryConsumer),
535  RegistryProvider: () => (/* reexport */ context),
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),
554  useRegistry: () => (/* reexport */ useRegistry),
555  useSelect: () => (/* reexport */ useSelect),
556  useSuspenseSelect: () => (/* reexport */ useSuspenseSelect),
557  withDispatch: () => (/* reexport */ with_dispatch),
558  withRegistry: () => (/* reexport */ with_registry),
559  withSelect: () => (/* reexport */ with_select)
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)
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;// ./node_modules/@wordpress/data/build-module/factory.js
1004/**
1005 * Internal dependencies
1006 */
1007
1008/**
1009 * Creates a selector function that takes additional curried argument with the
1010 * registry `select` function. While a regular selector has signature
1011 * ```js
1012 * ( state, ...selectorArgs ) => ( result )
1013 * ```
1014 * that allows to select data from the store's `state`, a registry selector
1015 * has signature:
1016 * ```js
1017 * ( select ) => ( state, ...selectorArgs ) => ( result )
1018 * ```
1019 * that supports also selecting from other registered stores.
1020 *
1021 * @example
1022 * ```js
1023 * import { store as coreStore } from '@wordpress/core-data';
1024 * import { store as editorStore } from '@wordpress/editor';
1025 *
1026 * const getCurrentPostId = createRegistrySelector( ( select ) => ( state ) => {
1027 *   return select( editorStore ).getCurrentPostId();
1028 * } );
1029 *
1030 * const getPostEdits = createRegistrySelector( ( select ) => ( state ) => {
1031 *   // calling another registry selector just like any other function
1032 *   const postType = getCurrentPostType( state );
1033 *   const postId = getCurrentPostId( state );
1034 *	 return select( coreStore ).getEntityRecordEdits( 'postType', postType, postId );
1035 * } );
1036 * ```
1037 *
1038 * Note how the `getCurrentPostId` selector can be called just like any other function,
1039 * (it works even inside a regular non-registry selector) and we don't need to pass the
1040 * registry as argument. The registry binding happens automatically when registering the selector
1041 * with a store.
1042 *
1043 * @param registrySelector Function receiving a registry `select`
1044 *                         function and returning a state selector.
1045 *
1046 * @return Registry selector that can be registered with a store.
1047 */
1048function createRegistrySelector(registrySelector) {
1049  const selectorsByRegistry = new WeakMap();
1050  // Create a selector function that is bound to the registry referenced by `selector.registry`
1051  // and that has the same API as a regular selector. Binding it in such a way makes it
1052  // possible to call the selector directly from another selector.
1053  const wrappedSelector = (...args) => {
1054    let selector = selectorsByRegistry.get(wrappedSelector.registry);
1055    // We want to make sure the cache persists even when new registry
1056    // instances are created. For example patterns create their own editors
1057    // with their own core/block-editor stores, so we should keep track of
1058    // the cache for each registry instance.
1059    if (!selector) {
1060      selector = registrySelector(wrappedSelector.registry.select);
1061      selectorsByRegistry.set(wrappedSelector.registry, selector);
1062    }
1063    return selector(...args);
1064  };
1065
1066  /**
1067   * Flag indicating that the selector is a registry selector that needs the correct registry
1068   * reference to be assigned to `selector.registry` to make it work correctly.
1069   * be mapped as a registry selector.
1070   */
1071  wrappedSelector.isRegistrySelector = true;
1072  return wrappedSelector;
1073}
1074

1075/**
1076 * Creates a control function that takes additional curried argument with the `registry` object.
1077 * While a regular control has signature
1078 * ```js
1079 * ( action ) => ( iteratorOrPromise )
1080 * ```
1081 * where the control works with the `action` that it's bound to, a registry control has signature:
1082 * ```js
1083 * ( registry ) => ( action ) => ( iteratorOrPromise )
1084 * ```
1085 * A registry control is typically used to select data or dispatch an action to a registered
1086 * store.
1087 *
1088 * When registering a control created with `createRegistryControl` with a store, the store
1089 * knows which calling convention to use when executing the control.
1090 *
1091 * @param registryControl Function receiving a registry object and returning a control.
1092 *
1093 * @return Registry control that can be registered with a store.
1094 */
1095function createRegistryControl(registryControl) {
1096  registryControl.isRegistryControl = true;
1097  return registryControl;
1098}
1099
1100;// ./node_modules/@wordpress/data/build-module/controls.js
1101/**
1102 * Internal dependencies
1103 */
1104
1105
1106/** @typedef {import('./types').StoreDescriptor} StoreDescriptor */
1107
1108const SELECT = '@@data/SELECT';
1109const RESOLVE_SELECT = '@@data/RESOLVE_SELECT';
1110const DISPATCH = '@@data/DISPATCH';
1111function isObject(object) {
1112  return object !== null && typeof object === 'object';
1113}
1114
1115/**
1116 * Dispatches a control action for triggering a synchronous registry select.
1117 *
1118 * Note: This control synchronously returns the current selector value, triggering the
1119 * resolution, but not waiting for it.
1120 *
1121 * @param {string|StoreDescriptor} storeNameOrDescriptor Unique namespace identifier for the store
1122 * @param {string}                 selectorName          The name of the selector.
1123 * @param {Array}                  args                  Arguments for the selector.
1124 *
1125 * @example
1126 * ```js
1127 * import { controls } from '@wordpress/data';
1128 *
1129 * // Action generator using `select`.
1130 * export function* myAction() {
1131 *   const isEditorSideBarOpened = yield controls.select( 'core/edit-post', 'isEditorSideBarOpened' );
1132 *   // Do stuff with the result from the `select`.
1133 * }
1134 * ```
1135 *
1136 * @return {Object} The control descriptor.
1137 */
1138function controls_select(storeNameOrDescriptor, selectorName, ...args) {
1139  return {
1140    type: SELECT,
1141    storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
1142    selectorName,
1143    args
1144  };
1145}
1146
1147/**
1148 * Dispatches a control action for triggering and resolving a registry select.
1149 *
1150 * Note: when this control action is handled, it automatically considers
1151 * selectors that may have a resolver. In such case, it will return a `Promise` that resolves
1152 * after the selector finishes resolving, with the final result value.
1153 *
1154 * @param {string|StoreDescriptor} storeNameOrDescriptor Unique namespace identifier for the store
1155 * @param {string}                 selectorName          The name of the selector
1156 * @param {Array}                  args                  Arguments for the selector.
1157 *
1158 * @example
1159 * ```js
1160 * import { controls } from '@wordpress/data';
1161 *
1162 * // Action generator using resolveSelect
1163 * export function* myAction() {
1164 * 	const isSidebarOpened = yield controls.resolveSelect( 'core/edit-post', 'isEditorSideBarOpened' );
1165 * 	// do stuff with the result from the select.
1166 * }
1167 * ```
1168 *
1169 * @return {Object} The control descriptor.
1170 */
1171function resolveSelect(storeNameOrDescriptor, selectorName, ...args) {
1172  return {
1173    type: RESOLVE_SELECT,
1174    storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
1175    selectorName,
1176    args
1177  };
1178}
1179
1180/**
1181 * Dispatches a control action for triggering a registry dispatch.
1182 *
1183 * @param {string|StoreDescriptor} storeNameOrDescriptor Unique namespace identifier for the store
1184 * @param {string}                 actionName            The name of the action to dispatch
1185 * @param {Array}                  args                  Arguments for the dispatch action.
1186 *
1187 * @example
1188 * ```js
1189 * import { controls } from '@wordpress/data-controls';
1190 *
1191 * // Action generator using dispatch
1192 * export function* myAction() {
1193 *   yield controls.dispatch( 'core/editor', 'togglePublishSidebar' );

1194 *   // do some other things.
1195 * }
1196 * ```
1197 *
1198 * @return {Object}  The control descriptor.
1199 */
1200function dispatch(storeNameOrDescriptor, actionName, ...args) {
1201  return {
1202    type: DISPATCH,
1203    storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
1204    actionName,
1205    args
1206  };
1207}
1208const controls = {
1209  select: controls_select,
1210  resolveSelect,
1211  dispatch
1212};
1213const builtinControls = {
1214  [SELECT]: createRegistryControl(registry => ({
1215    storeKey,
1216    selectorName,
1217    args
1218  }) => registry.select(storeKey)[selectorName](...args)),
1219  [RESOLVE_SELECT]: createRegistryControl(registry => ({
1220    storeKey,
1221    selectorName,
1222    args
1223  }) => {
1224    const method = registry.select(storeKey)[selectorName].hasResolver ? 'resolveSelect' : 'select';
1225    return registry[method](storeKey)[selectorName](...args);
1226  }),
1227  [DISPATCH]: createRegistryControl(registry => ({
1228    storeKey,
1229    actionName,
1230    args
1231  }) => registry.dispatch(storeKey)[actionName](...args))
1232};
1233
1234;// external ["wp","privateApis"]
1235const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
1236;// ./node_modules/@wordpress/data/build-module/lock-unlock.js
1237/**
1238 * WordPress dependencies
1239 */
1240
1241const {
1242  lock,
1243  unlock
1244} = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)('I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.', '@wordpress/data');
1245
1246;// ./node_modules/is-promise/index.mjs
1247function isPromise(obj) {
1248  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
1249}
1250
1251;// ./node_modules/@wordpress/data/build-module/promise-middleware.js
1252/**
1253 * External dependencies
1254 */
1255
1256
1257/**
1258 * Simplest possible promise redux middleware.
1259 *
1260 * @type {import('redux').Middleware}
1261 */
1262const promiseMiddleware = () => next => action => {
1263  if (isPromise(action)) {
1264    return action.then(resolvedAction => {
1265      if (resolvedAction) {
1266        return next(resolvedAction);
1267      }
1268    });
1269  }
1270  return next(action);
1271};
1272/* harmony default export */ const promise_middleware = (promiseMiddleware);
1273
1274;// ./node_modules/@wordpress/data/build-module/resolvers-cache-middleware.js
1275/** @typedef {import('./registry').WPDataRegistry} WPDataRegistry */
1276
1277/**
1278 * Creates a middleware handling resolvers cache invalidation.
1279 *
1280 * @param {WPDataRegistry} registry  Registry for which to create the middleware.
1281 * @param {string}         storeName Name of the store for which to create the middleware.
1282 *
1283 * @return {Function} Middleware function.
1284 */
1285const createResolversCacheMiddleware = (registry, storeName) => () => next => action => {
1286  const resolvers = registry.select(storeName).getCachedResolvers();
1287  const resolverEntries = Object.entries(resolvers);
1288  resolverEntries.forEach(([selectorName, resolversByArgs]) => {
1289    const resolver = registry.stores[storeName]?.resolvers?.[selectorName];
1290    if (!resolver || !resolver.shouldInvalidate) {
1291      return;
1292    }
1293    resolversByArgs.forEach((value, args) => {
1294      // Works around a bug in `EquivalentKeyMap` where `map.delete` merely sets an entry value
1295      // to `undefined` and `map.forEach` then iterates also over these orphaned entries.
1296      if (value === undefined) {
1297        return;
1298      }
1299
1300      // resolversByArgs is the map Map([ args ] => boolean) storing the cache resolution status for a given selector.
1301      // If the value is "finished" or "error" it means this resolver has finished its resolution which means we need
1302      // to invalidate it, if it's true it means it's inflight and the invalidation is not necessary.
1303      if (value.status !== 'finished' && value.status !== 'error') {
1304        return;
1305      }
1306      if (!resolver.shouldInvalidate(action, ...args)) {
1307        return;
1308      }
1309
1310      // Trigger cache invalidation
1311      registry.dispatch(storeName).invalidateResolution(selectorName, args);
1312    });
1313  });
1314  return next(action);
1315};
1316/* harmony default export */ const resolvers_cache_middleware = (createResolversCacheMiddleware);
1317
1318;// ./node_modules/@wordpress/data/build-module/redux-store/thunk-middleware.js
1319function createThunkMiddleware(args) {
1320  return () => next => action => {
1321    if (typeof action === 'function') {
1322      return action(args);
1323    }
1324    return next(action);
1325  };
1326}
1327
1328;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/utils.js
1329/**
1330 * External dependencies
1331 */
1332

1333/**
1334 * Higher-order reducer creator which creates a combined reducer object, keyed
1335 * by a property on the action object.
1336 *
1337 * @param actionProperty Action property by which to key object.
1338 * @return Higher-order reducer.
1339 */
1340const onSubKey = actionProperty => reducer => (state = {}, action) => {
1341  // Retrieve subkey from action. Do not track if undefined; useful for cases
1342  // where reducer is scoped by action shape.
1343  const key = action[actionProperty];
1344  if (key === undefined) {
1345    return state;
1346  }
1347
1348  // Avoid updating state if unchanged. Note that this also accounts for a
1349  // reducer which returns undefined on a key which is not yet tracked.
1350  const nextKeyState = reducer(state[key], action);
1351  if (nextKeyState === state[key]) {
1352    return state;
1353  }
1354  return {
1355    ...state,
1356    [key]: nextKeyState
1357  };
1358};
1359
1360/**
1361 * Normalize selector argument array by defaulting `undefined` value to an empty array
1362 * and removing trailing `undefined` values.
1363 *
1364 * @param args Selector argument array
1365 * @return Normalized state key array
1366 */
1367function selectorArgsToStateKey(args) {
1368  if (args === undefined || args === null) {
1369    return [];
1370  }
1371  const len = args.length;
1372  let idx = len;
1373  while (idx > 0 && args[idx - 1] === undefined) {
1374    idx--;
1375  }
1376  return idx === len ? args : args.slice(0, idx);
1377}
1378
1379;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/reducer.js
1380/**
1381 * External dependencies
1382 */
1383
1384/**
1385 * Internal dependencies
1386 */
1387
1388/**
1389 * Reducer function returning next state for selector resolution of
1390 * subkeys, object form:
1391 *
1392 *  selectorName -> EquivalentKeyMap<Array,boolean>
1393 */
1394const subKeysIsResolved = onSubKey('selectorName')((state = new (equivalent_key_map_default())(), action) => {
1395  switch (action.type) {
1396    case 'START_RESOLUTION':
1397      {
1398        const nextState = new (equivalent_key_map_default())(state);
1399        nextState.set(selectorArgsToStateKey(action.args), {
1400          status: 'resolving'
1401        });
1402        return nextState;
1403      }
1404    case 'FINISH_RESOLUTION':
1405      {
1406        const nextState = new (equivalent_key_map_default())(state);
1407        nextState.set(selectorArgsToStateKey(action.args), {
1408          status: 'finished'
1409        });
1410        return nextState;
1411      }
1412    case 'FAIL_RESOLUTION':
1413      {
1414        const nextState = new (equivalent_key_map_default())(state);
1415        nextState.set(selectorArgsToStateKey(action.args), {
1416          status: 'error',
1417          error: action.error
1418        });
1419        return nextState;
1420      }
1421    case 'START_RESOLUTIONS':
1422      {
1423        const nextState = new (equivalent_key_map_default())(state);

1424        for (const resolutionArgs of action.args) {
1425          nextState.set(selectorArgsToStateKey(resolutionArgs), {
1426            status: 'resolving'
1427          });
1428        }
1429        return nextState;
1430      }
1431    case 'FINISH_RESOLUTIONS':
1432      {
1433        const nextState = new (equivalent_key_map_default())(state);
1434        for (const resolutionArgs of action.args) {
1435          nextState.set(selectorArgsToStateKey(resolutionArgs), {
1436            status: 'finished'
1437          });
1438        }
1439        return nextState;
1440      }
1441    case 'FAIL_RESOLUTIONS':
1442      {
1443        const nextState = new (equivalent_key_map_default())(state);
1444        action.args.forEach((resolutionArgs, idx) => {
1445          const resolutionState = {
1446            status: 'error',
1447            error: undefined
1448          };
1449          const error = action.errors[idx];
1450          if (error) {
1451            resolutionState.error = error;
1452          }
1453          nextState.set(selectorArgsToStateKey(resolutionArgs), resolutionState);
1454        });
1455        return nextState;
1456      }
1457    case 'INVALIDATE_RESOLUTION':
1458      {
1459        const nextState = new (equivalent_key_map_default())(state);
1460        nextState.delete(selectorArgsToStateKey(action.args));
1461        return nextState;
1462      }
1463  }
1464  return state;
1465});
1466
1467/**
1468 * Reducer function returning next state for selector resolution, object form:
1469 *
1470 *   selectorName -> EquivalentKeyMap<Array, boolean>
1471 *
1472 * @param state  Current state.
1473 * @param action Dispatched action.
1474 *
1475 * @return Next state.
1476 */
1477const isResolved = (state = {}, action) => {
1478  switch (action.type) {
1479    case 'INVALIDATE_RESOLUTION_FOR_STORE':
1480      return {};
1481    case 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR':
1482      {
1483        if (action.selectorName in state) {
1484          const {
1485            [action.selectorName]: removedSelector,
1486            ...restState
1487          } = state;
1488          return restState;
1489        }
1490        return state;
1491      }
1492    case 'START_RESOLUTION':
1493    case 'FINISH_RESOLUTION':
1494    case 'FAIL_RESOLUTION':
1495    case 'START_RESOLUTIONS':
1496    case 'FINISH_RESOLUTIONS':
1497    case 'FAIL_RESOLUTIONS':
1498    case 'INVALIDATE_RESOLUTION':
1499      return subKeysIsResolved(state, action);
1500  }
1501  return state;
1502};
1503/* harmony default export */ const metadata_reducer = (isResolved);
1504
1505;// ./node_modules/rememo/rememo.js
1506
1507
1508/** @typedef {(...args: any[]) => *[]} GetDependants */
1509
1510/** @typedef {() => void} Clear */
1511
1512/**
1513 * @typedef {{
1514 *   getDependants: GetDependants,
1515 *   clear: Clear
1516 * }} EnhancedSelector
1517 */
1518
1519/**
1520 * Internal cache entry.
1521 *
1522 * @typedef CacheNode
1523 *
1524 * @property {?CacheNode|undefined} [prev] Previous node.
1525 * @property {?CacheNode|undefined} [next] Next node.
1526 * @property {*[]} args Function arguments for cache entry.
1527 * @property {*} val Function result.
1528 */
1529
1530/**
1531 * @typedef Cache
1532 *
1533 * @property {Clear} clear Function to clear cache.
1534 * @property {boolean} [isUniqueByDependants] Whether dependants are valid in
1535 * considering cache uniqueness. A cache is unique if dependents are all arrays
1536 * or objects.
1537 * @property {CacheNode?} [head] Cache head.
1538 * @property {*[]} [lastDependants] Dependants from previous invocation.
1539 */
1540
1541/**
1542 * Arbitrary value used as key for referencing cache object in WeakMap tree.
1543 *
1544 * @type {{}}
1545 */
1546var LEAF_KEY = {};
1547
1548/**
1549 * Returns the first argument as the sole entry in an array.
1550 *
1551 * @template T
1552 *
1553 * @param {T} value Value to return.
1554 *
1555 * @return {[T]} Value returned as entry in array.
1556 */
1557function arrayOf(value) {
1558	return [value];
1559}
1560
1561/**
1562 * Returns true if the value passed is object-like, or false otherwise. A value
1563 * is object-like if it can support property assignment, e.g. object or array.
1564 *
1565 * @param {*} value Value to test.
1566 *
1567 * @return {boolean} Whether value is object-like.
1568 */
1569function isObjectLike(value) {
1570	return !!value && 'object' === typeof value;
1571}
1572
1573/**
1574 * Creates and returns a new cache object.
1575 *
1576 * @return {Cache} Cache object.
1577 */
1578function createCache() {
1579	/** @type {Cache} */
1580	var cache = {
1581		clear: function () {
1582			cache.head = null;
1583		},
1584	};
1585
1586	return cache;
1587}
1588
1589/**
1590 * Returns true if entries within the two arrays are strictly equal by
1591 * reference from a starting index.
1592 *
1593 * @param {*[]} a First array.
1594 * @param {*[]} b Second array.
1595 * @param {number} fromIndex Index from which to start comparison.
1596 *
1597 * @return {boolean} Whether arrays are shallowly equal.
1598 */
1599function isShallowEqual(a, b, fromIndex) {
1600	var i;
1601
1602	if (a.length !== b.length) {
1603		return false;

1604	}
1605
1606	for (i = fromIndex; i < a.length; i++) {
1607		if (a[i] !== b[i]) {
1608			return false;
1609		}
1610	}
1611
1612	return true;
1613}
1614
1615/**
1616 * Returns a memoized selector function. The getDependants function argument is
1617 * called before the memoized selector and is expected to return an immutable
1618 * reference or array of references on which the selector depends for computing
1619 * its own return value. The memoize cache is preserved only as long as those
1620 * dependant references remain the same. If getDependants returns a different
1621 * reference(s), the cache is cleared and the selector value regenerated.
1622 *
1623 * @template {(...args: *[]) => *} S
1624 *
1625 * @param {S} selector Selector function.
1626 * @param {GetDependants=} getDependants Dependant getter returning an array of
1627 * references used in cache bust consideration.
1628 */
1629/* harmony default export */ function rememo(selector, getDependants) {
1630	/** @type {WeakMap<*,*>} */
1631	var rootCache;
1632
1633	/** @type {GetDependants} */
1634	var normalizedGetDependants = getDependants ? getDependants : arrayOf;
1635
1636	/**
1637	 * Returns the cache for a given dependants array. When possible, a WeakMap
1638	 * will be used to create a unique cache for each set of dependants. This
1639	 * is feasible due to the nature of WeakMap in allowing garbage collection
1640	 * to occur on entries where the key object is no longer referenced. Since
1641	 * WeakMap requires the key to be an object, this is only possible when the
1642	 * dependant is object-like. The root cache is created as a hierarchy where
1643	 * each top-level key is the first entry in a dependants set, the value a
1644	 * WeakMap where each key is the next dependant, and so on. This continues
1645	 * so long as the dependants are object-like. If no dependants are object-
1646	 * like, then the cache is shared across all invocations.
1647	 *
1648	 * @see isObjectLike
1649	 *
1650	 * @param {*[]}

1650 dependants Selector dependants.
1651	 *
1652	 * @return {Cache} Cache object.
1653	 */
1654	function getCache(dependants) {
1655		var caches = rootCache,
1656			isUniqueByDependants = true,
1657			i,
1658			dependant,
1659			map,
1660			cache;
1661
1662		for (i = 0; i < dependants.length; i++) {
1663			dependant = dependants[i];
1664
1665			// Can only compose WeakMap from object-like key.
1666			if (!isObjectLike(dependant)) {
1667				isUniqueByDependants = false;
1668				break;
1669			}
1670
1671			// Does current segment of cache already have a WeakMap?
1672			if (caches.has(dependant)) {
1673				// Traverse into nested WeakMap.
1674				caches = caches.get(dependant);
1675			} else {
1676				// Create, set, and traverse into a new one.
1677				map = new WeakMap();
1678				caches.set(dependant, map);
1679				caches = map;
1680			}
1681		}
1682
1683		// We use an arbitrary (but consistent) object as key for the last item
1684		// in the WeakMap to serve as our running cache.
1685		if (!caches.has(LEAF_KEY)) {
1686			cache = createCache();
1687			cache.isUniqueByDependants = isUniqueByDependants;
1688			caches.set(LEAF_KEY, cache);
1689		}
1690
1691		return caches.get(LEAF_KEY);
1692	}
1693
1694	/**
1695	 * Resets root memoization cache.
1696	 */
1697	function clear() {
1698		rootCache = new WeakMap();
1699	}
1700
1701	/* eslint-disable jsdoc/check-param-names */
1702	/**
1703	 * The augmented selector call, considering first whether dependants have
1704	 * changed before passing it to underlying memoize function.
1705	 *
1706	 * @param {*}    source    Source object for derivation.
1707	 * @param {...*} extraArgs Additional arguments to pass to selector.
1708	 *
1709	 * @return {*} Selector result.
1710	 */
1711	/* eslint-enable jsdoc/check-param-names */
1712	function callSelector(/* source, ...extraArgs */) {
1713		var len = arguments.length,
1714			cache,
1715			node,
1716			i,
1717			args,
1718			dependants;
1719
1720		// Create copy of arguments (avoid leaking deoptimization).
1721		args = new Array(len);
1722		for (i = 0; i < len; i++) {
1723			args[i] = arguments[i];
1724		}
1725
1726		dependants = normalizedGetDependants.apply(null, args);
1727		cache = getCache(dependants);
1728
1729		// If not guaranteed uniqueness by dependants (primitive type), shallow
1730		// compare against last dependants and, if references have changed,
1731		// destroy cache to recalculate result.
1732		if (!cache.isUniqueByDependants) {
1733			if (
1734				cache.lastDependants &&
1735				!isShallowEqual(dependants, cache.lastDependants, 0)
1736			) {
1737				cache.clear();
1738			}
1739
1740			cache.lastDependants = dependants;
1741		}
1742
1743		node = cache.head;
1744		while (node) {
1745			// Check whether node arguments match arguments
1746			if (!isShallowEqual(node.args, args, 1)) {
1747				node = node.next;
1748				continue;
1749			}
1750
1751			// At this point we can assume we've found a match
1752
1753			// Surface matched node to head if not already
1754			if (node !== cache.head) {
1755				// Adjust siblings to point to each other.
1756				/** @type {CacheNode} */ (node.prev).next = node.next;
1757				if (node.next) {
1758					node.next.prev = node.prev;
1759				}
1760
1761				node.next = cache.head;
1762				node.prev = null;
1763				/** @type {CacheNode} */ (cache.head).prev = node;
1764				cache.head = node;
1765			}
1766
1767			// Return immediately
1768			return node.val;
1769		}
1770
1771		// No cached value found. Continue to insertion phase:
1772
1773		node = /** @type {CacheNode} */ ({
1774			// Generate the result from original function
1775			val: selector.apply(null, args),
1776		});
1777
1778		// Avoid including the source object in the cache.
1779		args[0] = null;
1780		node.args = args;
1781
1782		// Don't need to check whether node is already head, since it would
1783		// have been returned above already if it was
1784
1785		// Shift existing head down list
1786		if (cache.head) {
1787			cache.head.prev = node;
1788			node.next = cache.head;
1789		}
1790
1791		cache.head = node;
1792
1793		return node.val;
1794	}
1795
1796	callSelector.getDependants = normalizedGetDependants;
1797	callSelector.clear = clear;
1798	clear();
1799
1800	return /** @type {S & EnhancedSelector} */ (callSelector);
1801}
1802
1803;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js
1804/**
1805 * WordPress dependencies
1806 */
1807
1808
1809/**
1810 * Internal dependencies
1811 */
1812
1813
1814
1815/** @typedef {Record<string, import('./reducer').State>} State */
1816/** @typedef {import('./reducer').StateValue} StateValue */
1817/** @typedef {import('./reducer').Status} Status */
1818
1819/**
1820 * Returns the raw resolution state value for a given selector name,
1821 * and arguments set. May be undefined if the selector has never been resolved
1822 * or not resolved for the given set of arguments, otherwise true or false for
1823 * resolution started and completed respectively.
1824 *
1825 * @param {State}      state        Data state.
1826 * @param {string}     selectorName Selector name.
1827 * @param {unknown[]?} args         Arguments passed to selector.
1828 *
1829 * @return {StateValue|undefined} isResolving value.
1830 */
1831function getResolutionState(state, selectorName, args) {
1832  const map = state[selectorName];
1833  if (!map) {
1834    return;
1835  }
1836  return map.get(selectorArgsToStateKey(args));
1837}
1838
1839/**
1840 * Returns an `isResolving`-like value for a given selector name and arguments set.
1841 * Its value is either `undefined` if the selector has never been resolved or has been

1842 * invalidated, or a `true`/`false` boolean value if the resolution is in progress or
1843 * has finished, respectively.
1844 *
1845 * This is a legacy selector that was implemented when the "raw" internal data had
1846 * this `undefined | boolean` format. Nowadays the internal value is an object that
1847 * can be retrieved with `getResolutionState`.
1848 *
1849 * @deprecated
1850 *
1851 * @param {State}      state        Data state.
1852 * @param {string}     selectorName Selector name.
1853 * @param {unknown[]?} args         Arguments passed to selector.
1854 *
1855 * @return {boolean | undefined} isResolving value.
1856 */
1857function getIsResolving(state, selectorName, args) {
1858  external_wp_deprecated_default()('wp.data.select( store ).getIsResolving', {
1859    since: '6.6',
1860    version: '6.8',
1861    alternative: 'wp.data.select( store ).getResolutionState'
1862  });
1863  const resolutionState = getResolutionState(state, selectorName, args);
1864  return resolutionState && resolutionState.status === 'resolving';
1865}
1866
1867/**
1868 * Returns true if resolution has already been triggered for a given
1869 * selector name, and arguments set.
1870 *
1871 * @param {State}      state        Data state.
1872 * @param {string}     selectorName Selector name.
1873 * @param {unknown[]?} args         Arguments passed to selector.
1874 *
1875 * @return {boolean} Whether resolution has been triggered.
1876 */
1877function hasStartedResolution(state, selectorName, args) {
1878  return getResolutionState(state, selectorName, args) !== undefined;
1879}
1880
1881/**
1882 * Returns true if resolution has completed for a given selector
1883 * name, and arguments set.
1884 *
1885 * @param {State}      state        Data state.
1886 * @param {string}     selectorName Selector name.
1887 * @param {unknown[]?} args         Arguments passed to selector.
1888 *
1889 * @return {boolean} Whether resolution has completed.
1890 */
1891function hasFinishedResolution(state, selectorName, args) {
1892  const status = getResolutionState(state, selectorName, args)?.status;
1893  return status === 'finished' || status === 'error';
1894}
1895
1896/**
1897 * Returns true if resolution has failed for a given selector
1898 * name, and arguments set.
1899 *
1900 * @param {State}      state        Data state.
1901 * @param {string}     selectorName Selector name.
1902 * @param {unknown[]?} args         Arguments passed to selector.
1903 *
1904 * @return {boolean} Has resolution failed
1905 */
1906function hasResolutionFailed(state, selectorName, args) {
1907  return getResolutionState(state, selectorName, args)?.status === 'error';
1908}
1909
1910/**
1911 * Returns the resolution error for a given selector name, and arguments set.
1912 * Note it may be of an Error type, but may also be null, undefined, or anything else
1913 * that can be `throw`-n.
1914 *
1915 * @param {State}      state        Data state.
1916 * @param {string}     selectorName Selector name.
1917 * @param {unknown[]?} args         Arguments passed to selector.
1918 *
1919 * @return {Error|unknown} Last resolution error
1920 */
1921function getResolutionError(state, selectorName, args) {
1922  const resolutionState = getResolutionState(state, selectorName, args);
1923  return resolutionState?.status === 'error' ? resolutionState.error : null;
1924}
1925
1926/**
1927 * Returns true if resolution has been triggered but has not yet completed for
1928 * a given selector name, and arguments set.
1929 *
1930 * @param {State}      state        Data state.
1931 * @param {string}     selectorName Selector name.
1932 * @param {unknown[]?} args         Arguments passed to selector.
1933 *
1934 * @return {boolean} Whether resolution is in progress.
1935 */
1936function isResolving(state, selectorName, args) {
1937  return getResolutionState(state, selectorName, args)?.status === 'resolving';
1938}
1939
1940/**
1941 * Returns the list of the cached resolvers.
1942 *
1943 * @param {State} state Data state.
1944 *
1945 * @return {State} Resolvers mapped by args and selectorName.
1946 */
1947function getCachedResolvers(state) {
1948  return state;
1949}
1950
1951/**
1952 * Whether the store has any currently resolving selectors.
1953 *
1954 * @param {State} state Data state.
1955 *
1956 * @return {boolean} True if one or more selectors are resolving, false otherwise.
1957 */
1958function hasResolvingSelectors(state) {
1959  return Object.values(state).some(selectorState =>
1960  /**
1961   * This uses the internal `_map` property of `EquivalentKeyMap` for
1962   * optimization purposes, since the `EquivalentKeyMap` implementation
1963   * does not support a `.values()` implementation.
1964   *
1965   * @see https://github.com/aduth/equivalent-key-map
1966   */
1967  Array.from(selectorState._map.values()).some(resolution => resolution[1]?.status === 'resolving'));
1968}
1969
1970/**
1971 * Retrieves the total number of selectors, grouped per status.
1972 *
1973 * @param {State} state Data state.
1974 *
1975 * @return {Object} Object, containing selector totals by status.
1976 */
1977const countSelectorsByStatus = rememo(state => {
1978  const selectorsByStatus = {};
1979  Object.values(state).forEach(selectorState =>
1980  /**
1981   * This uses the internal `_map` property of `EquivalentKeyMap` for
1982   * optimization purposes, since the `EquivalentKeyMap` implementation
1983   * does not support a `.values()` implementation.
1984   *
1985   * @see https://github.com/aduth/equivalent-key-map
1986   */

1987  Array.from(selectorState._map.values()).forEach(resolution => {
1988    var _resolution$1$status;
1989    const currentStatus = (_resolution$1$status = resolution[1]?.status) !== null && _resolution$1$status !== void 0 ? _resolution$1$status : 'error';
1990    if (!selectorsByStatus[currentStatus]) {
1991      selectorsByStatus[currentStatus] = 0;
1992    }
1993    selectorsByStatus[currentStatus]++;
1994  }));
1995  return selectorsByStatus;
1996}, state => [state]);
1997
1998;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js
1999/**
2000 * Returns an action object used in signalling that selector resolution has
2001 * started.
2002 *
2003 * @param {string}    selectorName Name of selector for which resolver triggered.
2004 * @param {unknown[]} args         Arguments to associate for uniqueness.
2005 *
2006 * @return {{ type: 'START_RESOLUTION', selectorName: string, args: unknown[] }} Action object.
2007 */
2008function startResolution(selectorName, args) {
2009  return {
2010    type: 'START_RESOLUTION',
2011    selectorName,
2012    args
2013  };
2014}
2015
2016/**
2017 * Returns an action object used in signalling that selector resolution has
2018 * completed.
2019 *
2020 * @param {string}    selectorName Name of selector for which resolver triggered.
2021 * @param {unknown[]} args         Arguments to associate for uniqueness.
2022 *
2023 * @return {{ type: 'FINISH_RESOLUTION', selectorName: string, args: unknown[] }} Action object.
2024 */
2025function finishResolution(selectorName, args) {
2026  return {
2027    type: 'FINISH_RESOLUTION',
2028    selectorName,
2029    args
2030  };
2031}
2032
2033/**
2034 * Returns an action object used in signalling that selector resolution has
2035 * failed.
2036 *
2037 * @param {string}        selectorName Name of selector for which resolver triggered.
2038 * @param {unknown[]}     args         Arguments to associate for uniqueness.
2039 * @param {Error|unknown} error        The error that caused the failure.
2040 *
2041 * @return {{ type: 'FAIL_RESOLUTION', selectorName: string, args: unknown[], error: Error|unknown }} Action object.
2042 */
2043function failResolution(selectorName, args, error) {
2044  return {
2045    type: 'FAIL_RESOLUTION',
2046    selectorName,
2047    args,
2048    error
2049  };
2050}
2051
2052/**
2053 * Returns an action object used in signalling that a batch of selector resolutions has
2054 * started.
2055 *
2056 * @param {string}      selectorName Name of selector for which resolver triggered.
2057 * @param {unknown[][]} args         Array of arguments to associate for uniqueness, each item
2058 *                                   is associated to a resolution.
2059 *
2060 * @return {{ type: 'START_RESOLUTIONS', selectorName: string, args: unknown[][] }} Action object.
2061 */
2062function startResolutions(selectorName, args) {
2063  return {
2064    type: 'START_RESOLUTIONS',
2065    selectorName,
2066    args
2067  };
2068}
2069
2070/**
2071 * Returns an action object used in signalling that a batch of selector resolutions has
2072 * completed.
2073 *
2074 * @param {string}      selectorName Name of selector for which resolver triggered.
2075 * @param {unknown[][]} args         Array of arguments to associate for uniqueness, each item
2076 *                                   is associated to a resolution.
2077 *
2078 * @return {{ type: 'FINISH_RESOLUTIONS', selectorName: string, args: unknown[][] }} Action object.
2079 */
2080function finishResolutions(selectorName, args) {
2081  return {
2082    type: 'FINISH_RESOLUTIONS',
2083    selectorName,
2084    args
2085  };
2086}
2087
2088/**
2089 * Returns an action object used in signalling that a batch of selector resolutions has
2090 * completed and at least one of them has failed.
2091 *
2092 * @param {string}            selectorName Name of selector for which resolver triggered.
2093 * @param {unknown[]}         args         Array of arguments to associate for uniqueness, each item
2094 *                                         is associated to a resolution.
2095 * @param {(Error|unknown)[]} errors       Array of errors to associate for uniqueness, each item
2096 *                                         is associated to a resolution.
2097 * @return {{ type: 'FAIL_RESOLUTIONS', selectorName: string, args: unknown[], errors: Array<Error|unknown> }} Action object.
2098 */
2099function failResolutions(selectorName, args, errors) {
2100  return {
2101    type: 'FAIL_RESOLUTIONS',
2102    selectorName,
2103    args,
2104    errors
2105  };
2106}
2107
2108/**
2109 * Returns an action object used in signalling that we should invali

2109date the resolution cache.
2110 *
2111 * @param {string}    selectorName Name of selector for which resolver should be invalidated.
2112 * @param {unknown[]} args         Arguments to associate for uniqueness.
2113 *
2114 * @return {{ type: 'INVALIDATE_RESOLUTION', selectorName: string, args: any[] }} Action object.
2115 */
2116function invalidateResolution(selectorName, args) {
2117  return {
2118    type: 'INVALIDATE_RESOLUTION',
2119    selectorName,
2120    args
2121  };
2122}
2123
2124/**
2125 * Returns an action object used in signalling that the resolution
2126 * should be invalidated.
2127 *
2128 * @return {{ type: 'INVALIDATE_RESOLUTION_FOR_STORE' }} Action object.
2129 */
2130function invalidateResolutionForStore() {
2131  return {
2132    type: 'INVALIDATE_RESOLUTION_FOR_STORE'
2133  };
2134}
2135
2136/**
2137 * Returns an action object used in signalling that the resolution cache for a
2138 * given selectorName should be invalidated.
2139 *
2140 * @param {string} selectorName Name of selector for which all resolvers should
2141 *                              be invalidated.
2142 *
2143 * @return  {{ type: 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR', selectorName: string }} Action object.
2144 */

2145function invalidateResolutionForStoreSelector(selectorName) {
2146  return {
2147    type: 'INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR',
2148    selectorName
2149  };
2150}
2151
2152;// ./node_modules/@wordpress/data/build-module/redux-store/index.js
2153/**
2154 * External dependencies
2155 */
2156
2157
2158
2159/**
2160 * WordPress dependencies
2161 */
2162
2163
2164
2165/**
2166 * Internal dependencies
2167 */
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179/** @typedef {import('../types').DataRegistry} DataRegistry */
2180/** @typedef {import('../types').ListenerFunction} ListenerFunction */
2181/**
2182 * @typedef {import('../types').StoreDescriptor<C>} StoreDescriptor
2183 * @template {import('../types').AnyConfig} C
2184 */
2185/**
2186 * @typedef {import('../types').ReduxStoreConfig<State,Actions,Selectors>} ReduxStoreConfig
2187 * @template State
2188 * @template {Record<string,import('../types').ActionCreator>} Actions
2189 * @template Selectors
2190 */
2191
2192const trimUndefinedValues = array => {
2193  const result = [...array];
2194  for (let i = result.length - 1; i >= 0; i--) {
2195    if (result[i] === undefined) {
2196      result.splice(i, 1);
2197    }
2198  }
2199  return result;
2200};
2201
2202/**
2203 * Creates a new object with the same keys, but with `callback()` called as
2204 * a transformer function on each of the values.
2205 *
2206 * @param {Object}   obj      The object to transform.
2207 * @param {Function} callback The function to transform each object value.
2208 * @return {Array} Transformed object.
2209 */
2210const mapValues = (obj, callback) => Object.fromEntries(Object.entries(obj !== null && obj !== void 0 ? obj : {}).map(([key, value]) => [key, callback(value, key)]));
2211
2212// Convert  non serializable types to plain objects
2213const devToolsReplacer = (key, state) => {
2214  if (state instanceof Map) {
2215    return Object.fromEntries(state);
2216  }
2217  if (state instanceof window.HTMLElement) {
2218    return null;
2219  }
2220  return state;
2221};
2222
2223/**
2224 * Create a cache to track whether resolvers started running or not.
2225 *
2226 * @return {Object} Resolvers Cache.
2227 */
2228function createResolversCache() {
2229  const cache = {};
2230  return {
2231    isRunning(selectorName, args) {
2232      return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args));
2233    },
2234    clear(selectorName, args) {
2235      if (cache[selectorName]) {
2236        cache[selectorName].delete(trimUndefinedValues(args));
2237      }
2238    },
2239    markAsRunning(selectorName, args) {
2240      if (!cache[selectorName]) {
2241        cache[selectorName] = new (equivalent_key_map_default())();
2242      }
2243      cache[selectorName].set(trimUndefinedValues(args), true);
2244    }
2245  };
2246}
2247function createBindingCache(bind) {
2248  const cache = new WeakMap();
2249  return {
2250    get(item, itemName) {
2251      let boundItem = cache.get(item);
2252      if (!boundItem) {
2253        boundItem = bind(item, itemName);
2254        cache.set(item, boundItem);
2255      }
2256      return boundItem;
2257    }
2258  };
2259}
2260
2261/**
2262 * Creates a data store descriptor for the provided Redux store configuration containing
2263 * properties describing reducer, actions, selectors, controls and resolvers.
2264 *
2265 * @example
2266 * ```js
2267 * import { createReduxStore } from '@wordpress/data';
2268 *
2269 * const store = createReduxStore( 'demo', {
2270 *     reducer: ( state = 'OK' ) => state,
2271 *     selectors: {
2272 *         getValue: ( state ) => state,
2273 *     },
2274 * } );
2275 * ```
2276 *
2277 * @template State
2278 * @template {Record<string,import('../types').ActionCreator>} Actions
2279 * @template Selectors
2280 * @param {string}                                    key     Unique namespace identifier.
2281 * @param {ReduxStoreConfig<State,Actions,Selectors>} options Registered store options, with properties
2282 *                                                            describing reducer, actions, selectors,
2283 *                                                            and resolvers.
2284 *
2285 * @return   {StoreDescriptor<ReduxStoreConfig<State,Actions,Selectors>>} Store Object.
2286 */
2287function createReduxStore(key, options) {
2288  const privateActions = {};
2289  const privateSelectors = {};
2290  const privateRegistrationFunctions = {
2291    privateActions,
2292    registerPrivateActions: actions => {
2293      Object.assign(privateActions, actions);
2294    },
2295    privateSelectors,
2296    registerPrivateSelectors: selectors => {
2297      Object.assign(privateSelectors, selectors);
2298    }
2299  };
2300  const storeDescriptor = {
2301    name: key,
2302    instantiate: registry => {
2303      /**
2304       * Stores listener functions registered with `subscribe()`.
2305       *
2306       * When functions register to listen to store changes with
2307       * `subscribe()` they get added here. Although Redux offers
2308       * its own `subscribe()` function directly, by wrapping the
2309       * subscription in this store instance it's possible to
2310       * optimize checking if the state has changed before calling
2311       * each listener.
2312       *
2313       * @type {Set<ListenerFunction>}
2314       */
2315      const listeners = new Set();
2316      const reducer = options.reducer;
2317      const thunkArgs = {
2318        registry,
2319        get dispatch() {
2320          return thunkActions;
2321        },
2322        get select() {
2323          return thunkSelectors;
2324        },
2325        get resolveSelect() {
2326          return getResolveSelectors();
2327        }
2328      };
2329      const store = instantiateReduxStore(key, options, registry, thunkArgs);
2330      // Expose the private registration functions on the store
2331      // so they can be copied to a sub registry in registry.js.
2332      lock(store, privateRegistrationFunctions);
2333      const resolversCache = createResolversCache();
2334      function bindAction(action) {
2335        return (...args) => Promise.resolve(store.dispatch(action(...args)));
2336      }
2337      const actions = {
2338        ...mapValues(actions_namespaceObject, bindAction),
2339        ...mapValues(options.actions, bindAction)
2340      };
2341      const boundPrivateActions = createBindingCache(bindAction);
2342      const allActions = new Proxy(() => {}, {
2343        get: (target, prop) => {
2344          const privateAction = privateActions[prop];
2345          return privateAction ? boundPrivateActions.get(privateAction, prop

2345) : actions[prop];
2346        }
2347      });
2348      const thunkActions = new Proxy(allActions, {
2349        apply: (target, thisArg, [action]) => store.dispatch(action)
2350      });
2351      lock(actions, allActions);
2352      const resolvers = options.resolvers ? mapResolvers(options.resolvers) : {};
2353      function bindSelector(selector, selectorName) {
2354        if (selector.isRegistrySelector) {
2355          selector.registry = registry;
2356        }
2357        const boundSelector = (...args) => {
2358          args = normalize(selector, args);
2359          const state = store.__unstableOriginalGetState();
2360          // Before calling the selector, switch to the correct
2361          // registry.
2362          if (selector.isRegistrySelector) {
2363            selector.registry = registry;
2364          }
2365          return selector(state.root, ...args);
2366        };
2367
2368        // Expose normalization method on the bound selector
2369        // in order that it can be called when fulfilling
2370        // the resolver.
2371        boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
2372        const resolver = resolvers[selectorName];
2373        if (!resolver) {
2374          boundSelector.hasResolver = false;
2375          return boundSelector;
2376        }
2377        return mapSelectorWithResolver(boundSelector, selectorName, resolver, store, resolversCache);
2378      }
2379      function bindMetadataSelector(metaDataSelector) {
2380        const boundSelector = (...args) => {
2381          const state = store.__unstableOriginalGetState();
2382          const originalSelectorName = args && args[0];
2383          const originalSelectorArgs = args && args[1];
2384          const targetSelector = options?.selectors?.[originalSelectorName];
2385
2386          // Normalize the arguments passed to the target selector.
2387          if (originalSelectorName && targetSelector) {
2388            args[1] = normalize(targetSelector, originalSelectorArgs);
2389          }
2390          return metaDataSelector(state.metadata, ...args);
2391        };
2392        boundSelector.hasResolver = false;
2393        return boundSelector;
2394      }
2395      const selectors = {
2396        ...mapValues(selectors_namespaceObject, bindMetadataSelector),
2397        ...mapValues(options.selectors, bindSelector)
2398      };
2399      const boundPrivateSelectors = createBindingCache(bindSelector);
2400
2401      // Pre-bind the private selectors that have been registered by the time of
2402      // instantiation, so that registry selectors are bound to the registry.
2403      for (const [selectorName, selector] of Object.entries(privateSelectors)) {
2404        boundPrivateSelectors.get(selector, selectorName);
2405      }
2406      const allSelectors = new Proxy(() => {}, {
2407        get: (target, prop) => {
2408          const privateSelector = privateSelectors[prop];
2409          return privateSelector ? boundPrivateSelectors.get(privateSelector, prop) : selectors[prop];
2410        }
2411      });
2412      const thunkSelectors = new Proxy(allSelectors, {
2413        apply: (target, thisArg, [selector]) => selector(store.__unstableOriginalGetState())
2414      });
2415      lock(selectors, allSelectors);
2416      const resolveSelectors = mapResolveSelectors(selectors, store);
2417      const suspendSelectors = mapSuspendSelectors(selectors, store);
2418      const getSelectors = () => selectors;
2419      const getActions = () => actions;
2420      const getResolveSelectors = () => resolveSelectors;
2421      const getSuspendSelectors = () => suspendSelectors;
2422
2423      // We have some modules monkey-patching the store object
2424      // It's wrong to do so but until we refactor all of our effects to controls
2425      // We need to keep the same "store" instance here.
2426      store.__unstableOriginalGetState = store.getState;
2427      store.getState = () => store.__unstableOriginalGetState().root;
2428
2429      // Customize subscribe behavior to call listeners only on effective change,
2430      // not on every dispatch.
2431      const subscribe = store && (listener => {
2432        listeners.add(listener);
2433        return () => listeners.delete(listener);
2434      });
2435      let lastState = store.__unstableOriginalGetState();
2436      store.subscribe(() => {
2437        const state = store.__unstableOriginalGetState();
2438        const hasChanged = state !== lastState;
2439        lastState = state;
2440        if (hasChanged) {
2441          for (const listener of listeners) {
2442            listener();
2443          }
2444        }
2445      });
2446
2447      // This can be simplified to just { subscribe, getSelectors, getActions }
2448      // Once we remove the use function.
2449      return {
2450        reducer,
2451        store,
2452        actions,
2453        selectors,
2454        resolvers,
2455        getSelectors,
2456        getResolveSelectors,
2457        getSuspendSelectors,
2458        getActions,
2459        subscribe
2460      };
2461    }
2462  };
2463
2464  // Expose the private registration functions on the store
2465  // descriptor. That's a natural choice since that's where the
2466  // public actions and selectors are stored .
2467  lock(storeDescriptor, privateRegistrationFunctions);
2468  return storeDescriptor;
2469}
2470

2471/**
2472 * Creates a redux store for a namespace.
2473 *
2474 * @param {string}       key       Unique namespace identifier.
2475 * @param {Object}       options   Registered store options, with properties
2476 *                                 describing reducer, actions, selectors,
2477 *                                 and resolvers.
2478 * @param {DataRegistry} registry  Registry reference.
2479 * @param {Object}       thunkArgs Argument object for the thunk middleware.
2480 * @return {Object} Newly created redux store.
2481 */
2482function instantiateReduxStore(key, options, registry, thunkArgs) {
2483  const controls = {
2484    ...options.controls,
2485    ...builtinControls
2486  };
2487  const normalizedControls = mapValues(controls, control => control.isRegistryControl ? control(registry) : control);
2488  const middlewares = [resolvers_cache_middleware(registry, key), promise_middleware, external_wp_reduxRoutine_default()(normalizedControls), createThunkMiddleware(thunkArgs)];
2489  const enhancers = [applyMiddleware(...middlewares)];
2490  if (typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__) {
2491    enhancers.push(window.__REDUX_DEVTOOLS_EXTENSION__({
2492      name: key,
2493      instanceId: key,
2494      serialize: {
2495        replacer: devToolsReplacer
2496      }
2497    }));
2498  }
2499  const {
2500    reducer,
2501    initialState
2502  } = options;
2503  const enhancedReducer = combine_reducers_combineReducers({
2504    metadata: metadata_reducer,
2505    root: reducer
2506  });
2507  return createStore(enhancedReducer, {
2508    root: initialState
2509  }, (0,external_wp_compose_namespaceObject.compose)(enhancers));
2510}
2511
2512/**
2513 * Maps selectors to functions that return a resolution promise for them
2514 *
2515 * @param {Object} selectors Selectors to map.
2516 * @param {Object} store     The redux store the selectors select from.
2517 *
2518 * @return {Object} Selectors mapped to their resolution functions.
2519 */
2520function mapResolveSelectors(selectors, store) {
2521  const {
2522    getIsResolving,
2523    hasStartedResolution,
2524    hasFinishedResolution,
2525    hasResolutionFailed,
2526    isResolving,
2527    getCachedResolvers,
2528    getResolutionState,
2529    getResolutionError,
2530    hasResolvingSelectors,
2531    countSelectorsByStatus,
2532    ...storeSelectors
2533  } = selectors;
2534  return mapValues(storeSelectors, (selector, selectorName) => {
2535    // If the selector doesn't have a resolver, just convert the return value
2536    // (including exceptions) to a Promise, no additional extra behavior is needed.
2537    if (!selector.hasResolver) {
2538      return async (...args) => selector.apply(null, args);
2539    }
2540    return (...args) => {
2541      return new Promise((resolve, reject) => {
2542        const hasFinished = () => selectors.hasFinishedResolution(selectorName, args);
2543        const finalize = result => {
2544          const hasFailed = selectors.hasResolutionFailed(selectorName, args);
2545          if (hasFailed) {
2546            const error = selectors.getResolutionError(selectorName, args);
2547            reject(error);
2548          } else {
2549            resolve(result);
2550          }
2551        };
2552        const getResult = () => selector.apply(null, args);
2553        // Trigger the selector (to trigger the resolver)
2554        const result = getResult();
2555        if (hasFinished()) {
2556          return finalize(result);
2557        }
2558        const unsubscribe = store.subscribe(() => {
2559          if (hasFinished()) {
2560            unsubscribe();
2561            finalize(getResult());
2562          }
2563        });
2564      });
2565    };
2566  });
2567}
2568
2569/**
2570 * Maps selectors to functions that throw a suspense promise if not yet resolved.
2571 *
2572 * @param {Object} selectors Selectors to map.
2573 * @param {Object} store     The redux store the selectors select from.
2574 *
2575 * @return {Object} Selectors mapped to their suspense functions.
2576 */
2577function mapSuspendSelectors(selectors, store) {
2578  return mapValues(selectors, (selector, selectorName) => {
2579    // Selector without a resolver doesn't have any extra suspense behavior.
2580    if (!selector.hasResolver) {
2581      return selector;
2582    }
2583    return (...args) => {
2584      const result = selector.apply(null, args);
2585      if (selectors.hasFinishedResolution(selectorName, args)) {
2586        if (selectors.hasResolutionFailed(selectorName, args)) {
2587          throw selectors.getResolutionError(selectorName, args);
2588        }
2589        return result;
2590      }
2591      throw new Promise(resolve => {
2592        const unsubscribe = store.subscribe(() => {
2593          if (selectors.hasFinishedResolution(selectorName, args)) {
2594            resolve();
2595            unsubscribe();
2596          }
2597        });
2598      });
2599    };
2600  });
2601}
2602
2603/**
2604 * Convert resolvers to a normalized form, an object with `fulfill` method and
2605 * optional methods like `isFulfilled`.
2606 *
2607 * @param {Object} resolvers Resolver to convert
2608 */
2609function mapResolvers(resolvers) {
2610  return mapValues(resolvers, resolver => {
2611    if (resolver.fulfill) {
2612      return resolver;
2613    }
2614    return {
2615      ...resolver,
2616      // Copy the enumerable properties of the resolver function.
2617      fulfill: resolver // Add the fulfill method.
2618    };
2619  });
2620}
2621
2622/**
2623 * Returns a selector with a matched resolver.
2624 * Resolvers are side effects invoked once per argument set of a given selector call,
2625 * used in ensuring that the data needs for the selector are satisfied.
2626 *
2627 * @param {Object} selector       The selector function to be bound.
2628 * @param {string} selectorName   The selector name.
2629 * @param {Object} resolver       Resolver to call.
2630 * @param {Object} store          The redux store to which the resolvers should be mapped.
2631 * @param {Object} resolversCache Resolvers Cache.
2632 */

2633function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache) {
2634  function fulfillSelector(args) {
2635    const state = store.getState();
2636    if (resolversCache.isRunning(selectorName, args) || typeof resolver.isFulfilled === 'function' && resolver.isFulfilled(state, ...args)) {
2637      return;
2638    }
2639    const {
2640      metadata
2641    } = store.__unstableOriginalGetState();
2642    if (hasStartedResolution(metadata, selectorName, args)) {
2643      return;
2644    }
2645    resolversCache.markAsRunning(selectorName, args);
2646    setTimeout(async () => {
2647      resolversCache.clear(selectorName, args);
2648      store.dispatch(startResolution(selectorName, args));
2649      try {
2650        const action = resolver.fulfill(...args);
2651        if (action) {
2652          await store.dispatch(action);
2653        }
2654        store.dispatch(finishResolution(selectorName, args));
2655      } catch (error) {
2656        store.dispatch(failResolution(selectorName, args, error));
2657      }
2658    }, 0);
2659  }
2660  const selectorResolver = (...args) => {
2661    args = normalize(selector, args);
2662    fulfillSelector(args);
2663    return selector(...args);
2664  };
2665  selectorResolver.hasResolver = true;
2666  return selectorResolver;
2667}
2668
2669/**
2670 * Applies selector's normalization function to the given arguments
2671 * if it exists.
2672 *
2673 * @param {Object} selector The selector potentially with a normalization method property.
2674 * @param {Array}  args     selector arguments to normalize.
2675 * @return {Array} Potentially normalized arguments.
2676 */
2677function normalize(selector, args) {
2678  if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === 'function' && args?.length) {
2679    return selector.__unstableNormalizeArgs(args);
2680  }
2681  return args;
2682}
2683
2684;// ./node_modules/@wordpress/data/build-module/store/index.js
2685const coreDataStore = {
2686  name: 'core/data',
2687  instantiate(registry) {
2688    const getCoreDataSelector = selectorName => (key, ...args) => {
2689      return registry.select(key)[selectorName](...args);
2690    };
2691    const getCoreDataAction = actionName => (key, ...args) => {
2692      return registry.dispatch(key)[actionName](...args);
2693    };
2694    return {
2695      getSelectors() {
2696        return Object.fromEntries(['getIsResolving', 'hasStartedResolution', 'hasFinishedResolution', 'isResolving', 'getCachedResolvers'].map(selectorName => [selectorName, getCoreDataSelector(selectorName)]));
2697      },
2698      getActions() {
2699        return Object.fromEntries(['startResolution', 'finishResolution', 'invalidateResolution', 'invalidateResolutionForStore', 'invalidateResolutionForStoreSelector'].map(actionName => [actionName, getCoreDataAction(actionName)]));
2700      },
2701      subscribe() {
2702        // There's no reasons to trigger any listener when we subscribe to this store
2703        // because there's no state stored in this store that need to retrigger selectors
2704        // if a change happens, the corresponding store where the tracking stated live
2705        // would have already triggered a "subscribe" call.
2706        return () => () => {};
2707      }
2708    };
2709  }
2710};
2711/* harmony default export */ const store = (coreDataStore);
2712
2713;// ./node_modules/@wordpress/data/build-module/utils/emitter.js
2714/**
2715 * Create an event emitter.
2716 *
2717 * @return The event emitter.
2718 */
2719function createEmitter() {
2720  let isPaused = false;
2721  let isPending = false;
2722  const listeners = new Set();
2723  const notifyListeners = () =>
2724  // We use Array.from to clone the listeners Set
2725  // This ensures that we don't run a listener
2726  // that was added as a response to another listener.
2727  Array.from(listeners).forEach(listener => listener());
2728  return {
2729    get isPaused() {
2730      return isPaused;
2731    },
2732    subscribe(listener) {
2733      listeners.add(listener);
2734      return () => listeners.delete(listener);
2735    },
2736    pause() {
2737      isPaused = true;
2738    },
2739    resume() {
2740      isPaused = false;
2741      if (isPending) {
2742        isPending = false;
2743        notifyListeners();
2744      }
2745    },
2746    emit() {
2747      if (isPaused) {
2748        isPending = true;
2749        return;
2750      }
2751      notifyListeners();
2752    }
2753  };
2754}
2755
2756;// ./node_modules/@wordpress/data/build-module/registry.js
2757/**
2758 * WordPress dependencies
2759 */
2760
2761
2762/**
2763 * Internal dependencies
2764 */
2765
2766
2767
2768
2769
2770/** @typedef {import('./types').StoreDescriptor} StoreDescriptor */
2771
2772/**
2773 * @typedef {Object} WPDataRegistry An isolated orchestrator of store registrations.
2774 *
2775 * @property {Function} registerGenericStore Given a namespace key and settings
2776 *                                           object, registers a new generic
2777 *                                           store.
2778 * @property {Function} registerStore        Given a namespace key and settings
2779 *                                           object, registers a new namespace
2780 *                                           store.
2781 * @property {Function} subscribe            Given a function callback, invokes
2782 *                                           the callback on any change to state
2783 *                                           within any registered store.
2784 * @property {Function} select               Given a namespace key, returns an
2785 *                                           object of the  store's registered
2786 *                                           selectors.
2787 * @property {Function} dispatch             Given a namespace key, returns an
2788 *                                           object of the store's registered
2789 *                                           action dispatchers.
2790 */
2791
2792/**
2793 * @typedef {Object} WPDataPlugin An object of registry function overrides.
2794 *
2795 * @property {Function} registerStore registers store.
2796 */
2797
2798function getStoreName(storeNameOrDescriptor) {
2799  return typeof storeNameOrDescriptor === 'string' ? storeNameOrDescriptor : storeNameOrDescriptor.name;
2800}
2801/**
2802 * Creates a new store registry, given an optional object of initial store
2803 * configurations.
2804 *
2805 * @param {Object}  storeConfigs Initial store configurations.
2806 * @param {?Object} parent       Parent registry.
2807 *
2808 * @return {WPDataRegistry} Data registry.
2809 */
2810function createRegistry(storeConfigs = {}, parent = null) {
2811  const stores = {};
2812  const emitter = createEmitter();
2813  let listeningStores = null;
2814
2815  /**
2816   * Global listener called for each store's update.
2817   */
2818  function globalListener() {
2819    emitter.emit();
2820  }
2821
2822  /**
2823   * Subscribe to changes to any data, either in all stores in registry, or
2824   * in one specific store.
2825   *
2826   * @param {Function}                listener              Listener function.
2827   * @param {string|StoreDescriptor?} storeNameOrDescriptor Optional store name.
2828   *
2829   * @return {Function} Unsubscribe function.
2830   */
2831  const subscribe = (listener, storeNameOrDescriptor) => {
2832    // subscribe to all stores
2833    if (!storeNameOrDescriptor) {
2834      return emitter.subscribe(listener);
2835    }
2836
2837    // subscribe to one store
2838    const storeName = getStoreName(storeNameOrDescriptor);
2839    const store = stores[storeName];
2840    if (store) {
2841      return store.subscribe(listener);
2842    }
2843
2844    // Trying to access a store that hasn't been registered,
2845    // this is a pattern rarely used but seen in some places.
2846    // We fallback to global `subscribe` here for backward-compatibility for now.
2847    // See https://github.com/WordPress/gutenberg/pull/27466 for more info.
2848    if (!parent) {
2849      return emitter.subscribe(listener);
2850    }
2851    return parent.subscribe(listener, storeNameOrDescriptor);
2852  };
2853
2854  /**
2855   * Calls a selector given the current state and extra arguments.
2856   *
2857   * @param {string|StoreDescriptor} storeNameOrDescriptor Unique namespace identifier for the store
2858   *                                                       or the store descriptor.
2859   *
2860   * @return {*} The selector's returned value.
2861   */
2862  function select(storeNameOrDescriptor) {
2863    const storeName = getStoreName(storeNameOrDescriptor);
2864    listeningStores?.add(storeName);
2865    const store = stores[storeName];
2866    if (store) {
2867      return store.getSelectors();
2868    }
2869    return parent?.select(storeName);
2870  }
2871  function __unstableMarkListeningStores(callback, ref) {
2872    listeningStores = new Set();
2873    try {
2874      return callback.call(this);
2875    } finally {
2876      ref.current = Array.from(listeningStores);
2877      listeningStores = null;
2878    }
2879  }
2880
2881  /**