Gutenberg / 22.3.0

Gutenberg v22.3.0

gutenberg / build / scripts / data / index.js

index.js in Gutenberg 22.3.0, at build/scripts/data/index.js

2,458 lines 82.5 KB

Raw Download Zip

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