Gutenberg / 23.1.1

Gutenberg v23.1.1

gutenberg / build / scripts / data / index.js

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

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