Gutenberg / 23.3.0

Gutenberg v23.3.0

gutenberg / build / scripts / data / index.js

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

2,499 lines 83.4 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	resolvers,
1467	boundMetadataSelectors
1468	);
1469	const resolveSelectors = mapValues(
1470	boundSelectors,
1471	bindResolveSelector
1472	);
1473	const allResolveSelectors = createPrivateProxy(
1474	resolveSelectors,
1475	createBindingCache(
1476	(name) => boundPrivateSelectors.get(name),
1477	bindResolveSelector
1478	)
1479	);
1480	lock(resolveSelectors, allResolveSelectors);
1481	const bindSuspendSelector = mapSuspendSelector(
1482	store,
1483	boundMetadataSelectors
1484	);
1485	const suspendSelectors = {
1486	...boundMetadataSelectors,
1487	// no special suspense behavior
1488	...mapValues(boundSelectors, bindSuspendSelector)
1489	};
1490	const allSuspendSelectors = createPrivateProxy(
1491	suspendSelectors,
1492	createBindingCache(
1493	(name) => boundPrivateSelectors.get(name),
1494	bindSuspendSelector
1495	)
1496	);
1497	lock(suspendSelectors, allSuspendSelectors);
1498	const getSelectors = () => selectors;
1499	const getActions = () => actions;
1500	const getResolveSelectors = () => resolveSelectors;
1501	const getSuspendSelectors = () => suspendSelectors;
1502	store.__unstableOriginalGetState = store.getState;
1503	store.getState = () => store.__unstableOriginalGetState().root;
1504	const subscribe2 = (listener) => {
1505	listeners.add(listener);
1506	return () => listeners.delete(listener);
1507	};
1508	let lastState = store.__unstableOriginalGetState();
1509	store.subscribe(() => {
1510	const state = store.__unstableOriginalGetState();
1511	const hasChanged = state !== lastState;
1512	lastState = state;
1513	if (hasChanged) {
1514	for (const listener of listeners) {
1515	listener();
1516	}
1517	}
1518	});
1519	return {
1520	reducer,
1521	store,
1522	actions,
1523	selectors,
1524	resolvers,
1525	getSelectors,
1526	getResolveSelectors,
1527	getSuspendSelectors,
1528	getActions,
1529	subscribe: subscribe2
1530	};
1531	}
1532	};
1533	lock(storeDescriptor, privateRegistrationFunctions);
1534	return storeDescriptor;
1535	}
1536	function instantiateReduxStore(key, options, registry, thunkArgs) {
1537	const controls2 = {
1538	...options.controls,
1539	...builtinControls
1540	};
1541	const normalizedControls = mapValues(
1542	controls2,
1543	(control) => control.isRegistryControl ? control(registry) : control
1544	);
1545	const middlewares = [
1546	resolvers_cache_middleware_default(registry, key),
1547	promise_middleware_default,
1548	(0, import_redux_routine.default)(normalizedControls),
1549	createThunkMiddleware(thunkArgs)
1550	];
1551	const enhancers = [applyMiddleware(...middlewares)];
1552	if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
1553	enhancers.push(
1554	window.__REDUX_DEVTOOLS_EXTENSION__({
1555	name: key,
1556	instanceId: key,
1557	serialize: {
1558	replacer: devToolsReplacer
1559	}
1560	})
1561	);
1562	}
1563	const { reducer, initialState } = options;
1564	const enhancedReducer = combineReducers({
1565	metadata: reducer_default,
1566	root: reducer
1567	});
1568	return createStore(
1569	enhancedReducer,
1570	{ root: initialState },
1571	(0, import_compose.compose)(...enhancers)
1572	);
1573	}
1574	function mapResolveSelector(store, resolvers, boundMetadataSelectors) {
1575	return (selector, selectorName) => {
1576	if (!selector.hasResolver) {
1577	return async (...args) => selector(...args);
1578	}
1579	return (...args) => new Promise((resolve, reject) => {
1580	const resolver = resolvers[selectorName];
1581	const hasFinished = () => {
1582	return boundMetadataSelectors.hasFinishedResolution(
1583	selectorName,
1584	args
1585	) \|\| typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args);
1586	};
1587	const finalize = (result2) => {
1588	const hasFailed = boundMetadataSelectors.hasResolutionFailed(
1589	selectorName,
1590	args
1591	);
1592	if (hasFailed) {
1593	const error = boundMetadataSelectors.getResolutionError(
1594	selectorName,
1595	args
1596	);
1597	reject(error);
1598	} else {
1599	resolve(result2);
1600	}
1601	};
1602	const getResult = () => selector(...args);
1603	const result = getResult();
1604	if (hasFinished()) {
1605	return finalize(result);
1606	}
1607	const unsubscribe = store.subscribe(() => {
1608	if (hasFinished()) {
1609	unsubscribe();
1610	finalize(getResult());
1611	}
1612	});
1613	});
1614	};
1615	}
1616	function mapSuspendSelector(store, boundMetadataSelectors) {
1617	return (selector, selectorName) => {
1618	if (!selector.hasResolver) {
1619	return selector;
1620	}
1621	return (...args) => {
1622	const result = selector(...args);
1623	if (boundMetadataSelectors.hasFinishedResolution(
1624	selectorName,
1625	args
1626	)) {
1627	if (boundMetadataSelectors.hasResolutionFailed(
1628	selectorName,
1629	args
1630	)) {
1631	throw boundMetadataSelectors.getResolutionError(
1632	selectorName,
1633	args
1634	);
1635	}
1636	return result;
1637	}
1638	throw new Promise((resolve) => {
1639	const unsubscribe = store.subscribe(() => {
1640	if (boundMetadataSelectors.hasFinishedResolution(
1641	selectorName,
1642	args
1643	)) {
1644	resolve();
1645	unsubscribe();
1646	}
1647	});
1648	});
1649	};
1650	};
1651	}
1652	function mapResolver(resolver) {
1653	if (resolver.fulfill) {
1654	return resolver;
1655	}
1656	return {
1657	...resolver,
1658	// Copy the enumerable properties of the resolver function.
1659	fulfill: resolver
1660	// Add the fulfill method.
1661	};
1662	}
1663	function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
1664	function fulfillSelector(args) {
1665	if (resolversCache.isRunning(selectorName, args) \|\| boundMetadataSelectors.hasStartedResolution(selectorName, args) \|\| typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args)) {
1666	return;
1667	}
1668	resolversCache.markAsRunning(selectorName, args);
1669	setTimeout(async () => {
1670	resolversCache.clear(selectorName, args);
1671	store.dispatch(
1672	startResolution(selectorName, args)
1673	);
1674	try {
1675	const action = resolver.fulfill(...args);
1676	if (action) {
1677	await store.dispatch(action);
1678	}
1679	store.dispatch(
1680	finishResolution(selectorName, args)
1681	);
1682	} catch (error) {
1683	store.dispatch(
1684	failResolution(selectorName, args, error)
1685	);
1686	}
1687	}, 0);
1688	}
1689	const selectorResolver = (...args) => {
1690	args = normalize(selector, args);
1691	fulfillSelector(args);
1692	return selector(...args);
1693	};
1694	selectorResolver.hasResolver = true;
1695	return selectorResolver;
1696	}
1697	function normalize(selector, args) {
1698	if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) {
1699	return selector.__unstableNormalizeArgs(args);
1700	}
1701	return args;
1702	}
1703
1704	// packages/data/build-module/store/index.mjs
1705	var coreDataStore = {
1706	name: "core/data",
1707	instantiate(registry) {
1708	const getCoreDataSelector = (selectorName) => (key, ...args) => {
1709	return registry.select(key)[selectorName](...args);
1710	};
1711	const getCoreDataAction = (actionName) => (key, ...args) => {
1712	return registry.dispatch(key)[actionName](...args);
1713	};
1714	return {
1715	getSelectors() {
1716	return Object.fromEntries(
1717	[
1718	"getIsResolving",
1719	"hasStartedResolution",
1720	"hasFinishedResolution",
1721	"isResolving",
1722	"getCachedResolvers"
1723	].map((selectorName) => [
1724	selectorName,
1725	getCoreDataSelector(selectorName)
1726	])
1727	);
1728	},
1729	getActions() {
1730	return Object.fromEntries(
1731	[
1732	"startResolution",
1733	"finishResolution",
1734	"invalidateResolution",
1735	"invalidateResolutionForStore",
1736	"invalidateResolutionForStoreSelector"
1737	].map((actionName) => [
1738	actionName,
1739	getCoreDataAction(actionName)
1740	])
1741	);
1742	},
1743	subscribe() {
1744	return () => () => {
1745	};
1746	}
1747	};
1748	}
1749	};
1750	var store_default = coreDataStore;
1751
1752	// packages/data/build-module/utils/emitter.mjs
1753	function createEmitter() {
1754	let isPaused = false;
1755	let isPending = false;
1756	const listeners = /* @__PURE__ */ new Set();
1757	const notifyListeners = () => (
1758	// We use Array.from to clone the listeners Set
1759	// This ensures that we don't run a listener
1760	// that was added as a response to another listener.
1761	Array.from(listeners).forEach((listener) => listener())
1762	);
1763	return {
1764	get isPaused() {
1765	return isPaused;
1766	},
1767	subscribe(listener) {
1768	listeners.add(listener);
1769	return () => listeners.delete(listener);
1770	},
1771	pause() {
1772	isPaused = true;
1773	},
1774	resume() {
1775	isPaused = false;
1776	if (isPending) {
1777	isPending = false;
1778	notifyListeners();
1779	}
1780	},
1781	emit() {
1782	if (isPaused) {
1783	isPending = true;
1784	return;
1785	}
1786	notifyListeners();
1787	}
1788	};
1789	}
1790
1791	// packages/data/build-module/registry.mjs
1792	function getStoreName(storeNameOrDescriptor) {
1793	return typeof storeNameOrDescriptor === "string" ? storeNameOrDescriptor : storeNameOrDescriptor.name;
1794	}
1795	function createRegistry(storeConfigs = {}, parent = null) {
1796	const stores = {};
1797	const emitter = createEmitter();
1798	let listeningStores = null;
1799	function globalListener() {
1800	emitter.emit();
1801	}
1802	const subscribe2 = (listener, storeNameOrDescriptor) => {
1803	if (!storeNameOrDescriptor) {
1804	return emitter.subscribe(listener);
1805	}
1806	const storeName = getStoreName(storeNameOrDescriptor);
1807	const store = stores[storeName];
1808	if (store) {
1809	return store.subscribe(listener);
1810	}
1811	if (!parent) {
1812	return emitter.subscribe(listener);
1813	}
1814	return parent.subscribe(listener, storeNameOrDescriptor);
1815	};
1816	function select3(storeNameOrDescriptor) {
1817	const storeName = getStoreName(storeNameOrDescriptor);
1818	listeningStores?.add(storeName);
1819	const store = stores[storeName];
1820	if (store) {
1821	return store.getSelectors();
1822	}
1823	return parent?.select(storeName);
1824	}
1825	function __unstableMarkListeningStores(callback, ref) {
1826	listeningStores = /* @__PURE__ */ new Set();
1827	try {
1828	return callback.call(this);
1829	} finally {
1830	ref.current = Array.from(listeningStores);
1831	listeningStores = null;
1832	}
1833	}
1834	function resolveSelect3(storeNameOrDescriptor) {
1835	const storeName = getStoreName(storeNameOrDescriptor);
1836	listeningStores?.add(storeName);
1837	const store = stores[storeName];
1838	if (store) {
1839	return store.getResolveSelectors();
1840	}
1841	return parent && parent.resolveSelect(storeName);
1842	}
1843	function suspendSelect2(storeNameOrDescriptor) {
1844	const storeName = getStoreName(storeNameOrDescriptor);
1845	listeningStores?.add(storeName);
1846	const store = stores[storeName];
1847	if (store) {
1848	return store.getSuspendSelectors();
1849	}
1850	return parent && parent.suspendSelect(storeName);
1851	}
1852	function dispatch3(storeNameOrDescriptor) {
1853	const storeName = getStoreName(storeNameOrDescriptor);
1854	const store = stores[storeName];
1855	if (store) {
1856	return store.getActions();
1857	}
1858	return parent && parent.dispatch(storeName);
1859	}
1860	function withPlugins(attributes) {
1861	return Object.fromEntries(
1862	Object.entries(attributes).map(([key, attribute]) => {
1863	if (typeof attribute !== "function") {
1864	return [key, attribute];
1865	}
1866	return [
1867	key,
1868	(...args) => {
1869	return registry[key](...args);
1870	}
1871	];
1872	})
1873	);
1874	}
1875	function registerStoreInstance(name, createStoreFunc) {
1876	if (stores[name]) {
1877	console.error('Store "' + name + '" is already registered.');
1878	return stores[name];
1879	}
1880	const store = createStoreFunc();
1881	if (typeof store.getSelectors !== "function") {
1882	throw new TypeError("store.getSelectors must be a function");
1883	}
1884	if (typeof store.getActions !== "function") {
1885	throw new TypeError("store.getActions must be a function");
1886	}
1887	if (typeof store.subscribe !== "function") {
1888	throw new TypeError("store.subscribe must be a function");
1889	}
1890	store.emitter = createEmitter();
1891	const currentSubscribe = store.subscribe;
1892	store.subscribe = (listener) => {
1893	const unsubscribeFromEmitter = store.emitter.subscribe(listener);
1894	const unsubscribeFromStore = currentSubscribe(() => {
1895	if (store.emitter.isPaused) {
1896	store.emitter.emit();
1897	return;
1898	}
1899	listener();
1900	});
1901	return () => {
1902	unsubscribeFromStore?.();
1903	unsubscribeFromEmitter?.();
1904	};
1905	};
1906	stores[name] = store;
1907	store.subscribe(globalListener);
1908	if (parent) {
1909	try {
1910	unlock(store.store).registerPrivateActions(
1911	unlock(parent).privateActionsOf(name)
1912	);
1913	unlock(store.store).registerPrivateSelectors(
1914	unlock(parent).privateSelectorsOf(name)
1915	);
1916	} catch {
1917	}
1918	}
1919	return store;
1920	}
1921	function register2(store) {
1922	registerStoreInstance(
1923	store.name,
1924	() => store.instantiate(registry)
1925	);
1926	}
1927	function registerGenericStore2(name, store) {
1928	(0, import_deprecated2.default)("wp.data.registerGenericStore", {
1929	since: "5.9",
1930	alternative: "wp.data.register( storeDescriptor )"
1931	});
1932	registerStoreInstance(name, () => store);
1933	}
1934	function registerStore2(storeName, options) {
1935	if (!options.reducer) {
1936	throw new TypeError("Must specify store reducer");
1937	}
1938	const store = registerStoreInstance(
1939	storeName,
1940	() => createReduxStore(storeName, options).instantiate(
1941	registry
1942	)
1943	);
1944	return store.store;
1945	}
1946	function batch(callback) {
1947	if (emitter.isPaused) {
1948	callback();
1949	return;
1950	}
1951	emitter.pause();
1952	Object.values(stores).forEach((store) => store.emitter.pause());
1953	try {
1954	callback();
1955	} finally {
1956	emitter.resume();
1957	Object.values(stores).forEach(
1958	(store) => store.emitter.resume()
1959	);
1960	}
1961	}
1962	let registry = {
1963	batch,
1964	stores,
1965	namespaces: stores,
1966	// TODO: Deprecate/remove this.
1967	subscribe: subscribe2,
1968	select: select3,
1969	resolveSelect: resolveSelect3,
1970	suspendSelect: suspendSelect2,
1971	dispatch: dispatch3,
1972	use: use2,
1973	register: register2,
1974	registerGenericStore: registerGenericStore2,
1975	registerStore: registerStore2,
1976	__unstableMarkListeningStores
1977	};
1978	function use2(plugin, options) {
1979	if (!plugin) {
1980	return;
1981	}
1982	registry = {
1983	...registry,
1984	...plugin(registry, options)
1985	};
1986	return registry;
1987	}
1988	registry.register(store_default);
1989	for (const [name, config] of Object.entries(storeConfigs)) {
1990	registry.register(createReduxStore(name, config));
1991	}
1992	if (parent) {
1993	parent.subscribe(globalListener);
1994	}
1995	const registryWithPlugins = withPlugins(
1996	registry
1997	);
1998	lock(registryWithPlugins, {
1999	privateActionsOf: (name) => {
2000	try {
2001	return unlock(stores[name].store).privateActions;
2002	} catch {
2003	return {};
2004	}
2005	},
2006	privateSelectorsOf: (name) => {
2007	try {
2008	return unlock(stores[name].store).privateSelectors;
2009	} catch {
2010	return {};
2011	}
2012	}
2013	});
2014	return registryWithPlugins;
2015	}
2016
2017	// packages/data/build-module/default-registry.mjs
2018	var defaultRegistry = createRegistry();
2019	var default_registry_default = defaultRegistry;
2020
2021	// packages/data/build-module/plugins/index.mjs
2022	var plugins_exports = {};
2023	__export(plugins_exports, {
2024	persistence: () => persistence_default
2025	});
2026
2027	// node_modules/is-plain-object/dist/is-plain-object.mjs
2028	function isObject(o) {
2029	return Object.prototype.toString.call(o) === "[object Object]";
2030	}
2031	function isPlainObject2(o) {
2032	var ctor, prot;
2033	if (isObject(o) === false) return false;
2034	ctor = o.constructor;
2035	if (ctor === void 0) return true;
2036	prot = ctor.prototype;
2037	if (isObject(prot) === false) return false;
2038	if (prot.hasOwnProperty("isPrototypeOf") === false) {
2039	return false;
2040	}
2041	return true;
2042	}
2043
2044	// packages/data/build-module/plugins/persistence/index.mjs
2045	var import_deepmerge = __toESM(require_cjs(), 1);
2046
2047	// packages/data/build-module/plugins/persistence/storage/object.mjs
2048	var objectStorage;
2049	var storage = {
2050	getItem(key) {
2051	if (!objectStorage \|\| !objectStorage[key]) {
2052	return null;
2053	}
2054	return objectStorage[key];
2055	},
2056	setItem(key, value) {
2057	if (!objectStorage) {
2058	storage.clear();
2059	}
2060	objectStorage[key] = String(value);
2061	},
2062	clear() {
2063	objectStorage = /* @__PURE__ */ Object.create(null);
2064	}
2065	};
2066	var object_default = storage;
2067
2068	// packages/data/build-module/plugins/persistence/storage/default.mjs
2069	var storage2;
2070	try {
2071	storage2 = window.localStorage;
2072	storage2.setItem("__wpDataTestLocalStorage", "");
2073	storage2.removeItem("__wpDataTestLocalStorage");
2074	} catch {
2075	storage2 = object_default;
2076	}
2077	var default_default = storage2;
2078
2079	// packages/data/build-module/plugins/persistence/index.mjs
2080	var DEFAULT_STORAGE = default_default;
2081	var DEFAULT_STORAGE_KEY = "WP_DATA";
2082	var withLazySameState = (reducer) => (state, action) => {
2083	if (action.nextState === state) {
2084	return state;
2085	}
2086	return reducer(state, action);
2087	};
2088	function createPersistenceInterface(options) {
2089	const { storage: storage3 = DEFAULT_STORAGE, storageKey = DEFAULT_STORAGE_KEY } = options;
2090	let data;
2091	function getData() {
2092	if (data === void 0) {
2093	const persisted = storage3.getItem(storageKey);
2094	if (persisted === null) {
2095	data = {};
2096	} else {
2097	try {
2098	data = JSON.parse(persisted);
2099	} catch {
2100	data = {};
2101	}
2102	}
2103	}
2104	return data;
2105	}
2106	function setData(key, value) {
2107	data = { ...data, [key]: value };
2108	storage3.setItem(storageKey, JSON.stringify(data));
2109	}
2110	return {
2111	get: getData,
2112	set: setData
2113	};
2114	}
2115	function persistencePlugin(registry, pluginOptions) {
2116	const persistence = createPersistenceInterface(pluginOptions);
2117	function createPersistOnChange(getState, storeName, keys) {
2118	let getPersistedState;
2119	if (Array.isArray(keys)) {
2120	const reducers = keys.reduce(
2121	(accumulator, key) => Object.assign(accumulator, {
2122	[key]: (state, action) => action.nextState[key]
2123	}),
2124	{}
2125	);
2126	getPersistedState = withLazySameState(
2127	combineReducers2(reducers)
2128	);
2129	} else {
2130	getPersistedState = (_state, action) => action.nextState;
2131	}
2132	let lastState = getPersistedState(void 0, {
2133	nextState: getState()
2134	});
2135	return () => {
2136	const state = getPersistedState(lastState, {
2137	nextState: getState()
2138	});
2139	if (state !== lastState) {
2140	persistence.set(storeName, state);
2141	lastState = state;
2142	}
2143	};
2144	}
2145	return {
2146	registerStore(storeName, options) {
2147	if (!options.persist) {
2148	return registry.registerStore(storeName, options);
2149	}
2150	const persistedState = persistence.get()[storeName];
2151	if (persistedState !== void 0) {
2152	let initialState = options.reducer(options.initialState, {
2153	type: "@@WP/PERSISTENCE_RESTORE"
2154	});
2155	if (isPlainObject2(initialState) && isPlainObject2(persistedState)) {
2156	initialState = (0, import_deepmerge.default)(
2157	initialState,
2158	persistedState,
2159	{
2160	isMergeableObject: isPlainObject2
2161	}
2162	);
2163	} else {
2164	initialState = persistedState;
2165	}
2166	options = {
2167	...options,
2168	initialState
2169	};
2170	}
2171	const store = registry.registerStore(storeName, options);
2172	store.subscribe(
2173	createPersistOnChange(
2174	store.getState,
2175	storeName,
2176	options.persist
2177	)
2178	);
2179	return store;
2180	}
2181	};
2182	}
2183	var persistence_default = Object.assign(persistencePlugin, {
2184	__unstableMigrate: () => {
2185	}
2186	});
2187
2188	// packages/data/build-module/components/with-select/index.mjs
2189	var import_compose2 = __toESM(require_compose(), 1);
2190
2191	// packages/data/build-module/components/use-select/index.mjs
2192	var import_priority_queue = __toESM(require_priority_queue(), 1);
2193	var import_element5 = __toESM(require_element(), 1);
2194	var import_is_shallow_equal = __toESM(require_is_shallow_equal(), 1);
2195
2196	// packages/data/build-module/components/registry-provider/use-registry.mjs
2197	var import_element2 = __toESM(require_element(), 1);
2198
2199	// packages/data/build-module/components/registry-provider/context.mjs
2200	var import_element = __toESM(require_element(), 1);
2201	var Context = (0, import_element.createContext)(default_registry_default);
2202	Context.displayName = "RegistryProviderContext";
2203	var { Consumer, Provider } = Context;
2204	var RegistryConsumer = Consumer;
2205	var context_default = Provider;
2206
2207	// packages/data/build-module/components/registry-provider/use-registry.mjs
2208	function useRegistry() {
2209	return (0, import_element2.useContext)(Context);
2210	}
2211
2212	// packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2213	var import_element4 = __toESM(require_element(), 1);
2214
2215	// packages/data/build-module/components/async-mode-provider/context.mjs
2216	var import_element3 = __toESM(require_element(), 1);
2217	var Context2 = (0, import_element3.createContext)(false);
2218	Context2.displayName = "AsyncModeContext";
2219	var { Consumer: Consumer2, Provider: Provider2 } = Context2;
2220	var context_default2 = Provider2;
2221
2222	// packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2223	function useAsyncMode() {
2224	return (0, import_element4.useContext)(Context2);
2225	}
2226
2227	// packages/data/build-module/components/use-select/index.mjs
2228	var renderQueue = (0, import_priority_queue.createQueue)();
2229	function warnOnUnstableReference(a, b) {
2230	if (!a \|\| !b) {
2231	return;
2232	}
2233	const keys = typeof a === "object" && typeof b === "object" ? Object.keys(a).filter((k) => a[k] !== b[k]) : [];
2234	console.warn(
2235	"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",
2236	keys.join(", ")
2237	);
2238	}
2239	function Store(registry, suspense) {
2240	const select3 = suspense ? registry.suspendSelect : registry.select;
2241	const queueContext = {};
2242	let lastMapSelect;
2243	let lastMapResult;
2244	let lastMapResultValid = false;
2245	let lastIsAsync;
2246	let subscriber;
2247	let didWarnUnstableReference;
2248	const storeStatesOnMount = /* @__PURE__ */ new Map();
2249	function getStoreState(name) {
2250	return registry.stores[name]?.store?.getState?.() ?? {};
2251	}
2252	const createSubscriber = (stores) => {
2253	const activeStores = [...stores];
2254	const activeSubscriptions = /* @__PURE__ */ new Set();
2255	function subscribe2(listener) {
2256	if (lastMapResultValid) {
2257	for (const name of activeStores) {
2258	if (storeStatesOnMount.get(name) !== getStoreState(name)) {
2259	lastMapResultValid = false;
2260	}
2261	}
2262	}
2263	storeStatesOnMount.clear();
2264	const onStoreChange = () => {
2265	lastMapResultValid = false;
2266	listener();
2267	};
2268	const onChange = () => {
2269	if (lastIsAsync) {
2270	renderQueue.add(queueContext, onStoreChange);
2271	} else {
2272	onStoreChange();
2273	}
2274	};
2275	const unsubs = [];
2276	function subscribeStore(storeName) {
2277	unsubs.push(registry.subscribe(onChange, storeName));
2278	}
2279	for (const storeName of activeStores) {
2280	subscribeStore(storeName);
2281	}
2282	activeSubscriptions.add(subscribeStore);
2283	return () => {
2284	activeSubscriptions.delete(subscribeStore);
2285	for (const unsub of unsubs.values()) {
2286	unsub?.();
2287	}
2288	renderQueue.cancel(queueContext);
2289	};
2290	}
2291	function updateStores(newStores) {
2292	for (const newStore of newStores) {
2293	if (activeStores.includes(newStore)) {
2294	continue;
2295	}
2296	activeStores.push(newStore);
2297	for (const subscription of activeSubscriptions) {
2298	subscription(newStore);
2299	}
2300	}
2301	}
2302	return { subscribe: subscribe2, updateStores };
2303	};
2304	return (mapSelect, isAsync) => {
2305	function updateValue() {
2306	if (lastMapResultValid && mapSelect === lastMapSelect) {
2307	return;
2308	}
2309	const listeningStores = { current: null };
2310	const mapResult = registry.__unstableMarkListeningStores(
2311	() => mapSelect(select3, registry),
2312	listeningStores
2313	);
2314	if (true) {
2315	if (!didWarnUnstableReference) {
2316	const secondMapResult = mapSelect(select3, registry);
2317	if (!(0, import_is_shallow_equal.isShallowEqual)(mapResult, secondMapResult)) {
2318	warnOnUnstableReference(mapResult, secondMapResult);
2319	didWarnUnstableReference = true;
2320	}
2321	}
2322	}
2323	if (!subscriber) {
2324	for (const name of listeningStores.current) {
2325	storeStatesOnMount.set(name, getStoreState(name));
2326	}
2327	subscriber = createSubscriber(listeningStores.current);
2328	} else {
2329	subscriber.updateStores(listeningStores.current);
2330	}
2331	if (!(0, import_is_shallow_equal.isShallowEqual)(lastMapResult, mapResult)) {
2332	lastMapResult = mapResult;
2333	}
2334	lastMapSelect = mapSelect;
2335	lastMapResultValid = true;
2336	}
2337	function getValue() {
2338	updateValue();
2339	return lastMapResult;
2340	}
2341	if (lastIsAsync && !isAsync) {
2342	lastMapResultValid = false;
2343	renderQueue.cancel(queueContext);
2344	}
2345	updateValue();
2346	lastIsAsync = isAsync;
2347	return { subscribe: subscriber.subscribe, getValue };
2348	};
2349	}
2350	function _useStaticSelect(storeName) {
2351	return useRegistry().select(storeName);
2352	}
2353	function _useMappingSelect(suspense, mapSelect, deps) {
2354	const registry = useRegistry();
2355	const isAsync = useAsyncMode();
2356	const store = (0, import_element5.useMemo)(
2357	() => Store(registry, suspense),
2358	[registry, suspense]
2359	);
2360	const selector = (0, import_element5.useCallback)(mapSelect, deps);
2361	const { subscribe: subscribe2, getValue } = store(selector, isAsync);
2362	const result = (0, import_element5.useSyncExternalStore)(subscribe2, getValue, getValue);
2363	(0, import_element5.useDebugValue)(result);
2364	return result;
2365	}
2366	function useSelect(mapSelect, deps) {
2367	const staticSelectMode = typeof mapSelect !== "function";
2368	const staticSelectModeRef = (0, import_element5.useRef)(staticSelectMode);
2369	if (staticSelectMode !== staticSelectModeRef.current) {
2370	const prevMode = staticSelectModeRef.current ? "static" : "mapping";
2371	const nextMode = staticSelectMode ? "static" : "mapping";
2372	throw new Error(
2373	`Switching useSelect from ${prevMode} to ${nextMode} is not allowed`
2374	);
2375	}
2376	return staticSelectMode ? _useStaticSelect(mapSelect) : _useMappingSelect(false, mapSelect, deps);
2377	}
2378	function useSuspenseSelect(mapSelect, deps) {
2379	return _useMappingSelect(true, mapSelect, deps);
2380	}
2381
2382	// packages/data/build-module/components/with-select/index.mjs
2383	var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
2384	var withSelect = (mapSelectToProps) => (0, import_compose2.createHigherOrderComponent)(
2385	(WrappedComponent) => (0, import_compose2.pure)((ownProps) => {
2386	const mapSelect = (select3, registry) => mapSelectToProps(select3, ownProps, registry);
2387	const mergeProps = useSelect(mapSelect);
2388	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(WrappedComponent, { ...ownProps, ...mergeProps });
2389	}),
2390	"withSelect"
2391	);
2392	var with_select_default = withSelect;
2393
2394	// packages/data/build-module/components/with-dispatch/index.mjs
2395	var import_compose4 = __toESM(require_compose(), 1);
2396
2397	// packages/data/build-module/components/use-dispatch/use-dispatch.mjs
2398	var useDispatch = (storeNameOrDescriptor) => {
2399	const { dispatch: dispatch3 } = useRegistry();
2400	return storeNameOrDescriptor === void 0 ? dispatch3 : dispatch3(storeNameOrDescriptor);
2401	};
2402	var use_dispatch_default = useDispatch;
2403
2404	// packages/data/build-module/components/use-dispatch/use-dispatch-with-map.mjs
2405	var import_element6 = __toESM(require_element(), 1);
2406	var import_compose3 = __toESM(require_compose(), 1);
2407	var useDispatchWithMap = (dispatchMap, deps) => {
2408	const registry = useRegistry();
2409	const currentDispatchMapRef = (0, import_element6.useRef)(dispatchMap);
2410	(0, import_compose3.useIsomorphicLayoutEffect)(() => {
2411	currentDispatchMapRef.current = dispatchMap;
2412	});
2413	return (0, import_element6.useMemo)(() => {
2414	const currentDispatchProps = currentDispatchMapRef.current(
2415	registry.dispatch,
2416	registry
2417	);
2418	return Object.fromEntries(
2419	Object.entries(currentDispatchProps).map(
2420	([propName, dispatcher]) => {
2421	if (typeof dispatcher !== "function") {
2422	console.warn(
2423	`Property ${propName} returned from dispatchMap in useDispatchWithMap must be a function.`
2424	);
2425	}
2426	return [
2427	propName,
2428	(...args) => currentDispatchMapRef.current(registry.dispatch, registry)[propName](...args)
2429	];
2430	}
2431	)
2432	);
2433	}, [registry, ...deps]);
2434	};
2435	var use_dispatch_with_map_default = useDispatchWithMap;
2436
2437	// packages/data/build-module/components/with-dispatch/index.mjs
2438	var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
2439	var withDispatch = (mapDispatchToProps) => (0, import_compose4.createHigherOrderComponent)(
2440	(WrappedComponent) => (ownProps) => {
2441	const mapDispatch = (dispatch3, registry) => mapDispatchToProps(dispatch3, ownProps, registry);
2442	const dispatchProps = use_dispatch_with_map_default(mapDispatch, []);
2443	return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(WrappedComponent, { ...ownProps, ...dispatchProps });
2444	},
2445	"withDispatch"
2446	);
2447	var with_dispatch_default = withDispatch;
2448
2449	// packages/data/build-module/components/with-registry/index.mjs
2450	var import_compose5 = __toESM(require_compose(), 1);
2451	var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
2452	var withRegistry = (0, import_compose5.createHigherOrderComponent)(
2453	(OriginalComponent) => (props) => /* @__PURE__ / (0, import_jsx_runtime3.jsx)(RegistryConsumer, { children: (registry) => / @__PURE__ */ (0, import_jsx_runtime3.jsx)(OriginalComponent, { ...props, registry }) }),
2454	"withRegistry"
2455	);
2456	var with_registry_default = withRegistry;
2457
2458	// packages/data/build-module/dispatch.mjs
2459	function dispatch2(storeNameOrDescriptor) {
2460	return default_registry_default.dispatch(
2461	storeNameOrDescriptor
2462	);
2463	}
2464
2465	// packages/data/build-module/select.mjs
2466	function select2(storeNameOrDescriptor) {
2467	return default_registry_default.select(
2468	storeNameOrDescriptor
2469	);
2470	}
2471
2472	// packages/data/build-module/index.mjs
2473	var combineReducers2 = combineReducers;
2474	function resolveSelect2(storeNameOrDescriptor) {
2475	return default_registry_default.resolveSelect(
2476	storeNameOrDescriptor
2477	);
2478	}
2479	var suspendSelect = (storeNameOrDescriptor) => default_registry_default.suspendSelect(storeNameOrDescriptor);
2480	var subscribe = (listener, storeNameOrDescriptor) => default_registry_default.subscribe(listener, storeNameOrDescriptor);
2481	var registerGenericStore = default_registry_default.registerGenericStore;
2482	var registerStore = default_registry_default.registerStore;
2483	var use = default_registry_default.use;
2484	var register = (store) => default_registry_default.register(store);
2485	return __toCommonJS(index_exports);
2486	})();
2487	/*! Bundled license information:
2488
2489	is-plain-object/dist/is-plain-object.mjs:
2490	(*!
2491	* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
2492	*
2493	* Copyright (c) 2014-2017, Jon Schlinkert.
2494	* Released under the MIT License.
2495	*)
2496	*/
2497	if(wp.data&&typeof wp.data==='object'){wp.data=Object.assign({},wp.data);}
2498	//# sourceMappingURL=index.js.map
2499