Gutenberg / 22.9.0

Gutenberg v22.9.0

gutenberg / build / scripts / data / index.js

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

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