Gutenberg / 24.1.0

Gutenberg v24.1.0

gutenberg / build / scripts / data / index.js

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

2,617 lines 87.0 KB

Raw Download Zip

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