1/******/ (() => { // webpackBootstrap
2/******/ "use strict";
3/******/ var __webpack_modules__ = ({
4
5/***/ 66:
6/***/ ((module) => {
7
8
9
10var isMergeableObject = function isMergeableObject(value) {
11 return isNonNullObject(value)
12 && !isSpecial(value)
13};
14
15function isNonNullObject(value) {
16 return !!value && typeof value === 'object'
17}
18
19function isSpecial(value) {
20 var stringValue = Object.prototype.toString.call(value);
21
22 return stringValue === '[object RegExp]'
23 || stringValue === '[object Date]'
24 || isReactElement(value)
25}
26
27// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
28var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
29var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
30
31function isReactElement(value) {
32 return value.$$typeof === REACT_ELEMENT_TYPE
33}
34
35function emptyTarget(val) {
36 return Array.isArray(val) ? [] : {}
37}
38
39function cloneUnlessOtherwiseSpecified(value, options) {
40 return (options.clone !== false && options.isMergeableObject(value))
41 ? deepmerge(emptyTarget(value), value, options)
42 : value
43}
44
45function defaultArrayMerge(target, source, options) {
46 return target.concat(source).map(function(element) {
47 return cloneUnlessOtherwiseSpecified(element, options)
48 })
49}
50
51function getMergeFunction(key, options) {
52 if (!options.customMerge) {
53 return deepmerge
54 }
55 var customMerge = options.customMerge(key);
56 return typeof customMerge === 'function' ? customMerge : deepmerge
57}
58
59function getEnumerableOwnPropertySymbols(target) {
60 return Object.getOwnPropertySymbols
61 ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
62 return Object.propertyIsEnumerable.call(target, symbol)
63 })
64 : []
65}
66
67function getKeys(target) {
68 return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
69}
70
71function propertyIsOnObject(object, property) {
72 try {
73 return property in object
74 } catch(_) {
75 return false
76 }
77}
78
79// Protects from prototype poisoning and unexpected merging up the prototype chain.
80function propertyIsUnsafe(target, key) {
81 return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
82 && !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
83 && Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
84}
85
86function mergeObject(target, source, options) {
87 var destination = {};
88 if (options.isMergeableObject(target)) {
89 getKeys(target).forEach(function(key) {
90 destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
91 });
92 }
93 getKeys(source).forEach(function(key) {
94 if (propertyIsUnsafe(target, key)) {
95 return
96 }
97
98 if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
99 destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
100 } else {
101 destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
102 }
103 });
104 return destination
105}
106
107function deepmerge(target, source, options) {
108 options = options || {};
109 options.arrayMerge = options.arrayMerge || defaultArrayMerge;
110 options.isMergeableObject = options.isMergeableObject || isMergeableObject;
111 // cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
112 // implementations can use it. The caller may not replace it.
113 options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
114
115 var sourceIsArray = Array.isArray(source);
116 var targetIsArray = Array.isArray(target);
117 var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
118
119 if (!sourceAndTargetTypesMatch) {
120 return cloneUnlessOtherwiseSpecified(source, options)
121 } else if (sourceIsArray) {
122 return options.arrayMerge(target, source, options)
123 } else {
124 return mergeObject(target, source, options)
125 }
126}
127
128deepmerge.all = function deepmergeAll(array, options) {
129 if (!Array.isArray(array)) {
130 throw new Error('first argument should be an array')
131 }
132
133 return array.reduce(function(prev, next) {
134 return deepmerge(prev, next, options)
135 }, {})
136};
137
138var deepmerge_1 = deepmerge;
139
140module.exports = deepmerge_1;
141
142
143/***/ }),
144
145/***/ 3249:
146/***/ ((module) => {
147
148
149
150function _typeof(obj) {
151 if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
152 _typeof = function (obj) {
153 return typeof obj;
154 };
155 } else {
156 _typeof = function (obj) {
157 return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
158 };
159 }
160
161 return _typeof(obj);
162}
163
164function _classCallCheck(instance, Constructor) {
165 if (!(instance instanceof Constructor)) {
166 throw new TypeError("Cannot call a class as a function");
167 }
168}
169
170function _defineProperties(target, props) {
171 for (var i = 0; i < props.length; i++) {
172 var descriptor = props[i];
173 descriptor.enumerable = descriptor.enumerable || false;
174 descriptor.configurable = true;
175 if ("value" in descriptor) descriptor.writable = true;
176 Object.defineProperty(target, descriptor.key, descriptor);
177 }
178}
179
180function _createClass(Constructor, protoProps, staticProps) {
181 if (protoProps) _defineProperties(Constructor.prototype, protoProps);
182 if (staticProps) _defineProperties(Constructor, staticProps);
183 return Constructor;
184}
185
186/**
187 * Given an instance of EquivalentKeyMap, returns its internal value pair tuple
188 * for a key, if one exists. The tuple members consist of the last reference
189 * value for the key (used in efficient subsequent lookups) and the value
190 * assigned for the key at the leaf node.
191 *
192 * @param {EquivalentKeyMap} instance EquivalentKeyMap instance.
193 * @param {*} key The key for which to return value pair.
194 *
195 * @return {?Array} Value pair, if exists.
196 */
197function getValuePair(instance, key) {
198 var _map = instance._map,
199 _arrayTreeMap = instance._arrayTreeMap,
200 _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the
201 // value, which can be used to shortcut immediately to the value.
202
203 if (_map.has(key)) {
204 return _map.get(key);
205 } // Sort keys to ensure stable retrieval from tree.
206
207
208 var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value.
209
210 var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;
211
212 for (var i = 0; i < properties.length; i++) {
213 var property = properties[i];
214 map = map.get(property);
215
216 if (map === undefined) {
217 return;
218 }
219
220 var propertyValue = key[property];
221 map = map.get(propertyValue);
222
223 if (map === undefined) {
224 return;
225 }
226 }
227
228 var valuePair = map.get('_ekm_value');
229
230 if (!valuePair) {
231 return;
232 } // If reached, it implies that an object-like key was set with another
233 // reference, so delete the reference and replace with the current.
234
235
236 _map.delete(valuePair[0]);
237
238 valuePair[0] = key;
239 map.set('_ekm_value', valuePair);
240
241 _map.set(key, valuePair);
242
243 return valuePair;
244}
245/**
246 * Variant of a Map object which enables lookup by equivalent (deeply equal)
247 * object and array keys.
248 */
249
250
251var EquivalentKeyMap =
252/*#__PURE__*/
253function () {
254 /**
255 * Constructs a new instance of EquivalentKeyMap.
256 *
257 * @param {Iterable.<*>} iterable Initial pair of key, value for map.
258 */
259 function EquivalentKeyMap(iterable) {
260 _classCallCheck(this, EquivalentKeyMap);
261
262 this.clear();
263
264 if (iterable instanceof EquivalentKeyMap) {
265 // Map#forEach is only means of iterating with support for IE11.
266 var iterablePairs = [];
267 iterable.forEach(function (value, key) {
268 iterablePairs.push([key, value]);
269 });
270 iterable = iterablePairs;
271 }
272
273 if (iterable != null) {
274 for (var i = 0; i < iterable.length; i++) {
275 this.set(iterable[i][0], iterable[i][1]);
276 }
277 }
278 }
279 /**
280 * Accessor property returning the number of elements.
281 *
282 * @return {number} Number of elements.
283 */
284
285
286 _createClass(EquivalentKeyMap, [{
287 key: "set",
288
289 /**
290 * Add or update an element with a specified key and value.
291 *
292 * @param {*} key The key of the element to add.
293 * @param {*} value The value of the element to add.
294 *
295 * @return {EquivalentKeyMap} Map instance.
296 */
297 value: function set(key, value) {
298 // Shortcut non-object-like to set on internal Map.
299 if (key === null || _typeof(key) !== 'object') {
300 this._map.set(key, value);
301
302 return this;
303 } // Sort keys to ensure stable assignment into tree.
304
305
306 var properties = Object.keys(key).sort();
307 var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value.
308
309 var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;
310
311 for (var i = 0; i < properties.length; i++) {
312 var property = properties[i];
313
314 if (!map.has(property)) {
315 map.set(property, new EquivalentKeyMap());
316 }
317
318 map = map.get(property);
319 var propertyValue = key[property];
320
321 if (!map.has(propertyValue)) {
322 map.set(propertyValue, new EquivalentKeyMap());
323 }
324
325 map = map.get(propertyValue);
326 } // If an _ekm_value exists, there was already an equivalent key. Before
327 // overriding, ensure that the old key reference is removed from map to
328 // avoid memory leak of accumulating equivalent keys. This is, in a
329 // sense, a poor man's WeakMap, while still enabling iterability.
330
331
332 var previousValuePair = map.get('_ekm_value');
333
334 if (previousValuePair) {
335 this._map.delete(previousValuePair[0]);
336 }
337
338 map.set('_ekm_value', valuePair);
339
340 this._map.set(key, valuePair);
341
342 return this;
343 }
344 /**
345 * Returns a specified element.
346 *
347 * @param {*} key The key of the element to return.
348 *
349 * @return {?*} The element associated with the specified key or undefined
350 * if the key can't be found.
351 */
352
353 }, {
354 key: "get",
355 value: function get(key) {
356 // Shortcut non-object-like to get from internal Map.
357 if (key === null || _typeof(key) !== 'object') {
358 return this._map.get(key);
359 }
360
361 var valuePair = getValuePair(this, key);
362
363 if (valuePair) {
364 return valuePair[1];
365 }
366 }
367 /**
368 * Returns a boolean indicating whether an element with the specified key
369 * exists or not.
370 *
371 * @param {*} key The key of the element to test for presence.
372 *
373 * @return {boolean} Whether an element with the specified key exists.
374 */
375
376 }, {
377 key: "has",
378 value: function has(key) {
379 if (key === null || _typeof(key) !== 'object') {
380 return this._map.has(key);
381 } // Test on the _presence_ of the pair, not its value, as even undefined
382 // can be a valid member value for a key.
383
384
385 return getValuePair(this, key) !== undefined;
386 }
387 /**
388 * Removes the specified element.
389 *
390 * @param {*} key The key of the element to remove.
391 *
392 * @return {boolean} Returns true if an element existed and has been
393 * removed, or false if the element does not exist.
394 */
395
396 }, {
397 key: "delete",
398 value: function _delete(key) {
399 if (!this.has(key)) {
400 return false;
401 } // This naive implementation will leave orphaned child trees. A better
402 // implementation should traverse and remove orphans.
403
404
405 this.set(key, undefined);
406 return true;
407 }
408 /**
409 * Executes a provided function once per each key/value pair, in insertion
410 * order.
411 *
412 * @param {Function} callback Function to execute for each element.
413 * @param {*} thisArg Value to use as `this` when executing
414 * `callback`.
415 */
416
417 }, {
418 key: "forEach",
419 value: function forEach(callback) {
420 var _this = this;
421
422 var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;
423
424 this._map.forEach(function (value, key) {
425 // Unwrap value from object-like value pair.
426 if (key !== null && _typeof(key) === 'object') {
427 value = value[1];
428 }
429
430 callback.call(thisArg, value, key, _this);
431 });
432 }
433 /**
434 * Removes all elements.
435 */
436
437 }, {
438 key: "clear",
439 value: function clear() {
440 this._map = new Map();
441 this._arrayTreeMap = new Map();
442 this._objectTreeMap = new Map();
443 }
444 }, {
445 key: "size",
446 get: function get() {
447 return this._map.size;
448 }
449 }]);
450
451 return EquivalentKeyMap;
452}();
453
454module.exports = EquivalentKeyMap;
455
456
457/***/ })
458
459/******/ });
460/************************************************************************/
461/******/ // The module cache
462/******/ var __webpack_module_cache__ = {};
463/******/
464/******/ // The require function
465/******/ function __webpack_require__(moduleId) {
466/******/ // Check if module is in cache
467/******/ var cachedModule = __webpack_module_cache__[moduleId];
468/******/ if (cachedModule !== undefined) {
469/******/ return cachedModule.exports;
470/******/ }
471/******/ // Create a new module (and put it into the cache)
472/******/ var module = __webpack_module_cache__[moduleId] = {
473/******/ // no module.id needed
474/******/ // no module.loaded needed
475/******/ exports: {}
476/******/ };
477/******/
478/******/ // Execute the module function
479/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
480/******/
481/******/ // Return the exports of the module
482/******/ return module.exports;
483/******/ }
484/******/
485/************************************************************************/
486/******/ /* webpack/runtime/compat get default export */
487/******/ (() => {
488/******/ // getDefaultExport function for compatibility with non-harmony modules
489/******/ __webpack_require__.n = (module) => {
490/******/ var getter = module && module.__esModule ?
491/******/ () => (module['default']) :
492/******/ () => (module);
493/******/ __webpack_require__.d(getter, { a: getter });
494/******/ return getter;
495/******/ };
496/******/ })();
497/******/
498/******/ /* webpack/runtime/define property getters */
499/******/ (() => {
500/******/ // define getter functions for harmony exports
501/******/ __webpack_require__.d = (exports, definition) => {
502/******/ for(var key in definition) {
503/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
504/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
505/******/ }
506/******/ }
507/******/ };
508/******/ })();
509/******/
510/******/ /* webpack/runtime/hasOwnProperty shorthand */
511/******/ (() => {
512/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
513/******/ })();
514/******/
515/******/ /* webpack/runtime/make namespace object */
516/******/ (() => {
517/******/ // define __esModule on exports
518/******/ __webpack_require__.r = (exports) => {
519/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
520/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
521/******/ }
522/******/ Object.defineProperty(exports, '__esModule', { value: true });
523/******/ };
524/******/ })();
525/******/
526/************************************************************************/
527var __webpack_exports__ = {};
528// ESM COMPAT FLAG
529__webpack_require__.r(__webpack_exports__);
530
531// EXPORTS
532__webpack_require__.d(__webpack_exports__, {
533 AsyncModeProvider: () => (/* reexport */ context_context_default),
534 RegistryConsumer: () => (/* reexport */ RegistryConsumer),
535 RegistryProvider: () => (/* reexport */ context_default),
536 combineReducers: () => (/* binding */ build_module_combineReducers),
537 controls: () => (/* reexport */ controls),
538 createReduxStore: () => (/* reexport */ createReduxStore),
539 createRegistry: () => (/* reexport */ createRegistry),
540 createRegistryControl: () => (/* reexport */ createRegistryControl),
541 createRegistrySelector: () => (/* reexport */ createRegistrySelector),
542 createSelector: () => (/* reexport */ rememo),
543 dispatch: () => (/* reexport */ dispatch_dispatch),
544 plugins: () => (/* reexport */ plugins_namespaceObject),
545 register: () => (/* binding */ register),
546 registerGenericStore: () => (/* binding */ registerGenericStore),
547 registerStore: () => (/* binding */ registerStore),
548 resolveSelect: () => (/* binding */ build_module_resolveSelect),
549 select: () => (/* reexport */ select_select),
550 subscribe: () => (/* binding */ subscribe),
551 suspendSelect: () => (/* binding */ suspendSelect),
552 use: () => (/* binding */ use),
553 useDispatch: () => (/* reexport */ use_dispatch_default),
554 useRegistry: () => (/* reexport */ useRegistry),
555 useSelect: () => (/* reexport */ useSelect),
556 useSuspenseSelect: () => (/* reexport */ useSuspenseSelect),
557 withDispatch: () => (/* reexport */ with_dispatch_default),
558 withRegistry: () => (/* reexport */ with_registry_default),
559 withSelect: () => (/* reexport */ with_select_default)
560});
561
562// NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js
563var selectors_namespaceObject = {};
564__webpack_require__.r(selectors_namespaceObject);
565__webpack_require__.d(selectors_namespaceObject, {
566 countSelectorsByStatus: () => (countSelectorsByStatus),
567 getCachedResolvers: () => (getCachedResolvers),
568 getIsResolving: () => (getIsResolving),
569 getResolutionError: () => (getResolutionError),
570 getResolutionState: () => (getResolutionState),
571 hasFinishedResolution: () => (hasFinishedResolution),
572 hasResolutionFailed: () => (hasResolutionFailed),
573 hasResolvingSelectors: () => (hasResolvingSelectors),
574 hasStartedResolution: () => (hasStartedResolution),
575 isResolving: () => (isResolving)
576});
577
578// NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js
579var actions_namespaceObject = {};
580__webpack_require__.r(actions_namespaceObject);
581__webpack_require__.d(actions_namespaceObject, {
582 failResolution: () => (failResolution),
583 failResolutions: () => (failResolutions),
584 finishResolution: () => (finishResolution),
585 finishResolutions: () => (finishResolutions),
586 invalidateResolution: () => (invalidateResolution),
587 invalidateResolutionForStore: () => (invalidateResolutionForStore),
588 invalidateResolutionForStoreSelector: () => (invalidateResolutionForStoreSelector),
589 startResolution: () => (startResolution),
590 startResolutions: () => (startResolutions)
591});
592
593// NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/plugins/index.js
594var plugins_namespaceObject = {};
595__webpack_require__.r(plugins_namespaceObject);
596__webpack_require__.d(plugins_namespaceObject, {
597 persistence: () => (persistence_default)
598});
599
600;// external ["wp","deprecated"]
601const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
602var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
603;// ./node_modules/redux/dist/redux.mjs
604// src/utils/formatProdErrorMessage.ts
605function formatProdErrorMessage(code) {
606 return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
607}
608
609// src/utils/symbol-observable.ts
610var $$observable = /* @__PURE__ */ (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
611var symbol_observable_default = $$observable;
612
613// src/utils/actionTypes.ts
614var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
615var ActionTypes = {
616 INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
617 REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
618 PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
619};
620var actionTypes_default = ActionTypes;
621
622// src/utils/isPlainObject.ts
623function isPlainObject(obj) {
624 if (typeof obj !== "object" || obj === null)
625 return false;
626 let proto = obj;
627 while (Object.getPrototypeOf(proto) !== null) {
628 proto = Object.getPrototypeOf(proto);
629 }
630 return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
631}
632
633// src/utils/kindOf.ts
634function miniKindOf(val) {
635 if (val === void 0)
636 return "undefined";
637 if (val === null)
638 return "null";
639 const type = typeof val;
640 switch (type) {
641 case "boolean":
642 case "string":
643 case "number":
644 case "symbol":
645 case "function": {
646 return type;
647 }
648 }
649 if (Array.isArray(val))
650 return "array";
651 if (isDate(val))
652 return "date";
653 if (isError(val))
654 return "error";
655 const constructorName = ctorName(val);
656 switch (constructorName) {
657 case "Symbol":
658 case "Promise":
659 case "WeakMap":
660 case "WeakSet":
661 case "Map":
662 case "Set":
663 return constructorName;
664 }
665 return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
666}
667function ctorName(val) {
668 return typeof val.constructor === "function" ? val.constructor.name : null;
669}
670function isError(val) {
671 return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
672}
673function isDate(val) {
674 if (val instanceof Date)
675 return true;
676 return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
677}
678function kindOf(val) {
679 let typeOfVal = typeof val;
680 if (false) {}
681 return typeOfVal;
682}
683
684// src/createStore.ts
685function createStore(reducer, preloadedState, enhancer) {
686 if (typeof reducer !== "function") {
687 throw new Error( true ? formatProdErrorMessage(2) : 0);
688 }
689 if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") {
690 throw new Error( true ? formatProdErrorMessage(0) : 0);
691 }
692 if (typeof preloadedState === "function" && typeof enhancer === "undefined") {
693 enhancer = preloadedState;
694 preloadedState = void 0;
695 }
696 if (typeof enhancer !== "undefined") {
697 if (typeof enhancer !== "function") {
698 throw new Error( true ? formatProdErrorMessage(1) : 0);
699 }
700 return enhancer(createStore)(reducer, preloadedState);
701 }
702 let currentReducer = reducer;
703 let currentState = preloadedState;
704 let currentListeners = /* @__PURE__ */ new Map();
705 let nextListeners = currentListeners;
706 let listenerIdCounter = 0;
707 let isDispatching = false;
708 function ensureCanMutateNextListeners() {
709 if (nextListeners === currentListeners) {
710 nextListeners = /* @__PURE__ */ new Map();
711 currentListeners.forEach((listener, key) => {
712 nextListeners.set(key, listener);
713 });
714 }
715 }
716 function getState() {
717 if (isDispatching) {
718 throw new Error( true ? formatProdErrorMessage(3) : 0);
719 }
720 return currentState;
721 }
722 function subscribe(listener) {
723 if (typeof listener !== "function") {
724 throw new Error( true ? formatProdErrorMessage(4) : 0);
725 }
726 if (isDispatching) {
727 throw new Error( true ? formatProdErrorMessage(5) : 0);
728 }
729 let isSubscribed = true;
730 ensureCanMutateNextListeners();
731 const listenerId = listenerIdCounter++;
732 nextListeners.set(listenerId, listener);
733 return function unsubscribe() {
734 if (!isSubscribed) {
735 return;
736 }
737 if (isDispatching) {
738 throw new Error( true ? formatProdErrorMessage(6) : 0);
739 }
740 isSubscribed = false;
741 ensureCanMutateNextListeners();
742 nextListeners.delete(listenerId);
743 currentListeners = null;
744 };
745 }
746 function dispatch(action) {
747 if (!isPlainObject(action)) {
748 throw new Error( true ? formatProdErrorMessage(7) : 0);
749 }
750 if (typeof action.type === "undefined") {
751 throw new Error( true ? formatProdErrorMessage(8) : 0);
752 }
753 if (typeof action.type !== "string") {
754 throw new Error( true ? formatProdErrorMessage(17) : 0);
755 }
756 if (isDispatching) {
757 throw new Error( true ? formatProdErrorMessage(9) : 0);
758 }
759 try {
760 isDispatching = true;
761 currentState = currentReducer(currentState, action);
762 } finally {
763 isDispatching = false;
764 }
765 const listeners = currentListeners = nextListeners;
766 listeners.forEach((listener) => {
767 listener();
768 });
769 return action;
770 }
771 function replaceReducer(nextReducer) {
772 if (typeof nextReducer !== "function") {
773 throw new Error( true ? formatProdErrorMessage(10) : 0);
774 }
775 currentReducer = nextReducer;
776 dispatch({
777 type: actionTypes_default.REPLACE
778 });
779 }
780 function observable() {
781 const outerSubscribe = subscribe;
782 return {
783 /**
784 * The minimal observable subscription method.
785 * @param observer Any object that can be used as an observer.
786 * The observer object should have a `next` method.
787 * @returns An object with an `unsubscribe` method that can
788 * be used to unsubscribe the observable from the store, and prevent further
789 * emission of values from the observable.
790 */
791 subscribe(observer) {
792 if (typeof observer !== "object" || observer === null) {
793 throw new Error( true ? formatProdErrorMessage(11) : 0);
794 }
795 function observeState() {
796 const observerAsObserver = observer;
797 if (observerAsObserver.next) {
798 observerAsObserver.next(getState());
799 }
800 }
801 observeState();
802 const unsubscribe = outerSubscribe(observeState);
803 return {
804 unsubscribe
805 };
806 },
807 [symbol_observable_default]() {
808 return this;
809 }
810 };
811 }
812 dispatch({
813 type: actionTypes_default.INIT
814 });
815 const store = {
816 dispatch,
817 subscribe,
818 getState,
819 replaceReducer,
820 [symbol_observable_default]: observable
821 };
822 return store;
823}
824function legacy_createStore(reducer, preloadedState, enhancer) {
825 return createStore(reducer, preloadedState, enhancer);
826}
827
828// src/utils/warning.ts
829function warning(message) {
830 if (typeof console !== "undefined" && typeof console.error === "function") {
831 console.error(message);
832 }
833 try {
834 throw new Error(message);
835 } catch (e) {
836 }
837}
838
839// src/combineReducers.ts
840function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
841 const reducerKeys = Object.keys(reducers);
842 const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer";
843 if (reducerKeys.length === 0) {
844 return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.";
845 }
846 if (!isPlainObject(inputState)) {
847 return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`;
848 }
849 const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);
850 unexpectedKeys.forEach((key) => {
851 unexpectedKeyCache[key] = true;
852 });
853 if (action && action.type === actionTypes_default.REPLACE)
854 return;
855 if (unexpectedKeys.length > 0) {
856 return `Unexpected ${unexpectedKeys.length > 1 ? "keys" : "key"} "${unexpectedKeys.join('", "')}" found in ${argumentName}. Expected to find one of the known reducer keys instead: "${reducerKeys.join('", "')}". Unexpected keys will be ignored.`;
857 }
858}
859function assertReducerShape(reducers) {
860 Object.keys(reducers).forEach((key) => {
861 const reducer = reducers[key];
862 const initialState = reducer(void 0, {
863 type: actionTypes_default.INIT
864 });
865 if (typeof initialState === "undefined") {
866 throw new Error( true ? formatProdErrorMessage(12) : 0);
867 }
868 if (typeof reducer(void 0, {
869 type: actionTypes_default.PROBE_UNKNOWN_ACTION()
870 }) === "undefined") {
871 throw new Error( true ? formatProdErrorMessage(13) : 0);
872 }
873 });
874}
875function combineReducers(reducers) {
876 const reducerKeys = Object.keys(reducers);
877 const finalReducers = {};
878 for (let i = 0; i < reducerKeys.length; i++) {
879 const key = reducerKeys[i];
880 if (false) {}
881 if (typeof reducers[key] === "function") {
882 finalReducers[key] = reducers[key];
883 }
884 }
885 const finalReducerKeys = Object.keys(finalReducers);
886 let unexpectedKeyCache;
887 if (false) {}
888 let shapeAssertionError;
889 try {
890 assertReducerShape(finalReducers);
891 } catch (e) {
892 shapeAssertionError = e;
893 }
894 return function combination(state = {}, action) {
895 if (shapeAssertionError) {
896 throw shapeAssertionError;
897 }
898 if (false) {}
899 let hasChanged = false;
900 const nextState = {};
901 for (let i = 0; i < finalReducerKeys.length; i++) {
902 const key = finalReducerKeys[i];
903 const reducer = finalReducers[key];
904 const previousStateForKey = state[key];
905 const nextStateForKey = reducer(previousStateForKey, action);
906 if (typeof nextStateForKey === "undefined") {
907 const actionType = action && action.type;
908 throw new Error( true ? formatProdErrorMessage(14) : 0);
909 }
910 nextState[key] = nextStateForKey;
911 hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
912 }
913 hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
914 return hasChanged ? nextState : state;
915 };
916}
917
918// src/bindActionCreators.ts
919function bindActionCreator(actionCreator, dispatch) {
920 return function(...args) {
921 return dispatch(actionCreator.apply(this, args));
922 };
923}
924function bindActionCreators(actionCreators, dispatch) {
925 if (typeof actionCreators === "function") {
926 return bindActionCreator(actionCreators, dispatch);
927 }
928 if (typeof actionCreators !== "object" || actionCreators === null) {
929 throw new Error( true ? formatProdErrorMessage(16) : 0);
930 }
931 const boundActionCreators = {};
932 for (const key in actionCreators) {
933 const actionCreator = actionCreators[key];
934 if (typeof actionCreator === "function") {
935 boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
936 }
937 }
938 return boundActionCreators;
939}
940
941// src/compose.ts
942function compose(...funcs) {
943 if (funcs.length === 0) {
944 return (arg) => arg;
945 }
946 if (funcs.length === 1) {
947 return funcs[0];
948 }
949 return funcs.reduce((a, b) => (...args) => a(b(...args)));
950}
951
952// src/applyMiddleware.ts
953function applyMiddleware(...middlewares) {
954 return (createStore2) => (reducer, preloadedState) => {
955 const store = createStore2(reducer, preloadedState);
956 let dispatch = () => {
957 throw new Error( true ? formatProdErrorMessage(15) : 0);
958 };
959 const middlewareAPI = {
960 getState: store.getState,
961 dispatch: (action, ...args) => dispatch(action, ...args)
962 };
963 const chain = middlewares.map((middleware) => middleware(middlewareAPI));
964 dispatch = compose(...chain)(store.dispatch);
965 return {
966 ...store,
967 dispatch
968 };
969 };
970}
971
972// src/utils/isAction.ts
973function isAction(action) {
974 return isPlainObject(action) && "type" in action && typeof action.type === "string";
975}
976
977//# sourceMappingURL=redux.mjs.map
978// EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js
979var equivalent_key_map = __webpack_require__(3249);
980var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map);
981;// external ["wp","reduxRoutine"]
982const external_wp_reduxRoutine_namespaceObject = window["wp"]["reduxRoutine"];
983var external_wp_reduxRoutine_default = /*#__PURE__*/__webpack_require__.n(external_wp_reduxRoutine_namespaceObject);
984;// external ["wp","compose"]
985const external_wp_compose_namespaceObject = window["wp"]["compose"];
986;// ./node_modules/@wordpress/data/build-module/redux-store/combine-reducers.js
987function combine_reducers_combineReducers(reducers) {
988 const keys = Object.keys(reducers);
989 return function combinedReducer(state = {}, action) {
990 const nextState = {};
991 let hasChanged = false;
992 for (const key of keys) {
993 const reducer = reducers[key];
994 const prevStateForKey = state[key];
995 const nextStateForKey = reducer(prevStateForKey, action);
996 nextState[key] = nextStateForKey;
997 hasChanged = hasChanged || nextStateForKey !== prevStateForKey;
998 }
999 return hasChanged ? nextState : state;
1000 };
1001}
1002
1003
1004;// ./node_modules/@wordpress/data/build-module/factory.js
1005function createRegistrySelector(registrySelector) {
1006 const selectorsByRegistry = /* @__PURE__ */ new WeakMap();
1007 const wrappedSelector = (...args) => {
1008 let selector = selectorsByRegistry.get(wrappedSelector.registry);
1009 if (!selector) {
1010 selector = registrySelector(wrappedSelector.registry.select);
1011 selectorsByRegistry.set(wrappedSelector.registry, selector);
1012 }
1013 return selector(...args);
1014 };
1015 wrappedSelector.isRegistrySelector = true;
1016 return wrappedSelector;
1017}
1018function createRegistryControl(registryControl) {
1019 registryControl.isRegistryControl = true;
1020 return registryControl;
1021}
1022
1023
1024;// ./node_modules/@wordpress/data/build-module/controls.js
1025
1026const SELECT = "@@data/SELECT";
1027const RESOLVE_SELECT = "@@data/RESOLVE_SELECT";
1028const DISPATCH = "@@data/DISPATCH";
1029function isObject(object) {
1030 return object !== null && typeof object === "object";
1031}
1032function controls_select(storeNameOrDescriptor, selectorName, ...args) {
1033 return {
1034 type: SELECT,
1035 storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
1036 selectorName,
1037 args
1038 };
1039}
1040function resolveSelect(storeNameOrDescriptor, selectorName, ...args) {
1041 return {
1042 type: RESOLVE_SELECT,
1043 storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
1044 selectorName,
1045 args
1046 };
1047}
1048function dispatch(storeNameOrDescriptor, actionName, ...args) {
1049 return {
1050 type: DISPATCH,
1051 storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor,
1052 actionName,
1053 args
1054 };
1055}
1056const controls = { select: controls_select, resolveSelect, dispatch };
1057const builtinControls = {
1058 [SELECT]: createRegistryControl(
1059 (registry) => ({ storeKey, selectorName, args }) => registry.select(storeKey)[selectorName](...args)
1060 ),
1061 [RESOLVE_SELECT]: createRegistryControl(
1062 (registry) => ({ storeKey, selectorName, args }) => {
1063 const method = registry.select(storeKey)[selectorName].hasResolver ? "resolveSelect" : "select";
1064 return registry[method](storeKey)[selectorName](
1065 ...args
1066 );
1067 }
1068 ),
1069 [DISPATCH]: createRegistryControl(
1070 (registry) => ({ storeKey, actionName, args }) => registry.dispatch(storeKey)[actionName](...args)
1071 )
1072};
1073
1074
1075;// external ["wp","privateApis"]
1076const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
1077;// ./node_modules/@wordpress/data/build-module/lock-unlock.js
1078
1079const { lock, unlock } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
1080 "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
1081 "@wordpress/data"
1082);
1083
1084
1085;// ./node_modules/is-promise/index.mjs
1086function isPromise(obj) {
1087 return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
1088}
1089
1090;// ./node_modules/@wordpress/data/build-module/promise-middleware.js
1091
1092const promiseMiddleware = () => (next) => (action) => {
1093 if (isPromise(action)) {
1094 return action.then((resolvedAction) => {
1095 if (resolvedAction) {
1096 return next(resolvedAction);
1097 }
1098 });
1099 }
1100 return next(action);
1101};
1102var promise_middleware_default = promiseMiddleware;
1103
1104
1105;// ./node_modules/@wordpress/data/build-module/resolvers-cache-middleware.js
1106const createResolversCacheMiddleware = (registry, storeName) => () => (next) => (action) => {
1107 const resolvers = registry.select(storeName).getCachedResolvers();
1108 const resolverEntries = Object.entries(resolvers);
1109 resolverEntries.forEach(([selectorName, resolversByArgs]) => {
1110 const resolver = registry.stores[storeName]?.resolvers?.[selectorName];
1111 if (!resolver || !resolver.shouldInvalidate) {
1112 return;
1113 }
1114 resolversByArgs.forEach((value, args) => {
1115 if (value === void 0) {
1116 return;
1117 }
1118 if (value.status !== "finished" && value.status !== "error") {
1119 return;
1120 }
1121 if (!resolver.shouldInvalidate(action, ...args)) {
1122 return;
1123 }
1124 registry.dispatch(storeName).invalidateResolution(selectorName, args);
1125 });
1126 });
1127 return next(action);
1128};
1129var resolvers_cache_middleware_default = createResolversCacheMiddleware;
1130
1131
1132;// ./node_modules/@wordpress/data/build-module/redux-store/thunk-middleware.js
1133function createThunkMiddleware(args) {
1134 return () => (next) => (action) => {
1135 if (typeof action === "function") {
1136 return action(args);
1137 }
1138 return next(action);
1139 };
1140}
1141
1142
1143;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/utils.js
1144const onSubKey = (actionProperty) => (reducer) => (state = {}, action) => {
1145 const key = action[actionProperty];
1146 if (key === void 0) {
1147 return state;
1148 }
1149 const nextKeyState = reducer(state[key], action);
1150 if (nextKeyState === state[key]) {
1151 return state;
1152 }
1153 return {
1154 ...state,
1155 [key]: nextKeyState
1156 };
1157};
1158function selectorArgsToStateKey(args) {
1159 if (args === void 0 || args === null) {
1160 return [];
1161 }
1162 const len = args.length;
1163 let idx = len;
1164 while (idx > 0 && args[idx - 1] === void 0) {
1165 idx--;
1166 }
1167 return idx === len ? args : args.slice(0, idx);
1168}
1169
1170
1171;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/reducer.js
1172
1173
1174const subKeysIsResolved = onSubKey("selectorName")((state = new (equivalent_key_map_default())(), action) => {
1175 switch (action.type) {
1176 case "START_RESOLUTION": {
1177 const nextState = new (equivalent_key_map_default())(state);
1178 nextState.set(selectorArgsToStateKey(action.args), {
1179 status: "resolving"
1180 });
1181 return nextState;
1182 }
1183 case "FINISH_RESOLUTION": {
1184 const nextState = new (equivalent_key_map_default())(state);
1185 nextState.set(selectorArgsToStateKey(action.args), {
1186 status: "finished"
1187 });
1188 return nextState;
1189 }
1190 case "FAIL_RESOLUTION": {
1191 const nextState = new (equivalent_key_map_default())(state);
1192 nextState.set(selectorArgsToStateKey(action.args), {
1193 status: "error",
1194 error: action.error
1195 });
1196 return nextState;
1197 }
1198 case "START_RESOLUTIONS": {
1199 const nextState = new (equivalent_key_map_default())(state);
1200 for (const resolutionArgs of action.args) {
1201 nextState.set(selectorArgsToStateKey(resolutionArgs), {
1202 status: "resolving"
1203 });
1204 }
1205 return nextState;
1206 }
1207 case "FINISH_RESOLUTIONS": {
1208 const nextState = new (equivalent_key_map_default())(state);
1209 for (const resolutionArgs of action.args) {
1210 nextState.set(selectorArgsToStateKey(resolutionArgs), {
1211 status: "finished"
1212 });
1213 }
1214 return nextState;
1215 }
1216 case "FAIL_RESOLUTIONS": {
1217 const nextState = new (equivalent_key_map_default())(state);
1218 action.args.forEach((resolutionArgs, idx) => {
1219 const resolutionState = {
1220 status: "error",
1221 error: void 0
1222 };
1223 const error = action.errors[idx];
1224 if (error) {
1225 resolutionState.error = error;
1226 }
1227 nextState.set(
1228 selectorArgsToStateKey(resolutionArgs),
1229 resolutionState
1230 );
1231 });
1232 return nextState;
1233 }
1234 case "INVALIDATE_RESOLUTION": {
1235 const nextState = new (equivalent_key_map_default())(state);
1236 nextState.delete(selectorArgsToStateKey(action.args));
1237 return nextState;
1238 }
1239 }
1240 return state;
1241});
1242const isResolved = (state = {}, action) => {
1243 switch (action.type) {
1244 case "INVALIDATE_RESOLUTION_FOR_STORE":
1245 return {};
1246 case "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR": {
1247 if (action.selectorName in state) {
1248 const {
1249 [action.selectorName]: removedSelector,
1250 ...restState
1251 } = state;
1252 return restState;
1253 }
1254 return state;
1255 }
1256 case "START_RESOLUTION":
1257 case "FINISH_RESOLUTION":
1258 case "FAIL_RESOLUTION":
1259 case "START_RESOLUTIONS":
1260 case "FINISH_RESOLUTIONS":
1261 case "FAIL_RESOLUTIONS":
1262 case "INVALIDATE_RESOLUTION":
1263 return subKeysIsResolved(state, action);
1264 }
1265 return state;
1266};
1267var reducer_default = isResolved;
1268
1269
1270;// ./node_modules/rememo/rememo.js
1271
1272
1273/** @typedef {(...args: any[]) => *[]} GetDependants */
1274
1275/** @typedef {() => void} Clear */
1276
1277/**
1278 * @typedef {{
1279 * getDependants: GetDependants,
1280 * clear: Clear
1281 * }} EnhancedSelector
1282 */
1283
1284/**
1285 * Internal cache entry.
1286 *
1287 * @typedef CacheNode
1288 *
1289 * @property {?CacheNode|undefined} [prev] Previous node.
1290 * @property {?CacheNode|undefined} [next] Next node.
1291 * @property {*[]} args Function arguments for cache entry.
1292 * @property {*} val Function result.
1293 */
1294
1295/**
1296 * @typedef Cache
1297 *
1298 * @property {Clear} clear Function to clear cache.
1299 * @property {boolean} [isUniqueByDependants] Whether dependants are valid in
1300 * considering cache uniqueness. A cache is unique if dependents are all arrays
1301 * or objects.
1302 * @property {CacheNode?} [head] Cache head.
1303 * @property {*[]} [lastDependants] Dependants from previous invocation.
1304 */
1305
1306/**
1307 * Arbitrary value used as key for referencing cache object in WeakMap tree.
1308 *
1309 * @type {{}}
1310 */
1311var LEAF_KEY = {};
1312
1313/**
1314 * Returns the first argument as the sole entry in an array.
1315 *
1316 * @template T
1317 *
1318 * @param {T} value Value to return.
1319 *
1320 * @return {[T]} Value returned as entry in array.
1321 */
1322function arrayOf(value) {
1323 return [value];
1324}
1325
1326/**
1327 * Returns true if the value passed is object-like, or false otherwise. A value
1328 * is object-like if it can support property assignment, e.g. object or array.
1329 *
1330 * @param {*} value Value to test.
1331 *
1332 * @return {boolean} Whether value is object-like.
1333 */
1334function isObjectLike(value) {
1335 return !!value && 'object' === typeof value;
1336}
1337
1338/**
1339 * Creates and returns a new cache object.
1340 *
1341 * @return {Cache} Cache object.
1342 */
1343function createCache() {
1344 /** @type {Cache} */
1345 var cache = {
1346 clear: function () {
1347 cache.head = null;
1348 },
1349 };
1350
1351 return cache;
1352}
1353
1354/**
1355 * Returns true if entries within the two arrays are strictly equal by
1356 * reference from a starting index.
1357 *
1358 * @param {*[]} a First array.
1359 * @param {*[]} b Second array.
1360 * @param {number} fromIndex Index from which to start comparison.
1361 *
1362 * @return {boolean} Whether arrays are shallowly equal.
1363 */
1364function isShallowEqual(a, b, fromIndex) {
1365 var i;
1366
1367 if (a.length !== b.length) {
1368 return false;
1369 }
1370
1371 for (i = fromIndex; i < a.length; i++) {
1372 if (a[i] !== b[i]) {
1373 return false;
1374 }
1375 }
1376
1377 return true;
1378}
1379
1380/**
1381 * Returns a memoized selector function. The getDependants function argument is
1382 * called before the memoized selector and is expected to return an immutable
1383 * reference or array of references on which the selector depends for computing
1384 * its own return value. The memoize cache is preserved only as long as those
1385 * dependant references remain the same. If getDependants returns a different
1386 * reference(s), the cache is cleared and the selector value regenerated.
1387 *
1388 * @template {(...args: *[]) => *} S
1389 *
1390 * @param {S} selector Selector function.
1391 * @param {GetDependants=} getDependants Dependant getter returning an array of
1392 * references used in cache bust consideration.
1393 */
1394/* harmony default export */ function rememo(selector, getDependants) {
1395 /** @type {WeakMap<*,*>} */
1396 var rootCache;
1397
1398 /** @type {GetDependants} */
1399 var normalizedGetDependants = getDependants ? getDependants : arrayOf;
1400
1401 /**
1402 * Returns the cache for a given dependants array. When possible, a WeakMap
1403 * will be used to create a unique cache for each set of dependants. This
1404 * is feasible due to the nature of WeakMap in allowing garbage collection
1405 * to occur on entries where the key object is no longer referenced. Since
1406 * WeakMap requires the key to be an object, this is only possible when the
1407 * dependant is object-like. The root cache is created as a hierarchy where
1408 * each top-level key is the first entry in a dependants set, the value a
1409 * WeakMap where each key is the next dependant, and so on. This continues
1410 * so long as the dependants are object-like. If no dependants are object-
1411 * like, then the cache is shared across all invocations.
1412 *
1413 * @see isObjectLike
1414 *
1415 * @param {*[]} dependants Selector dependants.
1416 *
1417 * @return {Cache} Cache object.
1418 */
1419 function getCache(dependants) {
1420 var caches = rootCache,
1421 isUniqueByDependants = true,
1422 i,
1423 dependant,
1424 map,
1425 cache;
1426
1427 for (i = 0; i < dependants.length; i++) {
1428 dependant = dependants[i];
1429
1430 // Can only compose WeakMap from object-like key.
1431 if (!isObjectLike(dependant)) {
1432 isUniqueByDependants = false;
1433 break;
1434 }
1435
1436 // Does current segment of cache already have a WeakMap?
1437 if (caches.has(dependant)) {
1438 // Traverse into nested WeakMap.
1439 caches = caches.get(dependant);
1440 } else {
1441 // Create, set, and traverse into a new one.
1442 map = new WeakMap();
1443 caches.set(dependant, map);
1444 caches = map;
1445 }
1446 }
1447
1448 // We use an arbitrary (but consistent) object as key for the last item
1449 // in the WeakMap to serve as our running cache.
1450 if (!caches.has(LEAF_KEY)) {
1451 cache = createCache();
1452 cache.isUniqueByDependants = isUniqueByDependants;
1453 caches.set(LEAF_KEY, cache);
1454 }
1455
1456 return caches.get(LEAF_KEY);
1457 }
1458
1459 /**
1460 * Resets root memoization cache.
1461 */
1462 function clear() {
1463 rootCache = new WeakMap();
1464 }
1465
1466 /* eslint-disable jsdoc/check-param-names */
1467 /**
1468 * The augmented selector call, considering first whether dependants have
1469 * changed before passing it to underlying memoize function.
1470 *
1471 * @param {*} source Source object for derivation.
1472 * @param {...*} extraArgs Additional arguments to pass to selector.
1473 *
1474 * @return {*} Selector result.
1475 */
1476 /* eslint-enable jsdoc/check-param-names */
1477 function callSelector(/* source, ...extraArgs */) {
1478 var len = arguments.length,
1479 cache,
1480 node,
1481 i,
1482 args,
1483 dependants;
1484
1485 // Create copy of arguments (avoid leaking deoptimization).
1486 args = new Array(len);
1487 for (i = 0; i < len; i++) {
1488 args[i] = arguments[i];
1489 }
1490
1491 dependants = normalizedGetDependants.apply(null, args);
1492 cache = getCache(dependants);
1493
1494 // If not guaranteed uniqueness by dependants (primitive type), shallow
1495 // compare against last dependants and, if references have changed,
1496 // destroy cache to recalculate result.
1497 if (!cache.isUniqueByDependants) {
1498 if (
1499 cache.lastDependants &&
1500 !isShallowEqual(dependants, cache.lastDependants, 0)
1501 ) {
1502 cache.clear();
1503 }
1504
1505 cache.lastDependants = dependants;
1506 }
1507
1508 node = cache.head;
1509 while (node) {
1510 // Check whether node arguments match arguments
1511 if (!isShallowEqual(node.args, args, 1)) {
1512 node = node.next;
1513 continue;
1514 }
1515
1516 // At this point we can assume we've found a match
1517
1518 // Surface matched node to head if not already
1519 if (node !== cache.head) {
1520 // Adjust siblings to point to each other.
1521 /** @type {CacheNode} */ (node.prev).next = node.next;
1522 if (node.next) {
1523 node.next.prev = node.prev;
1524 }
1525
1526 node.next = cache.head;
1527 node.prev = null;
1528 /** @type {CacheNode} */ (cache.head).prev = node;
1529 cache.head = node;
1530 }
1531
1532 // Return immediately
1533 return node.val;
1534 }
1535
1536 // No cached value found. Continue to insertion phase:
1537
1538 node = /** @type {CacheNode} */ ({
1539 // Generate the result from original function
1540 val: selector.apply(null, args),
1541 });
1542
1543 // Avoid including the source object in the cache.
1544 args[0] = null;
1545 node.args = args;
1546
1547 // Don't need to check whether node is already head, since it would
1548 // have been returned above already if it was
1549
1550 // Shift existing head down list
1551 if (cache.head) {
1552 cache.head.prev = node;
1553 node.next = cache.head;
1554 }
1555
1556 cache.head = node;
1557
1558 return node.val;
1559 }
1560
1561 callSelector.getDependants = normalizedGetDependants;
1562 callSelector.clear = clear;
1563 clear();
1564
1565 return /** @type {S & EnhancedSelector} */ (callSelector);
1566}
1567
1568;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js
1569
1570
1571
1572function getResolutionState(state, selectorName, args) {
1573 const map = state[selectorName];
1574 if (!map) {
1575 return;
1576 }
1577 return map.get(selectorArgsToStateKey(args));
1578}
1579function getIsResolving(state, selectorName, args) {
1580 external_wp_deprecated_default()("wp.data.select( store ).getIsResolving", {
1581 since: "6.6",
1582 version: "6.8",
1583 alternative: "wp.data.select( store ).getResolutionState"
1584 });
1585 const resolutionState = getResolutionState(state, selectorName, args);
1586 return resolutionState && resolutionState.status === "resolving";
1587}
1588function hasStartedResolution(state, selectorName, args) {
1589 return getResolutionState(state, selectorName, args) !== void 0;
1590}
1591function hasFinishedResolution(state, selectorName, args) {
1592 const status = getResolutionState(state, selectorName, args)?.status;
1593 return status === "finished" || status === "error";
1594}
1595function hasResolutionFailed(state, selectorName, args) {
1596 return getResolutionState(state, selectorName, args)?.status === "error";
1597}
1598function getResolutionError(state, selectorName, args) {
1599 const resolutionState = getResolutionState(state, selectorName, args);
1600 return resolutionState?.status === "error" ? resolutionState.error : null;
1601}
1602function isResolving(state, selectorName, args) {
1603 return getResolutionState(state, selectorName, args)?.status === "resolving";
1604}
1605function getCachedResolvers(state) {
1606 return state;
1607}
1608function hasResolvingSelectors(state) {
1609 return Object.values(state).some(
1610 (selectorState) => (
1611 /**
1612 * This uses the internal `_map` property of `EquivalentKeyMap` for
1613 * optimization purposes, since the `EquivalentKeyMap` implementation
1614 * does not support a `.values()` implementation.
1615 *
1616 * @see https://github.com/aduth/equivalent-key-map
1617 */
1618 Array.from(selectorState._map.values()).some(
1619 (resolution) => resolution[1]?.status === "resolving"
1620 )
1621 )
1622 );
1623}
1624const countSelectorsByStatus = rememo(
1625 (state) => {
1626 const selectorsByStatus = {};
1627 Object.values(state).forEach(
1628 (selectorState) => (
1629 /**
1630 * This uses the internal `_map` property of `EquivalentKeyMap` for
1631 * optimization purposes, since the `EquivalentKeyMap` implementation
1632 * does not support a `.values()` implementation.
1633 *
1634 * @see https://github.com/aduth/equivalent-key-map
1635 */
1636 Array.from(selectorState._map.values()).forEach(
1637 (resolution) => {
1638 const currentStatus = resolution[1]?.status ?? "error";
1639 if (!selectorsByStatus[currentStatus]) {
1640 selectorsByStatus[currentStatus] = 0;
1641 }
1642 selectorsByStatus[currentStatus]++;
1643 }
1644 )
1645 )
1646 );
1647 return selectorsByStatus;
1648 },
1649 (state) => [state]
1650);
1651
1652
1653;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js
1654function startResolution(selectorName, args) {
1655 return {
1656 type: "START_RESOLUTION",
1657 selectorName,
1658 args
1659 };
1660}
1661function finishResolution(selectorName, args) {
1662 return {
1663 type: "FINISH_RESOLUTION",
1664 selectorName,
1665 args
1666 };
1667}
1668function failResolution(selectorName, args, error) {
1669 return {
1670 type: "FAIL_RESOLUTION",
1671 selectorName,
1672 args,
1673 error
1674 };
1675}
1676function startResolutions(selectorName, args) {
1677 return {
1678 type: "START_RESOLUTIONS",
1679 selectorName,
1680 args
1681 };
1682}
1683function finishResolutions(selectorName, args) {
1684 return {
1685 type: "FINISH_RESOLUTIONS",
1686 selectorName,
1687 args
1688 };
1689}
1690function failResolutions(selectorName, args, errors) {
1691 return {
1692 type: "FAIL_RESOLUTIONS",
1693 selectorName,
1694 args,
1695 errors
1696 };
1697}
1698function invalidateResolution(selectorName, args) {
1699 return {
1700 type: "INVALIDATE_RESOLUTION",
1701 selectorName,
1702 args
1703 };
1704}
1705function invalidateResolutionForStore() {
1706 return {
1707 type: "INVALIDATE_RESOLUTION_FOR_STORE"
1708 };
1709}
1710function invalidateResolutionForStoreSelector(selectorName) {
1711 return {
1712 type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR",
1713 selectorName
1714 };
1715}
1716
1717
1718;// ./node_modules/@wordpress/data/build-module/redux-store/index.js
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732const trimUndefinedValues = (array) => {
1733 const result = [...array];
1734 for (let i = result.length - 1; i >= 0; i--) {
1735 if (result[i] === void 0) {
1736 result.splice(i, 1);
1737 }
1738 }
1739 return result;
1740};
1741const mapValues = (obj, callback) => Object.fromEntries(
1742 Object.entries(obj ?? {}).map(([key, value]) => [
1743 key,
1744 callback(value, key)
1745 ])
1746);
1747const devToolsReplacer = (key, state) => {
1748 if (state instanceof Map) {
1749 return Object.fromEntries(state);
1750 }
1751 if (state instanceof window.HTMLElement) {
1752 return null;
1753 }
1754 return state;
1755};
1756function createResolversCache() {
1757 const cache = {};
1758 return {
1759 isRunning(selectorName, args) {
1760 return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args));
1761 },
1762 clear(selectorName, args) {
1763 if (cache[selectorName]) {
1764 cache[selectorName].delete(trimUndefinedValues(args));
1765 }
1766 },
1767 markAsRunning(selectorName, args) {
1768 if (!cache[selectorName]) {
1769 cache[selectorName] = new (equivalent_key_map_default())();
1770 }
1771 cache[selectorName].set(trimUndefinedValues(args), true);
1772 }
1773 };
1774}
1775function createBindingCache(getItem, bindItem) {
1776 const cache = /* @__PURE__ */ new WeakMap();
1777 return {
1778 get(itemName) {
1779 const item = getItem(itemName);
1780 if (!item) {
1781 return null;
1782 }
1783 let boundItem = cache.get(item);
1784 if (!boundItem) {
1785 boundItem = bindItem(item, itemName);
1786 cache.set(item, boundItem);
1787 }
1788 return boundItem;
1789 }
1790 };
1791}
1792function createPrivateProxy(publicItems, privateItems) {
1793 return new Proxy(publicItems, {
1794 get: (target, itemName) => privateItems.get(itemName) || Reflect.get(target, itemName)
1795 });
1796}
1797function createReduxStore(key, options) {
1798 const privateActions = {};
1799 const privateSelectors = {};
1800 const privateRegistrationFunctions = {
1801 privateActions,
1802 registerPrivateActions: (actions) => {
1803 Object.assign(privateActions, actions);
1804 },
1805 privateSelectors,
1806 registerPrivateSelectors: (selectors) => {
1807 Object.assign(privateSelectors, selectors);
1808 }
1809 };
1810 const storeDescriptor = {
1811 name: key,
1812 instantiate: (registry) => {
1813 const listeners = /* @__PURE__ */ new Set();
1814 const reducer = options.reducer;
1815 const thunkArgs = {
1816 registry,
1817 get dispatch() {
1818 return thunkDispatch;
1819 },
1820 get select() {
1821 return thunkSelect;
1822 },
1823 get resolveSelect() {
1824 return resolveSelectors;
1825 }
1826 };
1827 const store = instantiateReduxStore(
1828 key,
1829 options,
1830 registry,
1831 thunkArgs
1832 );
1833 lock(store, privateRegistrationFunctions);
1834 const resolversCache = createResolversCache();
1835 function bindAction(action) {
1836 return (...args) => Promise.resolve(store.dispatch(action(...args)));
1837 }
1838 const actions = {
1839 ...mapValues(actions_namespaceObject, bindAction),
1840 ...mapValues(options.actions, bindAction)
1841 };
1842 const allActions = createPrivateProxy(
1843 actions,
1844 createBindingCache(
1845 (name) => privateActions[name],
1846 bindAction
1847 )
1848 );
1849 const thunkDispatch = new Proxy(
1850 (action) => store.dispatch(action),
1851 { get: (target, name) => allActions[name] }
1852 );
1853 lock(actions, allActions);
1854 const resolvers = options.resolvers ? mapValues(options.resolvers, mapResolver) : {};
1855 function bindSelector(selector, selectorName) {
1856 if (selector.isRegistrySelector) {
1857 selector.registry = registry;
1858 }
1859 const boundSelector = (...args) => {
1860 args = normalize(selector, args);
1861 const state = store.__unstableOriginalGetState();
1862 if (selector.isRegistrySelector) {
1863 selector.registry = registry;
1864 }
1865 return selector(state.root, ...args);
1866 };
1867 boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
1868 const resolver = resolvers[selectorName];
1869 if (!resolver) {
1870 boundSelector.hasResolver = false;
1871 return boundSelector;
1872 }
1873 return mapSelectorWithResolver(
1874 boundSelector,
1875 selectorName,
1876 resolver,
1877 store,
1878 resolversCache,
1879 boundMetadataSelectors
1880 );
1881 }
1882 function bindMetadataSelector(metaDataSelector) {
1883 const boundSelector = (selectorName, selectorArgs, ...args) => {
1884 if (selectorName) {
1885 const targetSelector = options.selectors?.[selectorName];
1886 if (targetSelector) {
1887 selectorArgs = normalize(
1888 targetSelector,
1889 selectorArgs
1890 );
1891 }
1892 }
1893 const state = store.__unstableOriginalGetState();
1894 return metaDataSelector(
1895 state.metadata,
1896 selectorName,
1897 selectorArgs,
1898 ...args
1899 );
1900 };
1901 boundSelector.hasResolver = false;
1902 return boundSelector;
1903 }
1904 const boundMetadataSelectors = mapValues(
1905 selectors_namespaceObject,
1906 bindMetadataSelector
1907 );
1908 const boundSelectors = mapValues(options.selectors, bindSelector);
1909 const selectors = {
1910 ...boundMetadataSelectors,
1911 ...boundSelectors
1912 };
1913 const boundPrivateSelectors = createBindingCache(
1914 (name) => privateSelectors[name],
1915 bindSelector
1916 );
1917 const allSelectors = createPrivateProxy(
1918 selectors,
1919 boundPrivateSelectors
1920 );
1921 for (const selectorName of Object.keys(privateSelectors)) {
1922 boundPrivateSelectors.get(selectorName);
1923 }
1924 const thunkSelect = new Proxy(
1925 (selector) => selector(store.__unstableOriginalGetState()),
1926 { get: (target, name) => allSelectors[name] }
1927 );
1928 lock(selectors, allSelectors);
1929 const bindResolveSelector = mapResolveSelector(
1930 store,
1931 boundMetadataSelectors
1932 );
1933 const resolveSelectors = mapValues(
1934 boundSelectors,
1935 bindResolveSelector
1936 );
1937 const allResolveSelectors = createPrivateProxy(
1938 resolveSelectors,
1939 createBindingCache(
1940 (name) => boundPrivateSelectors.get(name),
1941 bindResolveSelector
1942 )
1943 );
1944 lock(resolveSelectors, allResolveSelectors);
1945 const bindSuspendSelector = mapSuspendSelector(
1946 store,
1947 boundMetadataSelectors
1948 );
1949 const suspendSelectors = {
1950 ...boundMetadataSelectors,
1951 // no special suspense behavior
1952 ...mapValues(boundSelectors, bindSuspendSelector)
1953 };
1954 const allSuspendSelectors = createPrivateProxy(
1955 suspendSelectors,
1956 createBindingCache(
1957 (name) => boundPrivateSelectors.get(name),
1958 bindSuspendSelector
1959 )
1960 );
1961 lock(suspendSelectors, allSuspendSelectors);
1962 const getSelectors = () => selectors;
1963 const getActions = () => actions;
1964 const getResolveSelectors = () => resolveSelectors;
1965 const getSuspendSelectors = () => suspendSelectors;
1966 store.__unstableOriginalGetState = store.getState;
1967 store.getState = () => store.__unstableOriginalGetState().root;
1968 const subscribe = store && ((listener) => {
1969 listeners.add(listener);
1970 return () => listeners.delete(listener);
1971 });
1972 let lastState = store.__unstableOriginalGetState();
1973 store.subscribe(() => {
1974 const state = store.__unstableOriginalGetState();
1975 const hasChanged = state !== lastState;
1976 lastState = state;
1977 if (hasChanged) {
1978 for (const listener of listeners) {
1979 listener();
1980 }
1981 }
1982 });
1983 return {
1984 reducer,
1985 store,
1986 actions,
1987 selectors,
1988 resolvers,
1989 getSelectors,
1990 getResolveSelectors,
1991 getSuspendSelectors,
1992 getActions,
1993 subscribe
1994 };
1995 }
1996 };
1997 lock(storeDescriptor, privateRegistrationFunctions);
1998 return storeDescriptor;
1999}
2000function instantiateReduxStore(key, options, registry, thunkArgs) {
2001 const controls = {
2002 ...options.controls,
2003 ...builtinControls
2004 };
2005 const normalizedControls = mapValues(
2006 controls,
2007 (control) => control.isRegistryControl ? control(registry) : control
2008 );
2009 const middlewares = [
2010 resolvers_cache_middleware_default(registry, key),
2011 promise_middleware_default,
2012 external_wp_reduxRoutine_default()(normalizedControls),
2013 createThunkMiddleware(thunkArgs)
2014 ];
2015 const enhancers = [applyMiddleware(...middlewares)];
2016 if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
2017 enhancers.push(
2018 window.__REDUX_DEVTOOLS_EXTENSION__({
2019 name: key,
2020 instanceId: key,
2021 serialize: {
2022 replacer: devToolsReplacer
2023 }
2024 })
2025 );
2026 }
2027 const { reducer, initialState } = options;
2028 const enhancedReducer = combine_reducers_combineReducers({
2029 metadata: reducer_default,
2030 root: reducer
2031 });
2032 return createStore(
2033 enhancedReducer,
2034 { root: initialState },
2035 (0,external_wp_compose_namespaceObject.compose)(enhancers)
2036 );
2037}
2038function mapResolveSelector(store, boundMetadataSelectors) {
2039 return (selector, selectorName) => {
2040 if (!selector.hasResolver) {
2041 return async (...args) => selector.apply(null, args);
2042 }
2043 return (...args) => new Promise((resolve, reject) => {
2044 const hasFinished = () => {
2045 return boundMetadataSelectors.hasFinishedResolution(
2046 selectorName,
2047 args
2048 );
2049 };
2050 const finalize = (result2) => {
2051 const hasFailed = boundMetadataSelectors.hasResolutionFailed(
2052 selectorName,
2053 args
2054 );
2055 if (hasFailed) {
2056 const error = boundMetadataSelectors.getResolutionError(
2057 selectorName,
2058 args
2059 );
2060 reject(error);
2061 } else {
2062 resolve(result2);
2063 }
2064 };
2065 const getResult = () => selector.apply(null, args);
2066 const result = getResult();
2067 if (hasFinished()) {
2068 return finalize(result);
2069 }
2070 const unsubscribe = store.subscribe(() => {
2071 if (hasFinished()) {
2072 unsubscribe();
2073 finalize(getResult());
2074 }
2075 });
2076 });
2077 };
2078}
2079function mapSuspendSelector(store, boundMetadataSelectors) {
2080 return (selector, selectorName) => {
2081 if (!selector.hasResolver) {
2082 return selector;
2083 }
2084 return (...args) => {
2085 const result = selector.apply(null, args);
2086 if (boundMetadataSelectors.hasFinishedResolution(
2087 selectorName,
2088 args
2089 )) {
2090 if (boundMetadataSelectors.hasResolutionFailed(
2091 selectorName,
2092 args
2093 )) {
2094 throw boundMetadataSelectors.getResolutionError(
2095 selectorName,
2096 args
2097 );
2098 }
2099 return result;
2100 }
2101 throw new Promise((resolve) => {
2102 const unsubscribe = store.subscribe(() => {
2103 if (boundMetadataSelectors.hasFinishedResolution(
2104 selectorName,
2105 args
2106 )) {
2107 resolve();
2108 unsubscribe();
2109 }
2110 });
2111 });
2112 };
2113 };
2114}
2115function mapResolver(resolver) {
2116 if (resolver.fulfill) {
2117 return resolver;
2118 }
2119 return {
2120 ...resolver,
2121 // Copy the enumerable properties of the resolver function.
2122 fulfill: resolver
2123 // Add the fulfill method.
2124 };
2125}
2126function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
2127 function fulfillSelector(args) {
2128 const state = store.getState();
2129 if (resolversCache.isRunning(selectorName, args) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(state, ...args)) {
2130 return;
2131 }
2132 if (boundMetadataSelectors.hasStartedResolution(selectorName, args)) {
2133 return;
2134 }
2135 resolversCache.markAsRunning(selectorName, args);
2136 setTimeout(async () => {
2137 resolversCache.clear(selectorName, args);
2138 store.dispatch(
2139 startResolution(selectorName, args)
2140 );
2141 try {
2142 const action = resolver.fulfill(...args);
2143 if (action) {
2144 await store.dispatch(action);
2145 }
2146 store.dispatch(
2147 finishResolution(selectorName, args)
2148 );
2149 } catch (error) {
2150 store.dispatch(
2151 failResolution(selectorName, args, error)
2152 );
2153 }
2154 }, 0);
2155 }
2156 const selectorResolver = (...args) => {
2157 args = normalize(selector, args);
2158 fulfillSelector(args);
2159 return selector(...args);
2160 };
2161 selectorResolver.hasResolver = true;
2162 return selectorResolver;
2163}
2164function normalize(selector, args) {
2165 if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) {
2166 return selector.__unstableNormalizeArgs(args);
2167 }
2168 return args;
2169}
2170
2171
2172;// ./node_modules/@wordpress/data/build-module/store/index.js
2173const coreDataStore = {
2174 name: "core/data",
2175 instantiate(registry) {
2176 const getCoreDataSelector = (selectorName) => (key, ...args) => {
2177 return registry.select(key)[selectorName](...args);
2178 };
2179 const getCoreDataAction = (actionName) => (key, ...args) => {
2180 return registry.dispatch(key)[actionName](...args);
2181 };
2182 return {
2183 getSelectors() {
2184 return Object.fromEntries(
2185 [
2186 "getIsResolving",
2187 "hasStartedResolution",
2188 "hasFinishedResolution",
2189 "isResolving",
2190 "getCachedResolvers"
2191 ].map((selectorName) => [
2192 selectorName,
2193 getCoreDataSelector(selectorName)
2194 ])
2195 );
2196 },
2197 getActions() {
2198 return Object.fromEntries(
2199 [
2200 "startResolution",
2201 "finishResolution",
2202 "invalidateResolution",
2203 "invalidateResolutionForStore",
2204 "invalidateResolutionForStoreSelector"
2205 ].map((actionName) => [
2206 actionName,
2207 getCoreDataAction(actionName)
2208 ])
2209 );
2210 },
2211 subscribe() {
2212 return () => () => {
2213 };
2214 }
2215 };
2216 }
2217};
2218var store_default = coreDataStore;
2219
2220
2221;// ./node_modules/@wordpress/data/build-module/utils/emitter.js
2222function createEmitter() {
2223 let isPaused = false;
2224 let isPending = false;
2225 const listeners = /* @__PURE__ */ new Set();
2226 const notifyListeners = () => (
2227 // We use Array.from to clone the listeners Set
2228 // This ensures that we don't run a listener
2229 // that was added as a response to another listener.
2230 Array.from(listeners).forEach((listener) => listener())
2231 );
2232 return {
2233 get isPaused() {
2234 return isPaused;
2235 },
2236 subscribe(listener) {
2237 listeners.add(listener);
2238 return () => listeners.delete(listener);
2239 },
2240 pause() {
2241 isPaused = true;
2242 },
2243 resume() {
2244 isPaused = false;
2245 if (isPending) {
2246 isPending = false;
2247 notifyListeners();
2248 }
2249 },
2250 emit() {
2251 if (isPaused) {
2252 isPending = true;
2253 return;
2254 }
2255 notifyListeners();
2256 }
2257 };
2258}
2259
2260
2261;// ./node_modules/@wordpress/data/build-module/registry.js
2262
2263
2264
2265
2266
2267function getStoreName(storeNameOrDescriptor) {
2268 return typeof storeNameOrDescriptor === "string" ? storeNameOrDescriptor : storeNameOrDescriptor.name;
2269}
2270function createRegistry(storeConfigs = {}, parent = null) {
2271 const stores = {};
2272 const emitter = createEmitter();
2273 let listeningStores = null;
2274 function globalListener() {
2275 emitter.emit();
2276 }
2277 const subscribe = (listener, storeNameOrDescriptor) => {
2278 if (!storeNameOrDescriptor) {
2279 return emitter.subscribe(listener);
2280 }
2281 const storeName = getStoreName(storeNameOrDescriptor);
2282 const store = stores[storeName];
2283 if (store) {
2284 return store.subscribe(listener);
2285 }
2286 if (!parent) {
2287 return emitter.subscribe(listener);
2288 }
2289 return parent.subscribe(listener, storeNameOrDescriptor);
2290 };
2291 function select(storeNameOrDescriptor) {
2292 const storeName = getStoreName(storeNameOrDescriptor);
2293 listeningStores?.add(storeName);
2294 const store = stores[storeName];
2295 if (store) {
2296 return store.getSelectors();
2297 }
2298 return parent?.select(storeName);
2299 }
2300 function __unstableMarkListeningStores(callback, ref) {
2301 listeningStores = /* @__PURE__ */ new Set();
2302 try {
2303 return callback.call(this);
2304 } finally {
2305 ref.current = Array.from(listeningStores);
2306 listeningStores = null;
2307 }
2308 }
2309 function resolveSelect(storeNameOrDescriptor) {
2310 const storeName = getStoreName(storeNameOrDescriptor);
2311 listeningStores?.add(storeName);
2312 const store = stores[storeName];
2313 if (store) {
2314 return store.getResolveSelectors();
2315 }
2316 return parent && parent.resolveSelect(storeName);
2317 }
2318 function suspendSelect(storeNameOrDescriptor) {
2319 const storeName = getStoreName(storeNameOrDescriptor);
2320 listeningStores?.add(storeName);
2321 const store = stores[storeName];
2322 if (store) {
2323 return store.getSuspendSelectors();
2324 }
2325 return parent && parent.suspendSelect(storeName);
2326 }
2327 function dispatch(storeNameOrDescriptor) {
2328 const storeName = getStoreName(storeNameOrDescriptor);
2329 const store = stores[storeName];
2330 if (store) {
2331 return store.getActions();
2332 }
2333 return parent && parent.dispatch(storeName);
2334 }
2335 function withPlugins(attributes) {
2336 return Object.fromEntries(
2337 Object.entries(attributes).map(([key, attribute]) => {
2338 if (typeof attribute !== "function") {
2339 return [key, attribute];
2340 }
2341 return [
2342 key,
2343 function() {
2344 return registry[key].apply(null, arguments);
2345 }
2346 ];
2347 })
2348 );
2349 }
2350 function registerStoreInstance(name, createStore) {
2351 if (stores[name]) {
2352 console.error('Store "' + name + '" is already registered.');
2353 return stores[name];
2354 }
2355 const store = createStore();
2356 if (typeof store.getSelectors !== "function") {
2357 throw new TypeError("store.getSelectors must be a function");
2358 }
2359 if (typeof store.getActions !== "function") {
2360 throw new TypeError("store.getActions must be a function");
2361 }
2362 if (typeof store.subscribe !== "function") {
2363 throw new TypeError("store.subscribe must be a function");
2364 }
2365 store.emitter = createEmitter();
2366 const currentSubscribe = store.subscribe;
2367 store.subscribe = (listener) => {
2368 const unsubscribeFromEmitter = store.emitter.subscribe(listener);
2369 const unsubscribeFromStore = currentSubscribe(() => {
2370 if (store.emitter.isPaused) {
2371 store.emitter.emit();
2372 return;
2373 }
2374 listener();
2375 });
2376 return () => {
2377 unsubscribeFromStore?.();
2378 unsubscribeFromEmitter?.();
2379 };
2380 };
2381 stores[name] = store;
2382 store.subscribe(globalListener);
2383 if (parent) {
2384 try {
2385 unlock(store.store).registerPrivateActions(
2386 unlock(parent).privateActionsOf(name)
2387 );
2388 unlock(store.store).registerPrivateSelectors(
2389 unlock(parent).privateSelectorsOf(name)
2390 );
2391 } catch (e) {
2392 }
2393 }
2394 return store;
2395 }
2396 function register(store) {
2397 registerStoreInstance(
2398 store.name,
2399 () => store.instantiate(registry)
2400 );
2401 }
2402 function registerGenericStore(name, store) {
2403 external_wp_deprecated_default()("wp.data.registerGenericStore", {
2404 since: "5.9",
2405 alternative: "wp.data.register( storeDescriptor )"
2406 });
2407 registerStoreInstance(name, () => store);
2408 }
2409 function registerStore(storeName, options) {
2410 if (!options.reducer) {
2411 throw new TypeError("Must specify store reducer");
2412 }
2413 const store = registerStoreInstance(
2414 storeName,
2415 () => createReduxStore(storeName, options).instantiate(registry)
2416 );
2417 return store.store;
2418 }
2419 function batch(callback) {
2420 if (emitter.isPaused) {
2421 callback();
2422 return;
2423 }
2424 emitter.pause();
2425 Object.values(stores).forEach((store) => store.emitter.pause());
2426 try {
2427 callback();
2428 } finally {
2429 emitter.resume();
2430 Object.values(stores).forEach(
2431 (store) => store.emitter.resume()
2432 );
2433 }
2434 }
2435 let registry = {
2436 batch,
2437 stores,
2438 namespaces: stores,
2439 // TODO: Deprecate/remove this.
2440 subscribe,
2441 select,
2442 resolveSelect,
2443 suspendSelect,
2444 dispatch,
2445 use,
2446 register,
2447 registerGenericStore,
2448 registerStore,
2449 __unstableMarkListeningStores
2450 };
2451 function use(plugin, options) {
2452 if (!plugin) {
2453 return;
2454 }
2455 registry = {
2456 ...registry,
2457 ...plugin(registry, options)
2458 };
2459 return registry;
2460 }
2461 registry.register(store_default);
2462 for (const [name, config] of Object.entries(storeConfigs)) {
2463 registry.register(createReduxStore(name, config));
2464 }
2465 if (parent) {
2466 parent.subscribe(globalListener);
2467 }
2468 const registryWithPlugins = withPlugins(registry);
2469 lock(registryWithPlugins, {
2470 privateActionsOf: (name) => {
2471 try {
2472 return unlock(stores[name].store).privateActions;
2473 } catch (e) {
2474 return {};
2475 }
2476 },
2477 privateSelectorsOf: (name) => {
2478 try {
2479 return unlock(stores[name].store).privateSelectors;
2480 } catch (e) {
2481 return {};
2482 }
2483 }
2484 });
2485 return registryWithPlugins;
2486}
2487
2488
2489;// ./node_modules/@wordpress/data/build-module/default-registry.js
2490
2491var default_registry_default = createRegistry();
2492
2493
2494;// ./node_modules/is-plain-object/dist/is-plain-object.mjs
2495/*!
2496 * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
2497 *
2498 * Copyright (c) 2014-2017, Jon Schlinkert.
2499 * Released under the MIT License.
2500 */
2501
2502function is_plain_object_isObject(o) {
2503 return Object.prototype.toString.call(o) === '[object Object]';
2504}
2505
2506function is_plain_object_isPlainObject(o) {
2507 var ctor,prot;
2508
2509 if (is_plain_object_isObject(o) === false) return false;
2510
2511 // If has modified constructor
2512 ctor = o.constructor;
2513 if (ctor === undefined) return true;
2514
2515 // If has modified prototype
2516 prot = ctor.prototype;
2517 if (is_plain_object_isObject(prot) === false) return false;
2518
2519 // If constructor does not have an Object-specific method
2520 if (prot.hasOwnProperty('isPrototypeOf') === false) {
2521 return false;
2522 }
2523
2524 // Most likely a plain Object
2525 return true;
2526}
2527
2528
2529
2530// EXTERNAL MODULE: ./node_modules/deepmerge/dist/cjs.js
2531var cjs = __webpack_require__(66);
2532var cjs_default = /*#__PURE__*/__webpack_require__.n(cjs);
2533;// ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/object.js
2534let objectStorage;
2535const storage = {
2536 getItem(key) {
2537 if (!objectStorage || !objectStorage[key]) {
2538 return null;
2539 }
2540 return objectStorage[key];
2541 },
2542 setItem(key, value) {
2543 if (!objectStorage) {
2544 storage.clear();
2545 }
2546 objectStorage[key] = String(value);
2547 },
2548 clear() {
2549 objectStorage = /* @__PURE__ */ Object.create(null);
2550 }
2551};
2552var object_default = storage;
2553
2554
2555;// ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/default.js
2556
2557let default_storage;
2558try {
2559 default_storage = window.localStorage;
2560 default_storage.setItem("__wpDataTestLocalStorage", "");
2561 default_storage.removeItem("__wpDataTestLocalStorage");
2562} catch (error) {
2563 default_storage = object_default;
2564}
2565var default_default = default_storage;
2566
2567
2568;// ./node_modules/@wordpress/data/build-module/plugins/persistence/index.js
2569
2570
2571
2572
2573const DEFAULT_STORAGE = default_default;
2574const DEFAULT_STORAGE_KEY = "WP_DATA";
2575const withLazySameState = (reducer) => (state, action) => {
2576 if (action.nextState === state) {
2577 return state;
2578 }
2579 return reducer(state, action);
2580};
2581function createPersistenceInterface(options) {
2582 const { storage = DEFAULT_STORAGE, storageKey = DEFAULT_STORAGE_KEY } = options;
2583 let data;
2584 function getData() {
2585 if (data === void 0) {
2586 const persisted = storage.getItem(storageKey);
2587 if (persisted === null) {
2588 data = {};
2589 } else {
2590 try {
2591 data = JSON.parse(persisted);
2592 } catch (error) {
2593 data = {};
2594 }
2595 }
2596 }
2597 return data;
2598 }
2599 function setData(key, value) {
2600 data = { ...data, [key]: value };
2601 storage.setItem(storageKey, JSON.stringify(data));
2602 }
2603 return {
2604 get: getData,
2605 set: setData
2606 };
2607}
2608function persistencePlugin(registry, pluginOptions) {
2609 const persistence = createPersistenceInterface(pluginOptions);
2610 function createPersistOnChange(getState, storeName, keys) {
2611 let getPersistedState;
2612 if (Array.isArray(keys)) {
2613 const reducers = keys.reduce(
2614 (accumulator, key) => Object.assign(accumulator, {
2615 [key]: (state, action) => action.nextState[key]
2616 }),
2617 {}
2618 );
2619 getPersistedState = withLazySameState(
2620 build_module_combineReducers(reducers)
2621 );
2622 } else {
2623 getPersistedState = (state, action) => action.nextState;
2624 }
2625 let lastState = getPersistedState(void 0, {
2626 nextState: getState()
2627 });
2628 return () => {
2629 const state = getPersistedState(lastState, {
2630 nextState: getState()
2631 });
2632 if (state !== lastState) {
2633 persistence.set(storeName, state);
2634 lastState = state;
2635 }
2636 };
2637 }
2638 return {
2639 registerStore(storeName, options) {
2640 if (!options.persist) {
2641 return registry.registerStore(storeName, options);
2642 }
2643 const persistedState = persistence.get()[storeName];
2644 if (persistedState !== void 0) {
2645 let initialState = options.reducer(options.initialState, {
2646 type: "@@WP/PERSISTENCE_RESTORE"
2647 });
2648 if (is_plain_object_isPlainObject(initialState) && is_plain_object_isPlainObject(persistedState)) {
2649 initialState = cjs_default()(initialState, persistedState, {
2650 isMergeableObject: is_plain_object_isPlainObject
2651 });
2652 } else {
2653 initialState = persistedState;
2654 }
2655 options = {
2656 ...options,
2657 initialState
2658 };
2659 }
2660 const store = registry.registerStore(storeName, options);
2661 store.subscribe(
2662 createPersistOnChange(
2663 store.getState,
2664 storeName,
2665 options.persist
2666 )
2667 );
2668 return store;
2669 }
2670 };
2671}
2672persistencePlugin.__unstableMigrate = () => {
2673};
2674var persistence_default = persistencePlugin;
2675
2676
2677;// ./node_modules/@wordpress/data/build-module/plugins/index.js
2678
2679
2680
2681;// external "ReactJSXRuntime"
2682const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
2683;// external ["wp","priorityQueue"]
2684const external_wp_priorityQueue_namespaceObject = window["wp"]["priorityQueue"];
2685;// external ["wp","element"]
2686const external_wp_element_namespaceObject = window["wp"]["element"];
2687;// external ["wp","isShallowEqual"]
2688const external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"];
2689var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
2690;// ./node_modules/@wordpress/data/build-module/components/registry-provider/context.js
2691
2692
2693const Context = (0,external_wp_element_namespaceObject.createContext)(default_registry_default);
2694Context.displayName = "RegistryProviderContext";
2695const { Consumer, Provider } = Context;
2696const RegistryConsumer = Consumer;
2697var context_default = Provider;
2698
2699
2700;// ./node_modules/@wordpress/data/build-module/components/registry-provider/use-registry.js
2701
2702
2703function useRegistry() {
2704 return (0,external_wp_element_namespaceObject.useContext)(Context);
2705}
2706
2707
2708;// ./node_modules/@wordpress/data/build-module/components/async-mode-provider/context.js
2709
2710const context_Context = (0,external_wp_element_namespaceObject.createContext)(false);
2711context_Context.displayName = "AsyncModeContext";
2712const { Consumer: context_Consumer, Provider: context_Provider } = context_Context;
2713const AsyncModeConsumer = (/* unused pure expression or super */ null && (context_Consumer));
2714var context_context_default = context_Provider;
2715
2716
2717;// ./node_modules/@wordpress/data/build-module/components/async-mode-provider/use-async-mode.js
2718
2719
2720function useAsyncMode() {
2721 return (0,external_wp_element_namespaceObject.useContext)(context_Context);
2722}
2723
2724
2725;// ./node_modules/@wordpress/data/build-module/components/use-select/index.js
2726
2727
2728
2729
2730
2731const renderQueue = (0,external_wp_priorityQueue_namespaceObject.createQueue)();
2732function warnOnUnstableReference(a, b) {
2733 if (!a || !b) {
2734 return;
2735 }
2736 const keys = typeof a === "object" && typeof b === "object" ? Object.keys(a).filter((k) => a[k] !== b[k]) : [];
2737 console.warn(
2738 "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",
2739 keys.join(", ")
2740 );
2741}
2742function Store(registry, suspense) {
2743 const select = suspense ? registry.suspendSelect : registry.select;
2744 const queueContext = {};
2745 let lastMapSelect;
2746 let lastMapResult;
2747 let lastMapResultValid = false;
2748 let lastIsAsync;
2749 let subscriber;
2750 let didWarnUnstableReference;
2751 const storeStatesOnMount = /* @__PURE__ */ new Map();
2752 function getStoreState(name) {
2753 return registry.stores[name]?.store?.getState?.() ?? {};
2754 }
2755 const createSubscriber = (stores) => {
2756 const activeStores = [...stores];
2757 const activeSubscriptions = /* @__PURE__ */ new Set();
2758 function subscribe(listener) {
2759 if (lastMapResultValid) {
2760 for (const name of activeStores) {
2761 if (storeStatesOnMount.get(name) !== getStoreState(name)) {
2762 lastMapResultValid = false;
2763 }
2764 }
2765 }
2766 storeStatesOnMount.clear();
2767 const onStoreChange = () => {
2768 lastMapResultValid = false;
2769 listener();
2770 };
2771 const onChange = () => {
2772 if (lastIsAsync) {
2773 renderQueue.add(queueContext, onStoreChange);
2774 } else {
2775 onStoreChange();
2776 }
2777 };
2778 const unsubs = [];
2779 function subscribeStore(storeName) {
2780 unsubs.push(registry.subscribe(onChange, storeName));
2781 }
2782 for (const storeName of activeStores) {
2783 subscribeStore(storeName);
2784 }
2785 activeSubscriptions.add(subscribeStore);
2786 return () => {
2787 activeSubscriptions.delete(subscribeStore);
2788 for (const unsub of unsubs.values()) {
2789 unsub?.();
2790 }
2791 renderQueue.cancel(queueContext);
2792 };
2793 }
2794 function updateStores(newStores) {
2795 for (const newStore of newStores) {
2796 if (activeStores.includes(newStore)) {
2797 continue;
2798 }
2799 activeStores.push(newStore);
2800 for (const subscription of activeSubscriptions) {
2801 subscription(newStore);
2802 }
2803 }
2804 }
2805 return { subscribe, updateStores };
2806 };
2807 return (mapSelect, isAsync) => {
2808 function updateValue() {
2809 if (lastMapResultValid && mapSelect === lastMapSelect) {
2810 return lastMapResult;
2811 }
2812 const listeningStores = { current: null };
2813 const mapResult = registry.__unstableMarkListeningStores(
2814 () => mapSelect(select, registry),
2815 listeningStores
2816 );
2817 if (true) {
2818 if (!didWarnUnstableReference) {
2819 const secondMapResult = mapSelect(select, registry);
2820 if (!external_wp_isShallowEqual_default()(mapResult, secondMapResult)) {
2821 warnOnUnstableReference(mapResult, secondMapResult);
2822 didWarnUnstableReference = true;
2823 }
2824 }
2825 }
2826 if (!subscriber) {
2827 for (const name of listeningStores.current) {
2828 storeStatesOnMount.set(name, getStoreState(name));
2829 }
2830 subscriber = createSubscriber(listeningStores.current);
2831 } else {
2832 subscriber.updateStores(listeningStores.current);
2833 }
2834 if (!external_wp_isShallowEqual_default()(lastMapResult, mapResult)) {
2835 lastMapResult = mapResult;
2836 }
2837 lastMapSelect = mapSelect;
2838 lastMapResultValid = true;
2839 }
2840 function getValue() {
2841 updateValue();
2842 return lastMapResult;
2843 }
2844 if (lastIsAsync && !isAsync) {
2845 lastMapResultValid = false;
2846 renderQueue.cancel(queueContext);
2847 }
2848 updateValue();
2849 lastIsAsync = isAsync;
2850 return { subscribe: subscriber.subscribe, getValue };
2851 };
2852}
2853function _useStaticSelect(storeName) {
2854 return useRegistry().select(storeName);
2855}
2856function _useMappingSelect(suspense, mapSelect, deps) {
2857 const registry = useRegistry();
2858 const isAsync = useAsyncMode();
2859 const store = (0,external_wp_element_namespaceObject.useMemo)(
2860 () => Store(registry, suspense),
2861 [registry, suspense]
2862 );
2863 const selector = (0,external_wp_element_namespaceObject.useCallback)(mapSelect, deps);
2864 const { subscribe, getValue } = store(selector, isAsync);
2865 const result = (0,external_wp_element_namespaceObject.useSyncExternalStore)(subscribe, getValue, getValue);
2866 (0,external_wp_element_namespaceObject.useDebugValue)(result);
2867 return result;
2868}
2869function useSelect(mapSelect, deps) {
2870 const staticSelectMode = typeof mapSelect !== "function";
2871 const staticSelectModeRef = (0,external_wp_element_namespaceObject.useRef)(staticSelectMode);
2872 if (staticSelectMode !== staticSelectModeRef.current) {
2873 const prevMode = staticSelectModeRef.current ? "static" : "mapping";
2874 const nextMode = staticSelectMode ? "static" : "mapping";
2875 throw new Error(
2876 `Switching useSelect from ${prevMode} to ${nextMode} is not allowed`
2877 );
2878 }
2879 return staticSelectMode ? _useStaticSelect(mapSelect) : _useMappingSelect(false, mapSelect, deps);
2880}
2881function useSuspenseSelect(mapSelect, deps) {
2882 return _useMappingSelect(true, mapSelect, deps);
2883}
2884
2885
2886;// ./node_modules/@wordpress/data/build-module/components/with-select/index.js
2887
2888
2889
2890const withSelect = (mapSelectToProps) => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(
2891 (WrappedComponent) => (0,external_wp_compose_namespaceObject.pure)((ownProps) => {
2892 const mapSelect = (select, registry) => mapSelectToProps(select, ownProps, registry);
2893 const mergeProps = useSelect(mapSelect);
2894 return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { ...ownProps, ...mergeProps });
2895 }),
2896 "withSelect"
2897);
2898var with_select_default = withSelect;
2899
2900
2901;// ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch-with-map.js
2902
2903
2904
2905const useDispatchWithMap = (dispatchMap, deps) => {
2906 const registry = useRegistry();
2907 const currentDispatchMapRef = (0,external_wp_element_namespaceObject.useRef)(dispatchMap);
2908 (0,external_wp_compose_namespaceObject.useIsomorphicLayoutEffect)(() => {
2909 currentDispatchMapRef.current = dispatchMap;
2910 });
2911 return (0,external_wp_element_namespaceObject.useMemo)(() => {
2912 const currentDispatchProps = currentDispatchMapRef.current(
2913 registry.dispatch,
2914 registry
2915 );
2916 return Object.fromEntries(
2917 Object.entries(currentDispatchProps).map(
2918 ([propName, dispatcher]) => {
2919 if (typeof dispatcher !== "function") {
2920 console.warn(
2921 `Property ${propName} returned from dispatchMap in useDispatchWithMap must be a function.`
2922 );
2923 }
2924 return [
2925 propName,
2926 (...args) => currentDispatchMapRef.current(registry.dispatch, registry)[propName](...args)
2927 ];
2928 }
2929 )
2930 );
2931 }, [registry, ...deps]);
2932};
2933var use_dispatch_with_map_default = useDispatchWithMap;
2934
2935
2936;// ./node_modules/@wordpress/data/build-module/components/with-dispatch/index.js
2937
2938
2939
2940const withDispatch = (mapDispatchToProps) => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(
2941 (WrappedComponent) => (ownProps) => {
2942 const mapDispatch = (dispatch, registry) => mapDispatchToProps(dispatch, ownProps, registry);
2943 const dispatchProps = use_dispatch_with_map_default(mapDispatch, []);
2944 return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { ...ownProps, ...dispatchProps });
2945 },
2946 "withDispatch"
2947);
2948var with_dispatch_default = withDispatch;
2949
2950
2951;// ./node_modules/@wordpress/data/build-module/components/with-registry/index.js
2952
2953
2954
2955const withRegistry = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(
2956 (OriginalComponent) => (props) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RegistryConsumer, { children: (registry) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(OriginalComponent, { ...props, registry }) }),
2957 "withRegistry"
2958);
2959var with_registry_default = withRegistry;
2960
2961
2962;// ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch.js
2963
2964const useDispatch = (storeNameOrDescriptor) => {
2965 const { dispatch } = useRegistry();
2966 return storeNameOrDescriptor === void 0 ? dispatch : dispatch(storeNameOrDescriptor);
2967};
2968var use_dispatch_default = useDispatch;
2969
2970
2971;// ./node_modules/@wordpress/data/build-module/dispatch.js
2972
2973function dispatch_dispatch(storeNameOrDescriptor) {
2974 return default_registry_default.dispatch(storeNameOrDescriptor);
2975}
2976
2977
2978;// ./node_modules/@wordpress/data/build-module/select.js
2979
2980function select_select(storeNameOrDescriptor) {
2981 return default_registry_default.select(storeNameOrDescriptor);
2982}
2983
2984
2985;// ./node_modules/@wordpress/data/build-module/index.js
2986
2987
2988
2989
2990
2991
2992
2993
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003const build_module_combineReducers = combine_reducers_combineReducers;
3004const build_module_resolveSelect = default_registry_default.resolveSelect;
3005const suspendSelect = default_registry_default.suspendSelect;
3006const subscribe = default_registry_default.subscribe;
3007const registerGenericStore = default_registry_default.registerGenericStore;
3008const registerStore = default_registry_default.registerStore;
3009const use = default_registry_default.use;
3010const register = default_registry_default.register;
3011
3012
3013(window.wp = window.wp || {}).data = __webpack_exports__;
3014/******/ })()
3015;