Gutenberg / 22.4.3

Gutenberg v22.4.3

gutenberg / build / scripts / data / index.js

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

2,460 lines 82.7 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 ? /* @__PURE__ */ 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.mjs
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.mjs
440	var import_deprecated2 = __toESM(require_deprecated(), 1);
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.mjs
680	var import_equivalent_key_map2 = __toESM(require_equivalent_key_map(), 1);
681	var import_redux_routine = __toESM(require_redux_routine(), 1);
682	var import_compose = __toESM(require_compose(), 1);
683
684	// packages/data/build-module/redux-store/combine-reducers.mjs
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.mjs
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.mjs
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.mjs
770	var import_private_apis = __toESM(require_private_apis(), 1);
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.mjs
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.mjs
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.mjs
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.mjs
831	var import_equivalent_key_map = __toESM(require_equivalent_key_map(), 1);
832
833	// packages/data/build-module/redux-store/metadata/utils.mjs
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.mjs
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	default:
952	return state;
953	}
954	};
955	var reducer_default = isResolved;
956
957	// packages/data/build-module/redux-store/metadata/selectors.mjs
958	var selectors_exports = {};
959	__export(selectors_exports, {
960	countSelectorsByStatus: () => countSelectorsByStatus,
961	getCachedResolvers: () => getCachedResolvers,
962	getIsResolving: () => getIsResolving,
963	getResolutionError: () => getResolutionError,
964	getResolutionState: () => getResolutionState,
965	hasFinishedResolution: () => hasFinishedResolution,
966	hasResolutionFailed: () => hasResolutionFailed,
967	hasResolvingSelectors: () => hasResolvingSelectors,
968	hasStartedResolution: () => hasStartedResolution,
969	isResolving: () => isResolving
970	});
971	var import_deprecated = __toESM(require_deprecated(), 1);
972
973	// node_modules/rememo/rememo.js
974	var LEAF_KEY = {};
975	function arrayOf(value) {
976	return [value];
977	}
978	function isObjectLike(value) {
979	return !!value && "object" === typeof value;
980	}
981	function createCache() {
982	var cache = {
983	clear: function() {
984	cache.head = null;
985	}
986	};
987	return cache;
988	}
989	function isShallowEqual(a, b, fromIndex) {
990	var i;
991	if (a.length !== b.length) {
992	return false;
993	}
994	for (i = fromIndex; i < a.length; i++) {
995	if (a[i] !== b[i]) {
996	return false;
997	}
998	}
999	return true;
1000	}
1001	function rememo_default(selector, getDependants) {
1002	var rootCache;
1003	var normalizedGetDependants = getDependants ? getDependants : arrayOf;
1004	function getCache(dependants) {
1005	var caches = rootCache, isUniqueByDependants = true, i, dependant, map, cache;
1006	for (i = 0; i < dependants.length; i++) {
1007	dependant = dependants[i];
1008	if (!isObjectLike(dependant)) {
1009	isUniqueByDependants = false;
1010	break;
1011	}
1012	if (caches.has(dependant)) {
1013	caches = caches.get(dependant);
1014	} else {
1015	map = /* @__PURE__ */ new WeakMap();
1016	caches.set(dependant, map);
1017	caches = map;
1018	}
1019	}
1020	if (!caches.has(LEAF_KEY)) {
1021	cache = createCache();
1022	cache.isUniqueByDependants = isUniqueByDependants;
1023	caches.set(LEAF_KEY, cache);
1024	}
1025	return caches.get(LEAF_KEY);
1026	}
1027	function clear() {
1028	rootCache = /* @__PURE__ */ new WeakMap();
1029	}
1030	function callSelector() {
1031	var len = arguments.length, cache, node, i, args, dependants;
1032	args = new Array(len);
1033	for (i = 0; i < len; i++) {
1034	args[i] = arguments[i];
1035	}
1036	dependants = normalizedGetDependants.apply(null, args);
1037	cache = getCache(dependants);
1038	if (!cache.isUniqueByDependants) {
1039	if (cache.lastDependants && !isShallowEqual(dependants, cache.lastDependants, 0)) {
1040	cache.clear();
1041	}
1042	cache.lastDependants = dependants;
1043	}
1044	node = cache.head;
1045	while (node) {
1046	if (!isShallowEqual(node.args, args, 1)) {
1047	node = node.next;
1048	continue;
1049	}
1050	if (node !== cache.head) {
1051	node.prev.next = node.next;
1052	if (node.next) {
1053	node.next.prev = node.prev;
1054	}
1055	node.next = cache.head;
1056	node.prev = null;
1057	cache.head.prev = node;
1058	cache.head = node;
1059	}
1060	return node.val;
1061	}
1062	node = /** @type {CacheNode} */
1063	{
1064	// Generate the result from original function
1065	val: selector.apply(null, args)
1066	};
1067	args[0] = null;
1068	node.args = args;
1069	if (cache.head) {
1070	cache.head.prev = node;
1071	node.next = cache.head;
1072	}
1073	cache.head = node;
1074	return node.val;
1075	}
1076	callSelector.getDependants = normalizedGetDependants;
1077	callSelector.clear = clear;
1078	clear();
1079	return (
1080	/** @type {S & EnhancedSelector} */
1081	callSelector
1082	);
1083	}
1084
1085	// packages/data/build-module/redux-store/metadata/selectors.mjs
1086	function getResolutionState(state, selectorName, args) {
1087	const map = state[selectorName];
1088	if (!map) {
1089	return;
1090	}
1091	return map.get(selectorArgsToStateKey(args));
1092	}
1093	function getIsResolving(state, selectorName, args) {
1094	(0, import_deprecated.default)("wp.data.select( store ).getIsResolving", {
1095	since: "6.6",
1096	version: "6.8",
1097	alternative: "wp.data.select( store ).getResolutionState"
1098	});
1099	const resolutionState = getResolutionState(state, selectorName, args);
1100	return resolutionState && resolutionState.status === "resolving";
1101	}
1102	function hasStartedResolution(state, selectorName, args) {
1103	return getResolutionState(state, selectorName, args) !== void 0;
1104	}
1105	function hasFinishedResolution(state, selectorName, args) {
1106	const status = getResolutionState(state, selectorName, args)?.status;
1107	return status === "finished" \|\| status === "error";
1108	}
1109	function hasResolutionFailed(state, selectorName, args) {
1110	return getResolutionState(state, selectorName, args)?.status === "error";
1111	}
1112	function getResolutionError(state, selectorName, args) {
1113	const resolutionState = getResolutionState(state, selectorName, args);
1114	return resolutionState?.status === "error" ? resolutionState.error : null;
1115	}
1116	function isResolving(state, selectorName, args) {
1117	return getResolutionState(state, selectorName, args)?.status === "resolving";
1118	}
1119	function getCachedResolvers(state) {
1120	return state;
1121	}
1122	function hasResolvingSelectors(state) {
1123	return Object.values(state).some(
1124	(selectorState) => (
1125	/**
1126	* This uses the internal `_map` property of `EquivalentKeyMap` for
1127	* optimization purposes, since the `EquivalentKeyMap` implementation
1128	* does not support a `.values()` implementation.
1129	*
1130	* @see https://github.com/aduth/equivalent-key-map
1131	*/
1132	Array.from(selectorState._map.values()).some(
1133	(resolution) => resolution[1]?.status === "resolving"
1134	)
1135	)
1136	);
1137	}
1138	var countSelectorsByStatus = rememo_default(
1139	(state) => {
1140	const selectorsByStatus = {};
1141	Object.values(state).forEach(
1142	(selectorState) => (
1143	/**
1144	* This uses the internal `_map` property of `EquivalentKeyMap` for
1145	* optimization purposes, since the `EquivalentKeyMap` implementation
1146	* does not support a `.values()` implementation.
1147	*
1148	* @see https://github.com/aduth/equivalent-key-map
1149	*/
1150	Array.from(selectorState._map.values()).forEach(
1151	(resolution) => {
1152	const currentStatus = resolution[1]?.status ?? "error";
1153	if (!selectorsByStatus[currentStatus]) {
1154	selectorsByStatus[currentStatus] = 0;
1155	}
1156	selectorsByStatus[currentStatus]++;
1157	}
1158	)
1159	)
1160	);
1161	return selectorsByStatus;
1162	},
1163	(state) => [state]
1164	);
1165
1166	// packages/data/build-module/redux-store/metadata/actions.mjs
1167	var actions_exports = {};
1168	__export(actions_exports, {
1169	failResolution: () => failResolution,
1170	failResolutions: () => failResolutions,
1171	finishResolution: () => finishResolution,
1172	finishResolutions: () => finishResolutions,
1173	invalidateResolution: () => invalidateResolution,
1174	invalidateResolutionForStore: () => invalidateResolutionForStore,
1175	invalidateResolutionForStoreSelector: () => invalidateResolutionForStoreSelector,
1176	startResolution: () => startResolution,
1177	startResolutions: () => startResolutions
1178	});
1179	function startResolution(selectorName, args) {
1180	return {
1181	type: "START_RESOLUTION",
1182	selectorName,
1183	args
1184	};
1185	}
1186	function finishResolution(selectorName, args) {
1187	return {
1188	type: "FINISH_RESOLUTION",
1189	selectorName,
1190	args
1191	};
1192	}
1193	function failResolution(selectorName, args, error) {
1194	return {
1195	type: "FAIL_RESOLUTION",
1196	selectorName,
1197	args,
1198	error
1199	};
1200	}
1201	function startResolutions(selectorName, args) {
1202	return {
1203	type: "START_RESOLUTIONS",
1204	selectorName,
1205	args
1206	};
1207	}
1208	function finishResolutions(selectorName, args) {
1209	return {
1210	type: "FINISH_RESOLUTIONS",
1211	selectorName,
1212	args
1213	};
1214	}
1215	function failResolutions(selectorName, args, errors) {
1216	return {
1217	type: "FAIL_RESOLUTIONS",
1218	selectorName,
1219	args,
1220	errors
1221	};
1222	}
1223	function invalidateResolution(selectorName, args) {
1224	return {
1225	type: "INVALIDATE_RESOLUTION",
1226	selectorName,
1227	args
1228	};
1229	}
1230	function invalidateResolutionForStore() {
1231	return {
1232	type: "INVALIDATE_RESOLUTION_FOR_STORE"
1233	};
1234	}
1235	function invalidateResolutionForStoreSelector(selectorName) {
1236	return {
1237	type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR",
1238	selectorName
1239	};
1240	}
1241
1242	// packages/data/build-module/redux-store/index.mjs
1243	var trimUndefinedValues = (array) => {
1244	const result = [...array];
1245	for (let i = result.length - 1; i >= 0; i--) {
1246	if (result[i] === void 0) {
1247	result.splice(i, 1);
1248	}
1249	}
1250	return result;
1251	};
1252	var mapValues = (obj, callback) => Object.fromEntries(
1253	Object.entries(obj ?? {}).map(([key, value]) => [
1254	key,
1255	callback(value, key)
1256	])
1257	);
1258	var devToolsReplacer = (key, state) => {
1259	if (state instanceof Map) {
1260	return Object.fromEntries(state);
1261	}
1262	if (state instanceof window.HTMLElement) {
1263	return null;
1264	}
1265	return state;
1266	};
1267	function createResolversCache() {
1268	const cache = {};
1269	return {
1270	isRunning(selectorName, args) {
1271	return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args));
1272	},
1273	clear(selectorName, args) {
1274	if (cache[selectorName]) {
1275	cache[selectorName].delete(trimUndefinedValues(args));
1276	}
1277	},
1278	markAsRunning(selectorName, args) {
1279	if (!cache[selectorName]) {
1280	cache[selectorName] = new import_equivalent_key_map2.default();
1281	}
1282	cache[selectorName].set(trimUndefinedValues(args), true);
1283	}
1284	};
1285	}
1286	function createBindingCache(getItem, bindItem) {
1287	const cache = /* @__PURE__ */ new WeakMap();
1288	return {
1289	get(itemName) {
1290	const item = getItem(itemName);
1291	if (!item) {
1292	return null;
1293	}
1294	let boundItem = cache.get(item);
1295	if (!boundItem) {
1296	boundItem = bindItem(item, itemName);
1297	cache.set(item, boundItem);
1298	}
1299	return boundItem;
1300	}
1301	};
1302	}
1303	function createPrivateProxy(publicItems, privateItems) {
1304	return new Proxy(publicItems, {
1305	get: (target, itemName) => privateItems.get(itemName) \|\| Reflect.get(target, itemName)
1306	});
1307	}
1308	function createReduxStore(key, options) {
1309	const privateActions = {};
1310	const privateSelectors = {};
1311	const privateRegistrationFunctions = {
1312	privateActions,
1313	registerPrivateActions: (actions) => {
1314	Object.assign(privateActions, actions);
1315	},
1316	privateSelectors,
1317	registerPrivateSelectors: (selectors) => {
1318	Object.assign(privateSelectors, selectors);
1319	}
1320	};
1321	const storeDescriptor = {
1322	name: key,
1323	instantiate: (registry) => {
1324	const listeners = /* @__PURE__ */ new Set();
1325	const reducer = options.reducer;
1326	const thunkArgs = {
1327	registry,
1328	get dispatch() {
1329	return thunkDispatch;
1330	},
1331	get select() {
1332	return thunkSelect;
1333	},
1334	get resolveSelect() {
1335	return resolveSelectors;
1336	}
1337	};
1338	const store = instantiateReduxStore(
1339	key,
1340	options,
1341	registry,
1342	thunkArgs
1343	);
1344	lock(store, privateRegistrationFunctions);
1345	const resolversCache = createResolversCache();
1346	function bindAction(action) {
1347	return (...args) => Promise.resolve(store.dispatch(action(...args)));
1348	}
1349	const actions = {
1350	...mapValues(actions_exports, bindAction),
1351	...mapValues(options.actions, bindAction)
1352	};
1353	const allActions = createPrivateProxy(
1354	actions,
1355	createBindingCache(
1356	(name) => privateActions[name],
1357	bindAction
1358	)
1359	);
1360	const thunkDispatch = new Proxy(
1361	(action) => store.dispatch(action),
1362	{ get: (target, name) => allActions[name] }
1363	);
1364	lock(actions, allActions);
1365	const resolvers = options.resolvers ? mapValues(options.resolvers, mapResolver) : {};
1366	function bindSelector(selector, selectorName) {
1367	if (selector.isRegistrySelector) {
1368	selector.registry = registry;
1369	}
1370	const boundSelector = (...args) => {
1371	args = normalize(selector, args);
1372	const state = store.__unstableOriginalGetState();
1373	if (selector.isRegistrySelector) {
1374	selector.registry = registry;
1375	}
1376	return selector(state.root, ...args);
1377	};
1378	boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
1379	const resolver = resolvers[selectorName];
1380	if (!resolver) {
1381	boundSelector.hasResolver = false;
1382	return boundSelector;
1383	}
1384	return mapSelectorWithResolver(
1385	boundSelector,
1386	selectorName,
1387	resolver,
1388	store,
1389	resolversCache,
1390	boundMetadataSelectors
1391	);
1392	}
1393	function bindMetadataSelector(metaDataSelector) {
1394	const boundSelector = (selectorName, selectorArgs, ...args) => {
1395	if (selectorName) {
1396	const targetSelector = options.selectors?.[selectorName];
1397	if (targetSelector) {
1398	selectorArgs = normalize(
1399	targetSelector,
1400	selectorArgs
1401	);
1402	}
1403	}
1404	const state = store.__unstableOriginalGetState();
1405	return metaDataSelector(
1406	state.metadata,
1407	selectorName,
1408	selectorArgs,
1409	...args
1410	);
1411	};
1412	boundSelector.hasResolver = false;
1413	return boundSelector;
1414	}
1415	const boundMetadataSelectors = mapValues(
1416	selectors_exports,
1417	bindMetadataSelector
1418	);
1419	const boundSelectors = mapValues(options.selectors, bindSelector);
1420	const selectors = {
1421	...boundMetadataSelectors,
1422	...boundSelectors
1423	};
1424	const boundPrivateSelectors = createBindingCache(
1425	(name) => privateSelectors[name],
1426	bindSelector
1427	);
1428	const allSelectors = createPrivateProxy(
1429	selectors,
1430	boundPrivateSelectors
1431	);
1432	for (const selectorName of Object.keys(privateSelectors)) {
1433	boundPrivateSelectors.get(selectorName);
1434	}
1435	const thunkSelect = new Proxy(
1436	(selector) => selector(store.__unstableOriginalGetState()),
1437	{ get: (target, name) => allSelectors[name] }
1438	);
1439	lock(selectors, allSelectors);
1440	const bindResolveSelector = mapResolveSelector(
1441	store,
1442	boundMetadataSelectors
1443	);
1444	const resolveSelectors = mapValues(
1445	boundSelectors,
1446	bindResolveSelector
1447	);
1448	const allResolveSelectors = createPrivateProxy(
1449	resolveSelectors,
1450	createBindingCache(
1451	(name) => boundPrivateSelectors.get(name),
1452	bindResolveSelector
1453	)
1454	);
1455	lock(resolveSelectors, allResolveSelectors);
1456	const bindSuspendSelector = mapSuspendSelector(
1457	store,
1458	boundMetadataSelectors
1459	);
1460	const suspendSelectors = {
1461	...boundMetadataSelectors,
1462	// no special suspense behavior
1463	...mapValues(boundSelectors, bindSuspendSelector)
1464	};
1465	const allSuspendSelectors = createPrivateProxy(
1466	suspendSelectors,
1467	createBindingCache(
1468	(name) => boundPrivateSelectors.get(name),
1469	bindSuspendSelector
1470	)
1471	);
1472	lock(suspendSelectors, allSuspendSelectors);
1473	const getSelectors = () => selectors;
1474	const getActions = () => actions;
1475	const getResolveSelectors = () => resolveSelectors;
1476	const getSuspendSelectors = () => suspendSelectors;
1477	store.__unstableOriginalGetState = store.getState;
1478	store.getState = () => store.__unstableOriginalGetState().root;
1479	const subscribe2 = store && ((listener) => {
1480	listeners.add(listener);
1481	return () => listeners.delete(listener);
1482	});
1483	let lastState = store.__unstableOriginalGetState();
1484	store.subscribe(() => {
1485	const state = store.__unstableOriginalGetState();
1486	const hasChanged = state !== lastState;
1487	lastState = state;
1488	if (hasChanged) {
1489	for (const listener of listeners) {
1490	listener();
1491	}
1492	}
1493	});
1494	return {
1495	reducer,
1496	store,
1497	actions,
1498	selectors,
1499	resolvers,
1500	getSelectors,
1501	getResolveSelectors,
1502	getSuspendSelectors,
1503	getActions,
1504	subscribe: subscribe2
1505	};
1506	}
1507	};
1508	lock(storeDescriptor, privateRegistrationFunctions);
1509	return storeDescriptor;
1510	}
1511	function instantiateReduxStore(key, options, registry, thunkArgs) {
1512	const controls2 = {
1513	...options.controls,
1514	...builtinControls
1515	};
1516	const normalizedControls = mapValues(
1517	controls2,
1518	(control) => control.isRegistryControl ? control(registry) : control
1519	);
1520	const middlewares = [
1521	resolvers_cache_middleware_default(registry, key),
1522	promise_middleware_default,
1523	(0, import_redux_routine.default)(normalizedControls),
1524	createThunkMiddleware(thunkArgs)
1525	];
1526	const enhancers = [applyMiddleware(...middlewares)];
1527	if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
1528	enhancers.push(
1529	window.__REDUX_DEVTOOLS_EXTENSION__({
1530	name: key,
1531	instanceId: key,
1532	serialize: {
1533	replacer: devToolsReplacer
1534	}
1535	})
1536	);
1537	}
1538	const { reducer, initialState } = options;
1539	const enhancedReducer = combineReducers({
1540	metadata: reducer_default,
1541	root: reducer
1542	});
1543	return createStore(
1544	enhancedReducer,
1545	{ root: initialState },
1546	(0, import_compose.compose)(enhancers)
1547	);
1548	}
1549	function mapResolveSelector(store, boundMetadataSelectors) {
1550	return (selector, selectorName) => {
1551	if (!selector.hasResolver) {
1552	return async (...args) => selector.apply(null, args);
1553	}
1554	return (...args) => new Promise((resolve, reject) => {
1555	const hasFinished = () => {
1556	return boundMetadataSelectors.hasFinishedResolution(
1557	selectorName,
1558	args
1559	);
1560	};
1561	const finalize = (result2) => {
1562	const hasFailed = boundMetadataSelectors.hasResolutionFailed(
1563	selectorName,
1564	args
1565	);
1566	if (hasFailed) {
1567	const error = boundMetadataSelectors.getResolutionError(
1568	selectorName,
1569	args
1570	);
1571	reject(error);
1572	} else {
1573	resolve(result2);
1574	}
1575	};
1576	const getResult = () => selector.apply(null, args);
1577	const result = getResult();
1578	if (hasFinished()) {
1579	return finalize(result);
1580	}
1581	const unsubscribe = store.subscribe(() => {
1582	if (hasFinished()) {
1583	unsubscribe();
1584	finalize(getResult());
1585	}
1586	});
1587	});
1588	};
1589	}
1590	function mapSuspendSelector(store, boundMetadataSelectors) {
1591	return (selector, selectorName) => {
1592	if (!selector.hasResolver) {
1593	return selector;
1594	}
1595	return (...args) => {
1596	const result = selector.apply(null, args);
1597	if (boundMetadataSelectors.hasFinishedResolution(
1598	selectorName,
1599	args
1600	)) {
1601	if (boundMetadataSelectors.hasResolutionFailed(
1602	selectorName,
1603	args
1604	)) {
1605	throw boundMetadataSelectors.getResolutionError(
1606	selectorName,
1607	args
1608	);
1609	}
1610	return result;
1611	}
1612	throw new Promise((resolve) => {
1613	const unsubscribe = store.subscribe(() => {
1614	if (boundMetadataSelectors.hasFinishedResolution(
1615	selectorName,
1616	args
1617	)) {
1618	resolve();
1619	unsubscribe();
1620	}
1621	});
1622	});
1623	};
1624	};
1625	}
1626	function mapResolver(resolver) {
1627	if (resolver.fulfill) {
1628	return resolver;
1629	}
1630	return {
1631	...resolver,
1632	// Copy the enumerable properties of the resolver function.
1633	fulfill: resolver
1634	// Add the fulfill method.
1635	};
1636	}
1637	function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
1638	function fulfillSelector(args) {
1639	if (resolversCache.isRunning(selectorName, args) \|\| boundMetadataSelectors.hasStartedResolution(selectorName, args)) {
1640	return;
1641	}
1642	resolversCache.markAsRunning(selectorName, args);
1643	setTimeout(async () => {
1644	resolversCache.clear(selectorName, args);
1645	store.dispatch(
1646	startResolution(selectorName, args)
1647	);
1648	try {
1649	const isFulfilled = typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args);
1650	if (!isFulfilled) {
1651	const action = resolver.fulfill(...args);
1652	if (action) {
1653	await store.dispatch(action);
1654	}
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.mjs
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.mjs
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.mjs
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.mjs
1991	var default_registry_default = createRegistry();
1992
1993	// packages/data/build-module/plugins/index.mjs
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.mjs
2017	var import_deepmerge = __toESM(require_cjs(), 1);
2018
2019	// packages/data/build-module/plugins/persistence/storage/object.mjs
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.mjs
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.mjs
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.mjs
2156	var import_compose2 = __toESM(require_compose(), 1);
2157
2158	// packages/data/build-module/components/use-select/index.mjs
2159	var import_priority_queue = __toESM(require_priority_queue(), 1);
2160	var import_element5 = __toESM(require_element(), 1);
2161	var import_is_shallow_equal = __toESM(require_is_shallow_equal(), 1);
2162
2163	// packages/data/build-module/components/registry-provider/use-registry.mjs
2164	var import_element2 = __toESM(require_element(), 1);
2165
2166	// packages/data/build-module/components/registry-provider/context.mjs
2167	var import_element = __toESM(require_element(), 1);
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.mjs
2175	function useRegistry() {
2176	return (0, import_element2.useContext)(Context);
2177	}
2178
2179	// packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2180	var import_element4 = __toESM(require_element(), 1);
2181
2182	// packages/data/build-module/components/async-mode-provider/context.mjs
2183	var import_element3 = __toESM(require_element(), 1);
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.mjs
2190	function useAsyncMode() {
2191	return (0, import_element4.useContext)(Context2);
2192	}
2193
2194	// packages/data/build-module/components/use-select/index.mjs
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.isShallowEqual)(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.isShallowEqual)(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.mjs
2350	var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
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.mjs
2362	var import_compose4 = __toESM(require_compose(), 1);
2363
2364	// packages/data/build-module/components/use-dispatch/use-dispatch.mjs
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.mjs
2372	var import_element6 = __toESM(require_element(), 1);
2373	var import_compose3 = __toESM(require_compose(), 1);
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.mjs
2405	var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
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.mjs
2417	var import_compose5 = __toESM(require_compose(), 1);
2418	var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
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.mjs
2426	function dispatch2(storeNameOrDescriptor) {
2427	return default_registry_default.dispatch(storeNameOrDescriptor);
2428	}
2429
2430	// packages/data/build-module/select.mjs
2431	function select2(storeNameOrDescriptor) {
2432	return default_registry_default.select(storeNameOrDescriptor);
2433	}
2434
2435	// packages/data/build-module/index.mjs
2436	var defaultRegistry = default_registry_default;
2437	var combineReducers2 = combineReducers;
2438	function resolveSelect2(storeNameOrDescriptor) {
2439	return defaultRegistry.resolveSelect(storeNameOrDescriptor);
2440	}
2441	var suspendSelect = (storeNameOrDescriptor) => defaultRegistry.suspendSelect(storeNameOrDescriptor);
2442	var subscribe = (listener, storeNameOrDescriptor) => defaultRegistry.subscribe(listener, storeNameOrDescriptor);
2443	var registerGenericStore = defaultRegistry.registerGenericStore;
2444	var registerStore = defaultRegistry.registerStore;
2445	var use = defaultRegistry.use;
2446	var register = (store) => defaultRegistry.register(store);
2447	return __toCommonJS(index_exports);
2448	})();
2449	/*! Bundled license information:
2450
2451	is-plain-object/dist/is-plain-object.mjs:
2452	(*!
2453	* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
2454	*
2455	* Copyright (c) 2014-2017, Jon Schlinkert.
2456	* Released under the MIT License.
2457	*)
2458	*/
2459	//# sourceMappingURL=index.js.map
2460