#$@%#$%!

Ngiler SH3LL 360
: / home / likhxapw / securitysolution.com.bd / wp-includes / js / dist /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	63.250.38.10
System	Linux premium90.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
User	likhxapw
PHP Version	8.3.30
Software	LiteSpeed
Doc root	Writable

Edit File : data.js \| Size : 88.15 KB
/****/ (() => { // webpackBootstrap /**/ "use strict"; /**/ var __webpack_modules__ = ({ // 66: // ((module) => { var isMergeableObject = function isMergeableObject(value) { return isNonNullObject(value) && !isSpecial(value) }; function isNonNullObject(value) { return !!value && typeof value === 'object' } function isSpecial(value) { var stringValue = Object.prototype.toString.call(value); return stringValue === '[object RegExp]' \|\| stringValue === '[object Date]' \|\| isReactElement(value) } // see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25 var canUseSymbol = typeof Symbol === 'function' && Symbol.for; var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7; function isReactElement(value) { return value.$$typeof === REACT_ELEMENT_TYPE } function emptyTarget(val) { return Array.isArray(val) ? [] : {} } function cloneUnlessOtherwiseSpecified(value, options) { return (options.clone !== false && options.isMergeableObject(value)) ? deepmerge(emptyTarget(value), value, options) : value } function defaultArrayMerge(target, source, options) { return target.concat(source).map(function(element) { return cloneUnlessOtherwiseSpecified(element, options) }) } function getMergeFunction(key, options) { if (!options.customMerge) { return deepmerge } var customMerge = options.customMerge(key); return typeof customMerge === 'function' ? customMerge : deepmerge } function getEnumerableOwnPropertySymbols(target) { return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) { return Object.propertyIsEnumerable.call(target, symbol) }) : [] } function getKeys(target) { return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target)) } function propertyIsOnObject(object, property) { try { return property in object } catch(_) { return false } } // Protects from prototype poisoning and unexpected merging up the prototype chain. function propertyIsUnsafe(target, key) { return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet, && !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain, && Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable. } function mergeObject(target, source, options) { var destination = {}; if (options.isMergeableObject(target)) { getKeys(target).forEach(function(key) { destination[key] = cloneUnlessOtherwiseSpecified(target[key], options); }); } getKeys(source).forEach(function(key) { if (propertyIsUnsafe(target, key)) { return } if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) { destination[key] = getMergeFunction(key, options)(target[key], source[key], options); } else { destination[key] = cloneUnlessOtherwiseSpecified(source[key], options); } }); return destination } function deepmerge(target, source, options) { options = options \|\| {}; options.arrayMerge = options.arrayMerge \|\| defaultArrayMerge; options.isMergeableObject = options.isMergeableObject \|\| isMergeableObject; // cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge() // implementations can use it. The caller may not replace it. options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified; var sourceIsArray = Array.isArray(source); var targetIsArray = Array.isArray(target); var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray; if (!sourceAndTargetTypesMatch) { return cloneUnlessOtherwiseSpecified(source, options) } else if (sourceIsArray) { return options.arrayMerge(target, source, options) } else { return mergeObject(target, source, options) } } deepmerge.all = function deepmergeAll(array, options) { if (!Array.isArray(array)) { throw new Error('first argument should be an array') } return array.reduce(function(prev, next) { return deepmerge(prev, next, options) }, {}) }; var deepmerge_1 = deepmerge; module.exports = deepmerge_1; // }), // 3249: // ((module) => { function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function (obj) { return typeof obj; }; } else { _typeof = function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable \|\| false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } /* * Given an instance of EquivalentKeyMap, returns its internal value pair tuple * for a key, if one exists. The tuple members consist of the last reference * value for the key (used in efficient subsequent lookups) and the value * assigned for the key at the leaf node. * * @param {EquivalentKeyMap} instance EquivalentKeyMap instance. * @param {} key The key for which to return value pair. * @return {?Array} Value pair, if exists. / function getValuePair(instance, key) { var _map = instance._map, _arrayTreeMap = instance._arrayTreeMap, _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the // value, which can be used to shortcut immediately to the value. if (_map.has(key)) { return _map.get(key); } // Sort keys to ensure stable retrieval from tree. var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value. var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap; for (var i = 0; i < properties.length; i++) { var property = properties[i]; map = map.get(property); if (map === undefined) { return; } var propertyValue = key[property]; map = map.get(propertyValue); if (map === undefined) { return; } } var valuePair = map.get('_ekm_value'); if (!valuePair) { return; } // If reached, it implies that an object-like key was set with another // reference, so delete the reference and replace with the current. _map.delete(valuePair[0]); valuePair[0] = key; map.set('_ekm_value', valuePair); _map.set(key, valuePair); return valuePair; } /* * Variant of a Map object which enables lookup by equivalent (deeply equal) * object and array keys. / var EquivalentKeyMap = /#__PURE__/ function () { /* * Constructs a new instance of EquivalentKeyMap. * * @param {Iterable.<>} iterable Initial pair of key, value for map. / function EquivalentKeyMap(iterable) { _classCallCheck(this, EquivalentKeyMap); this.clear(); if (iterable instanceof EquivalentKeyMap) { // Map#forEach is only means of iterating with support for IE11. var iterablePairs = []; iterable.forEach(function (value, key) { iterablePairs.push([key, value]); }); iterable = iterablePairs; } if (iterable != null) { for (var i = 0; i < iterable.length; i++) { this.set(iterable[i][0], iterable[i][1]); } } } /** * Accessor property returning the number of elements. * * @return {number} Number of elements. / _createClass(EquivalentKeyMap, [{ key: "set", /* * Add or update an element with a specified key and value. * * @param {} key The key of the element to add. @param {} value The value of the element to add. * @return {EquivalentKeyMap} Map instance. / value: function set(key, value) { // Shortcut non-object-like to set on internal Map. if (key === null \|\| _typeof(key) !== 'object') { this._map.set(key, value); return this; } // Sort keys to ensure stable assignment into tree. var properties = Object.keys(key).sort(); var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value. var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap; for (var i = 0; i < properties.length; i++) { var property = properties[i]; if (!map.has(property)) { map.set(property, new EquivalentKeyMap()); } map = map.get(property); var propertyValue = key[property]; if (!map.has(propertyValue)) { map.set(propertyValue, new EquivalentKeyMap()); } map = map.get(propertyValue); } // If an _ekm_value exists, there was already an equivalent key. Before // overriding, ensure that the old key reference is removed from map to // avoid memory leak of accumulating equivalent keys. This is, in a // sense, a poor man's WeakMap, while still enabling iterability. var previousValuePair = map.get('_ekm_value'); if (previousValuePair) { this._map.delete(previousValuePair[0]); } map.set('_ekm_value', valuePair); this._map.set(key, valuePair); return this; } /* * Returns a specified element. * * @param {} key The key of the element to return. * @return {?} The element associated with the specified key or undefined if the key can't be found. / }, { key: "get", value: function get(key) { // Shortcut non-object-like to get from internal Map. if (key === null \|\| _typeof(key) !== 'object') { return this._map.get(key); } var valuePair = getValuePair(this, key); if (valuePair) { return valuePair[1]; } } /* * Returns a boolean indicating whether an element with the specified key * exists or not. * * @param {} key The key of the element to test for presence. * @return {boolean} Whether an element with the specified key exists. / }, { key: "has", value: function has(key) { if (key === null \|\| _typeof(key) !== 'object') { return this._map.has(key); } // Test on the _presence_ of the pair, not its value, as even undefined // can be a valid member value for a key. return getValuePair(this, key) !== undefined; } /* * Removes the specified element. * * @param {} key The key of the element to remove. * @return {boolean} Returns true if an element existed and has been * removed, or false if the element does not exist. / }, { key: "delete", value: function _delete(key) { if (!this.has(key)) { return false; } // This naive implementation will leave orphaned child trees. A better // implementation should traverse and remove orphans. this.set(key, undefined); return true; } /* * Executes a provided function once per each key/value pair, in insertion * order. * * @param {Function} callback Function to execute for each element. * @param {} thisArg Value to use as `this` when executing `callback`. / }, { key: "forEach", value: function forEach(callback) { var _this = this; var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this; this._map.forEach(function (value, key) { // Unwrap value from object-like value pair. if (key !== null && _typeof(key) === 'object') { value = value[1]; } callback.call(thisArg, value, key, _this); }); } /* * Removes all elements. / }, { key: "clear", value: function clear() { this._map = new Map(); this._arrayTreeMap = new Map(); this._objectTreeMap = new Map(); } }, { key: "size", get: function get() { return this._map.size; } }]); return EquivalentKeyMap; }(); module.exports = EquivalentKeyMap; // }) /**/ }); /********************************************************************/ /**/ // The module cache /**/ var __webpack_module_cache__ = {}; /**/ /**/ // The require function /**/ function __webpack_require__(moduleId) { /**/ // Check if module is in cache /**/ var cachedModule = __webpack_module_cache__[moduleId]; /**/ if (cachedModule !== undefined) { /**/ return cachedModule.exports; /**/ } /**/ // Create a new module (and put it into the cache) /**/ var module = __webpack_module_cache__[moduleId] = { /**/ // no module.id needed /**/ // no module.loaded needed /**/ exports: {} /**/ }; /**/ /**/ // Execute the module function /**/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__); /**/ /**/ // Return the exports of the module /**/ return module.exports; /**/ } /**/ /********************************************************************/ /***/ / webpack/runtime/compat get default export / /***/ (() => { /**/ // getDefaultExport function for compatibility with non-harmony modules /**/ __webpack_require__.n = (module) => { /**/ var getter = module && module.__esModule ? /**/ () => (module['default']) : /**/ () => (module); /**/ __webpack_require__.d(getter, { a: getter }); /**/ return getter; /**/ }; /**/ })(); /**/ /***/ / webpack/runtime/define property getters / /***/ (() => { /**/ // define getter functions for harmony exports /**/ __webpack_require__.d = (exports, definition) => { /**/ for(var key in definition) { /**/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { /**/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); /**/ } /**/ } /**/ }; /**/ })(); /**/ /***/ / webpack/runtime/hasOwnProperty shorthand / /***/ (() => { /**/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) /**/ })(); /**/ /***/ / webpack/runtime/make namespace object / /***/ (() => { /**/ // define __esModule on exports /**/ __webpack_require__.r = (exports) => { /**/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { /**/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); /**/ } /**/ Object.defineProperty(exports, '__esModule', { value: true }); /**/ }; /**/ })(); /**/ /*********************************************************************/ var __webpack_exports__ = {}; // ESM COMPAT FLAG __webpack_require__.r(__webpack_exports__); // EXPORTS __webpack_require__.d(__webpack_exports__, { AsyncModeProvider: () => (/ reexport / context_context_default), RegistryConsumer: () => (/ reexport / RegistryConsumer), RegistryProvider: () => (/ reexport / context_default), combineReducers: () => (/ binding / build_module_combineReducers), controls: () => (/ reexport / controls), createReduxStore: () => (/ reexport / createReduxStore), createRegistry: () => (/ reexport / createRegistry), createRegistryControl: () => (/ reexport / createRegistryControl), createRegistrySelector: () => (/ reexport / createRegistrySelector), createSelector: () => (/ reexport / rememo), dispatch: () => (/ reexport / dispatch_dispatch), plugins: () => (/ reexport / plugins_namespaceObject), register: () => (/ binding / register), registerGenericStore: () => (/ binding / registerGenericStore), registerStore: () => (/ binding / registerStore), resolveSelect: () => (/ binding / build_module_resolveSelect), select: () => (/ reexport / select_select), subscribe: () => (/ binding / subscribe), suspendSelect: () => (/ binding / suspendSelect), use: () => (/ binding / use), useDispatch: () => (/ reexport / use_dispatch_default), useRegistry: () => (/ reexport / useRegistry), useSelect: () => (/ reexport / useSelect), useSuspenseSelect: () => (/ reexport / useSuspenseSelect), withDispatch: () => (/ reexport / with_dispatch_default), withRegistry: () => (/ reexport / with_registry_default), withSelect: () => (/ reexport / with_select_default) }); // NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js var selectors_namespaceObject = {}; __webpack_require__.r(selectors_namespaceObject); __webpack_require__.d(selectors_namespaceObject, { countSelectorsByStatus: () => (countSelectorsByStatus), getCachedResolvers: () => (getCachedResolvers), getIsResolving: () => (getIsResolving), getResolutionError: () => (getResolutionError), getResolutionState: () => (getResolutionState), hasFinishedResolution: () => (hasFinishedResolution), hasResolutionFailed: () => (hasResolutionFailed), hasResolvingSelectors: () => (hasResolvingSelectors), hasStartedResolution: () => (hasStartedResolution), isResolving: () => (isResolving) }); // NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js var actions_namespaceObject = {}; __webpack_require__.r(actions_namespaceObject); __webpack_require__.d(actions_namespaceObject, { failResolution: () => (failResolution), failResolutions: () => (failResolutions), finishResolution: () => (finishResolution), finishResolutions: () => (finishResolutions), invalidateResolution: () => (invalidateResolution), invalidateResolutionForStore: () => (invalidateResolutionForStore), invalidateResolutionForStoreSelector: () => (invalidateResolutionForStoreSelector), startResolution: () => (startResolution), startResolutions: () => (startResolutions) }); // NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/plugins/index.js var plugins_namespaceObject = {}; __webpack_require__.r(plugins_namespaceObject); __webpack_require__.d(plugins_namespaceObject, { persistence: () => (persistence_default) }); ;// external ["wp","deprecated"] const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"]; var external_wp_deprecated_default = /#__PURE__/__webpack_require__.n(external_wp_deprecated_namespaceObject); ;// ./node_modules/redux/dist/redux.mjs // src/utils/formatProdErrorMessage.ts function formatProdErrorMessage(code) { 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. `; } // src/utils/symbol-observable.ts var $$observable = / @__PURE__ / (() => typeof Symbol === "function" && Symbol.observable \|\| "@@observable")(); var symbol_observable_default = $$observable; // src/utils/actionTypes.ts var randomString = () => Math.random().toString(36).substring(7).split("").join("."); var ActionTypes = { INIT: `@@redux/INIT${/ @__PURE__ / randomString()}`, REPLACE: `@@redux/REPLACE${/ @__PURE__ / randomString()}`, PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}` }; var actionTypes_default = ActionTypes; // src/utils/isPlainObject.ts function isPlainObject(obj) { if (typeof obj !== "object" \|\| obj === null) return false; let proto = obj; while (Object.getPrototypeOf(proto) !== null) { proto = Object.getPrototypeOf(proto); } return Object.getPrototypeOf(obj) === proto \|\| Object.getPrototypeOf(obj) === null; } // src/utils/kindOf.ts function miniKindOf(val) { if (val === void 0) return "undefined"; if (val === null) return "null"; const type = typeof val; switch (type) { case "boolean": case "string": case "number": case "symbol": case "function": { return type; } } if (Array.isArray(val)) return "array"; if (isDate(val)) return "date"; if (isError(val)) return "error"; const constructorName = ctorName(val); switch (constructorName) { case "Symbol": case "Promise": case "WeakMap": case "WeakSet": case "Map": case "Set": return constructorName; } return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, ""); } function ctorName(val) { return typeof val.constructor === "function" ? val.constructor.name : null; } function isError(val) { return val instanceof Error \|\| typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number"; } function isDate(val) { if (val instanceof Date) return true; return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function"; } function kindOf(val) { let typeOfVal = typeof val; if (false) {} return typeOfVal; } // src/createStore.ts function createStore(reducer, preloadedState, enhancer) { if (typeof reducer !== "function") { throw new Error( true ? formatProdErrorMessage(2) : 0); } if (typeof preloadedState === "function" && typeof enhancer === "function" \|\| typeof enhancer === "function" && typeof arguments[3] === "function") { throw new Error( true ? formatProdErrorMessage(0) : 0); } if (typeof preloadedState === "function" && typeof enhancer === "undefined") { enhancer = preloadedState; preloadedState = void 0; } if (typeof enhancer !== "undefined") { if (typeof enhancer !== "function") { throw new Error( true ? formatProdErrorMessage(1) : 0); } return enhancer(createStore)(reducer, preloadedState); } let currentReducer = reducer; let currentState = preloadedState; let currentListeners = / @__PURE__ / new Map(); let nextListeners = currentListeners; let listenerIdCounter = 0; let isDispatching = false; function ensureCanMutateNextListeners() { if (nextListeners === currentListeners) { nextListeners = / @__PURE__ / new Map(); currentListeners.forEach((listener, key) => { nextListeners.set(key, listener); }); } } function getState() { if (isDispatching) { throw new Error( true ? formatProdErrorMessage(3) : 0); } return currentState; } function subscribe(listener) { if (typeof listener !== "function") { throw new Error( true ? formatProdErrorMessage(4) : 0); } if (isDispatching) { throw new Error( true ? formatProdErrorMessage(5) : 0); } let isSubscribed = true; ensureCanMutateNextListeners(); const listenerId = listenerIdCounter++; nextListeners.set(listenerId, listener); return function unsubscribe() { if (!isSubscribed) { return; } if (isDispatching) { throw new Error( true ? formatProdErrorMessage(6) : 0); } isSubscribed = false; ensureCanMutateNextListeners(); nextListeners.delete(listenerId); currentListeners = null; }; } function dispatch(action) { if (!isPlainObject(action)) { throw new Error( true ? formatProdErrorMessage(7) : 0); } if (typeof action.type === "undefined") { throw new Error( true ? formatProdErrorMessage(8) : 0); } if (typeof action.type !== "string") { throw new Error( true ? formatProdErrorMessage(17) : 0); } if (isDispatching) { throw new Error( true ? formatProdErrorMessage(9) : 0); } try { isDispatching = true; currentState = currentReducer(currentState, action); } finally { isDispatching = false; } const listeners = currentListeners = nextListeners; listeners.forEach((listener) => { listener(); }); return action; } function replaceReducer(nextReducer) { if (typeof nextReducer !== "function") { throw new Error( true ? formatProdErrorMessage(10) : 0); } currentReducer = nextReducer; dispatch({ type: actionTypes_default.REPLACE }); } function observable() { const outerSubscribe = subscribe; return { /* * The minimal observable subscription method. * @param observer Any object that can be used as an observer. * The observer object should have a `next` method. * @returns An object with an `unsubscribe` method that can * be used to unsubscribe the observable from the store, and prevent further * emission of values from the observable. / subscribe(observer) { if (typeof observer !== "object" \|\| observer === null) { throw new Error( true ? formatProdErrorMessage(11) : 0); } function observeState() { const observerAsObserver = observer; if (observerAsObserver.next) { observerAsObserver.next(getState()); } } observeState(); const unsubscribe = outerSubscribe(observeState); return { unsubscribe }; }, [symbol_observable_default]() { return this; } }; } dispatch({ type: actionTypes_default.INIT }); const store = { dispatch, subscribe, getState, replaceReducer, [symbol_observable_default]: observable }; return store; } function legacy_createStore(reducer, preloadedState, enhancer) { return createStore(reducer, preloadedState, enhancer); } // src/utils/warning.ts function warning(message) { if (typeof console !== "undefined" && typeof console.error === "function") { console.error(message); } try { throw new Error(message); } catch (e) { } } // src/combineReducers.ts function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) { const reducerKeys = Object.keys(reducers); const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer"; if (reducerKeys.length === 0) { return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers."; } if (!isPlainObject(inputState)) { return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`; } const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]); unexpectedKeys.forEach((key) => { unexpectedKeyCache[key] = true; }); if (action && action.type === actionTypes_default.REPLACE) return; if (unexpectedKeys.length > 0) { 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.`; } } function assertReducerShape(reducers) { Object.keys(reducers).forEach((key) => { const reducer = reducers[key]; const initialState = reducer(void 0, { type: actionTypes_default.INIT }); if (typeof initialState === "undefined") { throw new Error( true ? formatProdErrorMessage(12) : 0); } if (typeof reducer(void 0, { type: actionTypes_default.PROBE_UNKNOWN_ACTION() }) === "undefined") { throw new Error( true ? formatProdErrorMessage(13) : 0); } }); } function combineReducers(reducers) { const reducerKeys = Object.keys(reducers); const finalReducers = {}; for (let i = 0; i < reducerKeys.length; i++) { const key = reducerKeys[i]; if (false) {} if (typeof reducers[key] === "function") { finalReducers[key] = reducers[key]; } } const finalReducerKeys = Object.keys(finalReducers); let unexpectedKeyCache; if (false) {} let shapeAssertionError; try { assertReducerShape(finalReducers); } catch (e) { shapeAssertionError = e; } return function combination(state = {}, action) { if (shapeAssertionError) { throw shapeAssertionError; } if (false) {} let hasChanged = false; const nextState = {}; for (let i = 0; i < finalReducerKeys.length; i++) { const key = finalReducerKeys[i]; const reducer = finalReducers[key]; const previousStateForKey = state[key]; const nextStateForKey = reducer(previousStateForKey, action); if (typeof nextStateForKey === "undefined") { const actionType = action && action.type; throw new Error( true ? formatProdErrorMessage(14) : 0); } nextState[key] = nextStateForKey; hasChanged = hasChanged \|\| nextStateForKey !== previousStateForKey; } hasChanged = hasChanged \|\| finalReducerKeys.length !== Object.keys(state).length; return hasChanged ? nextState : state; }; } // src/bindActionCreators.ts function bindActionCreator(actionCreator, dispatch) { return function(...args) { return dispatch(actionCreator.apply(this, args)); }; } function bindActionCreators(actionCreators, dispatch) { if (typeof actionCreators === "function") { return bindActionCreator(actionCreators, dispatch); } if (typeof actionCreators !== "object" \|\| actionCreators === null) { throw new Error( true ? formatProdErrorMessage(16) : 0); } const boundActionCreators = {}; for (const key in actionCreators) { const actionCreator = actionCreators[key]; if (typeof actionCreator === "function") { boundActionCreators[key] = bindActionCreator(actionCreator, dispatch); } } return boundActionCreators; } // src/compose.ts function compose(...funcs) { if (funcs.length === 0) { return (arg) => arg; } if (funcs.length === 1) { return funcs[0]; } return funcs.reduce((a, b) => (...args) => a(b(...args))); } // src/applyMiddleware.ts function applyMiddleware(...middlewares) { return (createStore2) => (reducer, preloadedState) => { const store = createStore2(reducer, preloadedState); let dispatch = () => { throw new Error( true ? formatProdErrorMessage(15) : 0); }; const middlewareAPI = { getState: store.getState, dispatch: (action, ...args) => dispatch(action, ...args) }; const chain = middlewares.map((middleware) => middleware(middlewareAPI)); dispatch = compose(...chain)(store.dispatch); return { ...store, dispatch }; }; } // src/utils/isAction.ts function isAction(action) { return isPlainObject(action) && "type" in action && typeof action.type === "string"; } //# sourceMappingURL=redux.mjs.map // EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js var equivalent_key_map = __webpack_require__(3249); var equivalent_key_map_default = /#__PURE__/__webpack_require__.n(equivalent_key_map); ;// external ["wp","reduxRoutine"] const external_wp_reduxRoutine_namespaceObject = window["wp"]["reduxRoutine"]; var external_wp_reduxRoutine_default = /#__PURE__/__webpack_require__.n(external_wp_reduxRoutine_namespaceObject); ;// external ["wp","compose"] const external_wp_compose_namespaceObject = window["wp"]["compose"]; ;// ./node_modules/@wordpress/data/build-module/redux-store/combine-reducers.js function combine_reducers_combineReducers(reducers) { const keys = Object.keys(reducers); return function combinedReducer(state = {}, action) { const nextState = {}; let hasChanged = false; for (const key of keys) { const reducer = reducers[key]; const prevStateForKey = state[key]; const nextStateForKey = reducer(prevStateForKey, action); nextState[key] = nextStateForKey; hasChanged = hasChanged \|\| nextStateForKey !== prevStateForKey; } return hasChanged ? nextState : state; }; } ;// ./node_modules/@wordpress/data/build-module/factory.js function createRegistrySelector(registrySelector) { const selectorsByRegistry = / @__PURE__ / new WeakMap(); const wrappedSelector = (...args) => { let selector = selectorsByRegistry.get(wrappedSelector.registry); if (!selector) { selector = registrySelector(wrappedSelector.registry.select); selectorsByRegistry.set(wrappedSelector.registry, selector); } return selector(...args); }; wrappedSelector.isRegistrySelector = true; return wrappedSelector; } function createRegistryControl(registryControl) { registryControl.isRegistryControl = true; return registryControl; } ;// ./node_modules/@wordpress/data/build-module/controls.js const SELECT = "@@data/SELECT"; const RESOLVE_SELECT = "@@data/RESOLVE_SELECT"; const DISPATCH = "@@data/DISPATCH"; function isObject(object) { return object !== null && typeof object === "object"; } function controls_select(storeNameOrDescriptor, selectorName, ...args) { return { type: SELECT, storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor, selectorName, args }; } function resolveSelect(storeNameOrDescriptor, selectorName, ...args) { return { type: RESOLVE_SELECT, storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor, selectorName, args }; } function dispatch(storeNameOrDescriptor, actionName, ...args) { return { type: DISPATCH, storeKey: isObject(storeNameOrDescriptor) ? storeNameOrDescriptor.name : storeNameOrDescriptor, actionName, args }; } const controls = { select: controls_select, resolveSelect, dispatch }; const builtinControls = { [SELECT]: createRegistryControl( (registry) => ({ storeKey, selectorName, args }) => registry.select(storeKey)[selectorName](...args) ), [RESOLVE_SELECT]: createRegistryControl( (registry) => ({ storeKey, selectorName, args }) => { const method = registry.select(storeKey)[selectorName].hasResolver ? "resolveSelect" : "select"; return registry[method](storeKey)[selectorName]( ...args ); } ), [DISPATCH]: createRegistryControl( (registry) => ({ storeKey, actionName, args }) => registry.dispatch(storeKey)[actionName](...args) ) }; ;// external ["wp","privateApis"] const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"]; ;// ./node_modules/@wordpress/data/build-module/lock-unlock.js const { lock, unlock } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)( "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.", "@wordpress/data" ); ;// ./node_modules/is-promise/index.mjs function isPromise(obj) { return !!obj && (typeof obj === 'object' \|\| typeof obj === 'function') && typeof obj.then === 'function'; } ;// ./node_modules/@wordpress/data/build-module/promise-middleware.js const promiseMiddleware = () => (next) => (action) => { if (isPromise(action)) { return action.then((resolvedAction) => { if (resolvedAction) { return next(resolvedAction); } }); } return next(action); }; var promise_middleware_default = promiseMiddleware; ;// ./node_modules/@wordpress/data/build-module/resolvers-cache-middleware.js const createResolversCacheMiddleware = (registry, storeName) => () => (next) => (action) => { const resolvers = registry.select(storeName).getCachedResolvers(); const resolverEntries = Object.entries(resolvers); resolverEntries.forEach(([selectorName, resolversByArgs]) => { const resolver = registry.stores[storeName]?.resolvers?.[selectorName]; if (!resolver \|\| !resolver.shouldInvalidate) { return; } resolversByArgs.forEach((value, args) => { if (value === void 0) { return; } if (value.status !== "finished" && value.status !== "error") { return; } if (!resolver.shouldInvalidate(action, ...args)) { return; } registry.dispatch(storeName).invalidateResolution(selectorName, args); }); }); return next(action); }; var resolvers_cache_middleware_default = createResolversCacheMiddleware; ;// ./node_modules/@wordpress/data/build-module/redux-store/thunk-middleware.js function createThunkMiddleware(args) { return () => (next) => (action) => { if (typeof action === "function") { return action(args); } return next(action); }; } ;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/utils.js const onSubKey = (actionProperty) => (reducer) => (state = {}, action) => { const key = action[actionProperty]; if (key === void 0) { return state; } const nextKeyState = reducer(state[key], action); if (nextKeyState === state[key]) { return state; } return { ...state, [key]: nextKeyState }; }; function selectorArgsToStateKey(args) { if (args === void 0 \|\| args === null) { return []; } const len = args.length; let idx = len; while (idx > 0 && args[idx - 1] === void 0) { idx--; } return idx === len ? args : args.slice(0, idx); } ;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/reducer.js const subKeysIsResolved = onSubKey("selectorName")((state = new (equivalent_key_map_default())(), action) => { switch (action.type) { case "START_RESOLUTION": { const nextState = new (equivalent_key_map_default())(state); nextState.set(selectorArgsToStateKey(action.args), { status: "resolving" }); return nextState; } case "FINISH_RESOLUTION": { const nextState = new (equivalent_key_map_default())(state); nextState.set(selectorArgsToStateKey(action.args), { status: "finished" }); return nextState; } case "FAIL_RESOLUTION": { const nextState = new (equivalent_key_map_default())(state); nextState.set(selectorArgsToStateKey(action.args), { status: "error", error: action.error }); return nextState; } case "START_RESOLUTIONS": { const nextState = new (equivalent_key_map_default())(state); for (const resolutionArgs of action.args) { nextState.set(selectorArgsToStateKey(resolutionArgs), { status: "resolving" }); } return nextState; } case "FINISH_RESOLUTIONS": { const nextState = new (equivalent_key_map_default())(state); for (const resolutionArgs of action.args) { nextState.set(selectorArgsToStateKey(resolutionArgs), { status: "finished" }); } return nextState; } case "FAIL_RESOLUTIONS": { const nextState = new (equivalent_key_map_default())(state); action.args.forEach((resolutionArgs, idx) => { const resolutionState = { status: "error", error: void 0 }; const error = action.errors[idx]; if (error) { resolutionState.error = error; } nextState.set( selectorArgsToStateKey(resolutionArgs), resolutionState ); }); return nextState; } case "INVALIDATE_RESOLUTION": { const nextState = new (equivalent_key_map_default())(state); nextState.delete(selectorArgsToStateKey(action.args)); return nextState; } } return state; }); const isResolved = (state = {}, action) => { switch (action.type) { case "INVALIDATE_RESOLUTION_FOR_STORE": return {}; case "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR": { if (action.selectorName in state) { const { [action.selectorName]: removedSelector, ...restState } = state; return restState; } return state; } case "START_RESOLUTION": case "FINISH_RESOLUTION": case "FAIL_RESOLUTION": case "START_RESOLUTIONS": case "FINISH_RESOLUTIONS": case "FAIL_RESOLUTIONS": case "INVALIDATE_RESOLUTION": return subKeysIsResolved(state, action); } return state; }; var reducer_default = isResolved; ;// ./node_modules/rememo/rememo.js /* @typedef {(...args: any[]) => []} GetDependants / /** @typedef {() => void} Clear / /* * @typedef {{ * getDependants: GetDependants, * clear: Clear * }} EnhancedSelector / /* * Internal cache entry. * * @typedef CacheNode * * @property {?CacheNode\|undefined} [prev] Previous node. * @property {?CacheNode\|undefined} [next] Next node. * @property {[]} args Function arguments for cache entry. @property {} val Function result. / /** * @typedef Cache * * @property {Clear} clear Function to clear cache. * @property {boolean} [isUniqueByDependants] Whether dependants are valid in * considering cache uniqueness. A cache is unique if dependents are all arrays * or objects. * @property {CacheNode?} [head] Cache head. * @property {[]} [lastDependants] Dependants from previous invocation. / /** * Arbitrary value used as key for referencing cache object in WeakMap tree. * * @type {{}} / var LEAF_KEY = {}; /* * Returns the first argument as the sole entry in an array. * * @template T * * @param {T} value Value to return. * * @return {[T]} Value returned as entry in array. / function arrayOf(value) { return [value]; } /* * Returns true if the value passed is object-like, or false otherwise. A value * is object-like if it can support property assignment, e.g. object or array. * * @param {} value Value to test. * @return {boolean} Whether value is object-like. / function isObjectLike(value) { return !!value && 'object' === typeof value; } /* * Creates and returns a new cache object. * * @return {Cache} Cache object. / function createCache() { /* @type {Cache} / var cache = { clear: function () { cache.head = null; }, }; return cache; } /* * Returns true if entries within the two arrays are strictly equal by * reference from a starting index. * * @param {[]} a First array. @param {[]} b Second array. @param {number} fromIndex Index from which to start comparison. * * @return {boolean} Whether arrays are shallowly equal. / function isShallowEqual(a, b, fromIndex) { var i; if (a.length !== b.length) { return false; } for (i = fromIndex; i < a.length; i++) { if (a[i] !== b[i]) { return false; } } return true; } /* * Returns a memoized selector function. The getDependants function argument is * called before the memoized selector and is expected to return an immutable * reference or array of references on which the selector depends for computing * its own return value. The memoize cache is preserved only as long as those * dependant references remain the same. If getDependants returns a different * reference(s), the cache is cleared and the selector value regenerated. * * @template {(...args: []) => } S * * @param {S} selector Selector function. * @param {GetDependants=} getDependants Dependant getter returning an array of * references used in cache bust consideration. / / harmony default export / function rememo(selector, getDependants) { /* @type {WeakMap<,>} / var rootCache; /* @type {GetDependants} / var normalizedGetDependants = getDependants ? getDependants : arrayOf; /* * Returns the cache for a given dependants array. When possible, a WeakMap * will be used to create a unique cache for each set of dependants. This * is feasible due to the nature of WeakMap in allowing garbage collection * to occur on entries where the key object is no longer referenced. Since * WeakMap requires the key to be an object, this is only possible when the * dependant is object-like. The root cache is created as a hierarchy where * each top-level key is the first entry in a dependants set, the value a * WeakMap where each key is the next dependant, and so on. This continues * so long as the dependants are object-like. If no dependants are object- * like, then the cache is shared across all invocations. * * @see isObjectLike * * @param {[]} dependants Selector dependants. * @return {Cache} Cache object. / function getCache(dependants) { var caches = rootCache, isUniqueByDependants = true, i, dependant, map, cache; for (i = 0; i < dependants.length; i++) { dependant = dependants[i]; // Can only compose WeakMap from object-like key. if (!isObjectLike(dependant)) { isUniqueByDependants = false; break; } // Does current segment of cache already have a WeakMap? if (caches.has(dependant)) { // Traverse into nested WeakMap. caches = caches.get(dependant); } else { // Create, set, and traverse into a new one. map = new WeakMap(); caches.set(dependant, map); caches = map; } } // We use an arbitrary (but consistent) object as key for the last item // in the WeakMap to serve as our running cache. if (!caches.has(LEAF_KEY)) { cache = createCache(); cache.isUniqueByDependants = isUniqueByDependants; caches.set(LEAF_KEY, cache); } return caches.get(LEAF_KEY); } /* * Resets root memoization cache. / function clear() { rootCache = new WeakMap(); } / eslint-disable jsdoc/check-param-names / /* * The augmented selector call, considering first whether dependants have * changed before passing it to underlying memoize function. * * @param {} source Source object for derivation. @param {...} extraArgs Additional arguments to pass to selector. * @return {} Selector result. / /* eslint-enable jsdoc/check-param-names / function callSelector(/ source, ...extraArgs /) { var len = arguments.length, cache, node, i, args, dependants; // Create copy of arguments (avoid leaking deoptimization). args = new Array(len); for (i = 0; i < len; i++) { args[i] = arguments[i]; } dependants = normalizedGetDependants.apply(null, args); cache = getCache(dependants); // If not guaranteed uniqueness by dependants (primitive type), shallow // compare against last dependants and, if references have changed, // destroy cache to recalculate result. if (!cache.isUniqueByDependants) { if ( cache.lastDependants && !isShallowEqual(dependants, cache.lastDependants, 0) ) { cache.clear(); } cache.lastDependants = dependants; } node = cache.head; while (node) { // Check whether node arguments match arguments if (!isShallowEqual(node.args, args, 1)) { node = node.next; continue; } // At this point we can assume we've found a match // Surface matched node to head if not already if (node !== cache.head) { // Adjust siblings to point to each other. /* @type {CacheNode} / (node.prev).next = node.next; if (node.next) { node.next.prev = node.prev; } node.next = cache.head; node.prev = null; /* @type {CacheNode} / (cache.head).prev = node; cache.head = node; } // Return immediately return node.val; } // No cached value found. Continue to insertion phase: node = /* @type {CacheNode} / ({ // Generate the result from original function val: selector.apply(null, args), }); // Avoid including the source object in the cache. args[0] = null; node.args = args; // Don't need to check whether node is already head, since it would // have been returned above already if it was // Shift existing head down list if (cache.head) { cache.head.prev = node; node.next = cache.head; } cache.head = node; return node.val; } callSelector.getDependants = normalizedGetDependants; callSelector.clear = clear; clear(); return /* @type {S & EnhancedSelector} / (callSelector); } ;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js function getResolutionState(state, selectorName, args) { const map = state[selectorName]; if (!map) { return; } return map.get(selectorArgsToStateKey(args)); } function getIsResolving(state, selectorName, args) { external_wp_deprecated_default()("wp.data.select( store ).getIsResolving", { since: "6.6", version: "6.8", alternative: "wp.data.select( store ).getResolutionState" }); const resolutionState = getResolutionState(state, selectorName, args); return resolutionState && resolutionState.status === "resolving"; } function hasStartedResolution(state, selectorName, args) { return getResolutionState(state, selectorName, args) !== void 0; } function hasFinishedResolution(state, selectorName, args) { const status = getResolutionState(state, selectorName, args)?.status; return status === "finished" \|\| status === "error"; } function hasResolutionFailed(state, selectorName, args) { return getResolutionState(state, selectorName, args)?.status === "error"; } function getResolutionError(state, selectorName, args) { const resolutionState = getResolutionState(state, selectorName, args); return resolutionState?.status === "error" ? resolutionState.error : null; } function isResolving(state, selectorName, args) { return getResolutionState(state, selectorName, args)?.status === "resolving"; } function getCachedResolvers(state) { return state; } function hasResolvingSelectors(state) { return Object.values(state).some( (selectorState) => ( /* * This uses the internal `_map` property of `EquivalentKeyMap` for * optimization purposes, since the `EquivalentKeyMap` implementation * does not support a `.values()` implementation. * * @see https://github.com/aduth/equivalent-key-map / Array.from(selectorState._map.values()).some( (resolution) => resolution[1]?.status === "resolving" ) ) ); } const countSelectorsByStatus = rememo( (state) => { const selectorsByStatus = {}; Object.values(state).forEach( (selectorState) => ( /* * This uses the internal `_map` property of `EquivalentKeyMap` for * optimization purposes, since the `EquivalentKeyMap` implementation * does not support a `.values()` implementation. * * @see https://github.com/aduth/equivalent-key-map / Array.from(selectorState._map.values()).forEach( (resolution) => { const currentStatus = resolution[1]?.status ?? "error"; if (!selectorsByStatus[currentStatus]) { selectorsByStatus[currentStatus] = 0; } selectorsByStatus[currentStatus]++; } ) ) ); return selectorsByStatus; }, (state) => [state] ); ;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js function startResolution(selectorName, args) { return { type: "START_RESOLUTION", selectorName, args }; } function finishResolution(selectorName, args) { return { type: "FINISH_RESOLUTION", selectorName, args }; } function failResolution(selectorName, args, error) { return { type: "FAIL_RESOLUTION", selectorName, args, error }; } function startResolutions(selectorName, args) { return { type: "START_RESOLUTIONS", selectorName, args }; } function finishResolutions(selectorName, args) { return { type: "FINISH_RESOLUTIONS", selectorName, args }; } function failResolutions(selectorName, args, errors) { return { type: "FAIL_RESOLUTIONS", selectorName, args, errors }; } function invalidateResolution(selectorName, args) { return { type: "INVALIDATE_RESOLUTION", selectorName, args }; } function invalidateResolutionForStore() { return { type: "INVALIDATE_RESOLUTION_FOR_STORE" }; } function invalidateResolutionForStoreSelector(selectorName) { return { type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR", selectorName }; } ;// ./node_modules/@wordpress/data/build-module/redux-store/index.js const trimUndefinedValues = (array) => { const result = [...array]; for (let i = result.length - 1; i >= 0; i--) { if (result[i] === void 0) { result.splice(i, 1); } } return result; }; const mapValues = (obj, callback) => Object.fromEntries( Object.entries(obj ?? {}).map(([key, value]) => [ key, callback(value, key) ]) ); const devToolsReplacer = (key, state) => { if (state instanceof Map) { return Object.fromEntries(state); } if (state instanceof window.HTMLElement) { return null; } return state; }; function createResolversCache() { const cache = {}; return { isRunning(selectorName, args) { return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args)); }, clear(selectorName, args) { if (cache[selectorName]) { cache[selectorName].delete(trimUndefinedValues(args)); } }, markAsRunning(selectorName, args) { if (!cache[selectorName]) { cache[selectorName] = new (equivalent_key_map_default())(); } cache[selectorName].set(trimUndefinedValues(args), true); } }; } function createBindingCache(getItem, bindItem) { const cache = / @__PURE__ / new WeakMap(); return { get(itemName) { const item = getItem(itemName); if (!item) { return null; } let boundItem = cache.get(item); if (!boundItem) { boundItem = bindItem(item, itemName); cache.set(item, boundItem); } return boundItem; } }; } function createPrivateProxy(publicItems, privateItems) { return new Proxy(publicItems, { get: (target, itemName) => privateItems.get(itemName) \|\| Reflect.get(target, itemName) }); } function createReduxStore(key, options) { const privateActions = {}; const privateSelectors = {}; const privateRegistrationFunctions = { privateActions, registerPrivateActions: (actions) => { Object.assign(privateActions, actions); }, privateSelectors, registerPrivateSelectors: (selectors) => { Object.assign(privateSelectors, selectors); } }; const storeDescriptor = { name: key, instantiate: (registry) => { const listeners = / @__PURE__ / new Set(); const reducer = options.reducer; const thunkArgs = { registry, get dispatch() { return thunkDispatch; }, get select() { return thunkSelect; }, get resolveSelect() { return resolveSelectors; } }; const store = instantiateReduxStore( key, options, registry, thunkArgs ); lock(store, privateRegistrationFunctions); const resolversCache = createResolversCache(); function bindAction(action) { return (...args) => Promise.resolve(store.dispatch(action(...args))); } const actions = { ...mapValues(actions_namespaceObject, bindAction), ...mapValues(options.actions, bindAction) }; const allActions = createPrivateProxy( actions, createBindingCache( (name) => privateActions[name], bindAction ) ); const thunkDispatch = new Proxy( (action) => store.dispatch(action), { get: (target, name) => allActions[name] } ); lock(actions, allActions); const resolvers = options.resolvers ? mapValues(options.resolvers, mapResolver) : {}; function bindSelector(selector, selectorName) { if (selector.isRegistrySelector) { selector.registry = registry; } const boundSelector = (...args) => { args = normalize(selector, args); const state = store.__unstableOriginalGetState(); if (selector.isRegistrySelector) { selector.registry = registry; } return selector(state.root, ...args); }; boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs; const resolver = resolvers[selectorName]; if (!resolver) { boundSelector.hasResolver = false; return boundSelector; } return mapSelectorWithResolver( boundSelector, selectorName, resolver, store, resolversCache, boundMetadataSelectors ); } function bindMetadataSelector(metaDataSelector) { const boundSelector = (selectorName, selectorArgs, ...args) => { if (selectorName) { const targetSelector = options.selectors?.[selectorName]; if (targetSelector) { selectorArgs = normalize( targetSelector, selectorArgs ); } } const state = store.__unstableOriginalGetState(); return metaDataSelector( state.metadata, selectorName, selectorArgs, ...args ); }; boundSelector.hasResolver = false; return boundSelector; } const boundMetadataSelectors = mapValues( selectors_namespaceObject, bindMetadataSelector ); const boundSelectors = mapValues(options.selectors, bindSelector); const selectors = { ...boundMetadataSelectors, ...boundSelectors }; const boundPrivateSelectors = createBindingCache( (name) => privateSelectors[name], bindSelector ); const allSelectors = createPrivateProxy( selectors, boundPrivateSelectors ); for (const selectorName of Object.keys(privateSelectors)) { boundPrivateSelectors.get(selectorName); } const thunkSelect = new Proxy( (selector) => selector(store.__unstableOriginalGetState()), { get: (target, name) => allSelectors[name] } ); lock(selectors, allSelectors); const bindResolveSelector = mapResolveSelector( store, boundMetadataSelectors ); const resolveSelectors = mapValues( boundSelectors, bindResolveSelector ); const allResolveSelectors = createPrivateProxy( resolveSelectors, createBindingCache( (name) => boundPrivateSelectors.get(name), bindResolveSelector ) ); lock(resolveSelectors, allResolveSelectors); const bindSuspendSelector = mapSuspendSelector( store, boundMetadataSelectors ); const suspendSelectors = { ...boundMetadataSelectors, // no special suspense behavior ...mapValues(boundSelectors, bindSuspendSelector) }; const allSuspendSelectors = createPrivateProxy( suspendSelectors, createBindingCache( (name) => boundPrivateSelectors.get(name), bindSuspendSelector ) ); lock(suspendSelectors, allSuspendSelectors); const getSelectors = () => selectors; const getActions = () => actions; const getResolveSelectors = () => resolveSelectors; const getSuspendSelectors = () => suspendSelectors; store.__unstableOriginalGetState = store.getState; store.getState = () => store.__unstableOriginalGetState().root; const subscribe = store && ((listener) => { listeners.add(listener); return () => listeners.delete(listener); }); let lastState = store.__unstableOriginalGetState(); store.subscribe(() => { const state = store.__unstableOriginalGetState(); const hasChanged = state !== lastState; lastState = state; if (hasChanged) { for (const listener of listeners) { listener(); } } }); return { reducer, store, actions, selectors, resolvers, getSelectors, getResolveSelectors, getSuspendSelectors, getActions, subscribe }; } }; lock(storeDescriptor, privateRegistrationFunctions); return storeDescriptor; } function instantiateReduxStore(key, options, registry, thunkArgs) { const controls = { ...options.controls, ...builtinControls }; const normalizedControls = mapValues( controls, (control) => control.isRegistryControl ? control(registry) : control ); const middlewares = [ resolvers_cache_middleware_default(registry, key), promise_middleware_default, external_wp_reduxRoutine_default()(normalizedControls), createThunkMiddleware(thunkArgs) ]; const enhancers = [applyMiddleware(...middlewares)]; if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) { enhancers.push( window.__REDUX_DEVTOOLS_EXTENSION__({ name: key, instanceId: key, serialize: { replacer: devToolsReplacer } }) ); } const { reducer, initialState } = options; const enhancedReducer = combine_reducers_combineReducers({ metadata: reducer_default, root: reducer }); return createStore( enhancedReducer, { root: initialState }, (0,external_wp_compose_namespaceObject.compose)(enhancers) ); } function mapResolveSelector(store, boundMetadataSelectors) { return (selector, selectorName) => { if (!selector.hasResolver) { return async (...args) => selector.apply(null, args); } return (...args) => new Promise((resolve, reject) => { const hasFinished = () => { return boundMetadataSelectors.hasFinishedResolution( selectorName, args ); }; const finalize = (result2) => { const hasFailed = boundMetadataSelectors.hasResolutionFailed( selectorName, args ); if (hasFailed) { const error = boundMetadataSelectors.getResolutionError( selectorName, args ); reject(error); } else { resolve(result2); } }; const getResult = () => selector.apply(null, args); const result = getResult(); if (hasFinished()) { return finalize(result); } const unsubscribe = store.subscribe(() => { if (hasFinished()) { unsubscribe(); finalize(getResult()); } }); }); }; } function mapSuspendSelector(store, boundMetadataSelectors) { return (selector, selectorName) => { if (!selector.hasResolver) { return selector; } return (...args) => { const result = selector.apply(null, args); if (boundMetadataSelectors.hasFinishedResolution( selectorName, args )) { if (boundMetadataSelectors.hasResolutionFailed( selectorName, args )) { throw boundMetadataSelectors.getResolutionError( selectorName, args ); } return result; } throw new Promise((resolve) => { const unsubscribe = store.subscribe(() => { if (boundMetadataSelectors.hasFinishedResolution( selectorName, args )) { resolve(); unsubscribe(); } }); }); }; }; } function mapResolver(resolver) { if (resolver.fulfill) { return resolver; } return { ...resolver, // Copy the enumerable properties of the resolver function. fulfill: resolver // Add the fulfill method. }; } function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) { function fulfillSelector(args) { const state = store.getState(); if (resolversCache.isRunning(selectorName, args) \|\| typeof resolver.isFulfilled === "function" && resolver.isFulfilled(state, ...args)) { return; } if (boundMetadataSelectors.hasStartedResolution(selectorName, args)) { return; } resolversCache.markAsRunning(selectorName, args); setTimeout(async () => { resolversCache.clear(selectorName, args); store.dispatch( startResolution(selectorName, args) ); try { const action = resolver.fulfill(...args); if (action) { await store.dispatch(action); } store.dispatch( finishResolution(selectorName, args) ); } catch (error) { store.dispatch( failResolution(selectorName, args, error) ); } }, 0); } const selectorResolver = (...args) => { args = normalize(selector, args); fulfillSelector(args); return selector(...args); }; selectorResolver.hasResolver = true; return selectorResolver; } function normalize(selector, args) { if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) { return selector.__unstableNormalizeArgs(args); } return args; } ;// ./node_modules/@wordpress/data/build-module/store/index.js const coreDataStore = { name: "core/data", instantiate(registry) { const getCoreDataSelector = (selectorName) => (key, ...args) => { return registry.select(key)[selectorName](...args); }; const getCoreDataAction = (actionName) => (key, ...args) => { return registry.dispatch(key)[actionName](...args); }; return { getSelectors() { return Object.fromEntries( [ "getIsResolving", "hasStartedResolution", "hasFinishedResolution", "isResolving", "getCachedResolvers" ].map((selectorName) => [ selectorName, getCoreDataSelector(selectorName) ]) ); }, getActions() { return Object.fromEntries( [ "startResolution", "finishResolution", "invalidateResolution", "invalidateResolutionForStore", "invalidateResolutionForStoreSelector" ].map((actionName) => [ actionName, getCoreDataAction(actionName) ]) ); }, subscribe() { return () => () => { }; } }; } }; var store_default = coreDataStore; ;// ./node_modules/@wordpress/data/build-module/utils/emitter.js function createEmitter() { let isPaused = false; let isPending = false; const listeners = / @__PURE__ / new Set(); const notifyListeners = () => ( // We use Array.from to clone the listeners Set // This ensures that we don't run a listener // that was added as a response to another listener. Array.from(listeners).forEach((listener) => listener()) ); return { get isPaused() { return isPaused; }, subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); }, pause() { isPaused = true; }, resume() { isPaused = false; if (isPending) { isPending = false; notifyListeners(); } }, emit() { if (isPaused) { isPending = true; return; } notifyListeners(); } }; } ;// ./node_modules/@wordpress/data/build-module/registry.js function getStoreName(storeNameOrDescriptor) { return typeof storeNameOrDescriptor === "string" ? storeNameOrDescriptor : storeNameOrDescriptor.name; } function createRegistry(storeConfigs = {}, parent = null) { const stores = {}; const emitter = createEmitter(); let listeningStores = null; function globalListener() { emitter.emit(); } const subscribe = (listener, storeNameOrDescriptor) => { if (!storeNameOrDescriptor) { return emitter.subscribe(listener); } const storeName = getStoreName(storeNameOrDescriptor); const store = stores[storeName]; if (store) { return store.subscribe(listener); } if (!parent) { return emitter.subscribe(listener); } return parent.subscribe(listener, storeNameOrDescriptor); }; function select(storeNameOrDescriptor) { const storeName = getStoreName(storeNameOrDescriptor); listeningStores?.add(storeName); const store = stores[storeName]; if (store) { return store.getSelectors(); } return parent?.select(storeName); } function __unstableMarkListeningStores(callback, ref) { listeningStores = / @__PURE__ / new Set(); try { return callback.call(this); } finally { ref.current = Array.from(listeningStores); listeningStores = null; } } function resolveSelect(storeNameOrDescriptor) { const storeName = getStoreName(storeNameOrDescriptor); listeningStores?.add(storeName); const store = stores[storeName]; if (store) { return store.getResolveSelectors(); } return parent && parent.resolveSelect(storeName); } function suspendSelect(storeNameOrDescriptor) { const storeName = getStoreName(storeNameOrDescriptor); listeningStores?.add(storeName); const store = stores[storeName]; if (store) { return store.getSuspendSelectors(); } return parent && parent.suspendSelect(storeName); } function dispatch(storeNameOrDescriptor) { const storeName = getStoreName(storeNameOrDescriptor); const store = stores[storeName]; if (store) { return store.getActions(); } return parent && parent.dispatch(storeName); } function withPlugins(attributes) { return Object.fromEntries( Object.entries(attributes).map(([key, attribute]) => { if (typeof attribute !== "function") { return [key, attribute]; } return [ key, function() { return registry[key].apply(null, arguments); } ]; }) ); } function registerStoreInstance(name, createStore) { if (stores[name]) { console.error('Store "' + name + '" is already registered.'); return stores[name]; } const store = createStore(); if (typeof store.getSelectors !== "function") { throw new TypeError("store.getSelectors must be a function"); } if (typeof store.getActions !== "function") { throw new TypeError("store.getActions must be a function"); } if (typeof store.subscribe !== "function") { throw new TypeError("store.subscribe must be a function"); } store.emitter = createEmitter(); const currentSubscribe = store.subscribe; store.subscribe = (listener) => { const unsubscribeFromEmitter = store.emitter.subscribe(listener); const unsubscribeFromStore = currentSubscribe(() => { if (store.emitter.isPaused) { store.emitter.emit(); return; } listener(); }); return () => { unsubscribeFromStore?.(); unsubscribeFromEmitter?.(); }; }; stores[name] = store; store.subscribe(globalListener); if (parent) { try { unlock(store.store).registerPrivateActions( unlock(parent).privateActionsOf(name) ); unlock(store.store).registerPrivateSelectors( unlock(parent).privateSelectorsOf(name) ); } catch (e) { } } return store; } function register(store) { registerStoreInstance( store.name, () => store.instantiate(registry) ); } function registerGenericStore(name, store) { external_wp_deprecated_default()("wp.data.registerGenericStore", { since: "5.9", alternative: "wp.data.register( storeDescriptor )" }); registerStoreInstance(name, () => store); } function registerStore(storeName, options) { if (!options.reducer) { throw new TypeError("Must specify store reducer"); } const store = registerStoreInstance( storeName, () => createReduxStore(storeName, options).instantiate(registry) ); return store.store; } function batch(callback) { if (emitter.isPaused) { callback(); return; } emitter.pause(); Object.values(stores).forEach((store) => store.emitter.pause()); try { callback(); } finally { emitter.resume(); Object.values(stores).forEach( (store) => store.emitter.resume() ); } } let registry = { batch, stores, namespaces: stores, // TODO: Deprecate/remove this. subscribe, select, resolveSelect, suspendSelect, dispatch, use, register, registerGenericStore, registerStore, __unstableMarkListeningStores }; function use(plugin, options) { if (!plugin) { return; } registry = { ...registry, ...plugin(registry, options) }; return registry; } registry.register(store_default); for (const [name, config] of Object.entries(storeConfigs)) { registry.register(createReduxStore(name, config)); } if (parent) { parent.subscribe(globalListener); } const registryWithPlugins = withPlugins(registry); lock(registryWithPlugins, { privateActionsOf: (name) => { try { return unlock(stores[name].store).privateActions; } catch (e) { return {}; } }, privateSelectorsOf: (name) => { try { return unlock(stores[name].store).privateSelectors; } catch (e) { return {}; } } }); return registryWithPlugins; } ;// ./node_modules/@wordpress/data/build-module/default-registry.js var default_registry_default = createRegistry(); ;// ./node_modules/is-plain-object/dist/is-plain-object.mjs /! * is-plain-object <https://github.com/jonschlinkert/is-plain-object> * * Copyright (c) 2014-2017, Jon Schlinkert. * Released under the MIT License. / function is_plain_object_isObject(o) { return Object.prototype.toString.call(o) === '[object Object]'; } function is_plain_object_isPlainObject(o) { var ctor,prot; if (is_plain_object_isObject(o) === false) return false; // If has modified constructor ctor = o.constructor; if (ctor === undefined) return true; // If has modified prototype prot = ctor.prototype; if (is_plain_object_isObject(prot) === false) return false; // If constructor does not have an Object-specific method if (prot.hasOwnProperty('isPrototypeOf') === false) { return false; } // Most likely a plain Object return true; } // EXTERNAL MODULE: ./node_modules/deepmerge/dist/cjs.js var cjs = __webpack_require__(66); var cjs_default = /#__PURE__/__webpack_require__.n(cjs); ;// ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/object.js let objectStorage; const storage = { getItem(key) { if (!objectStorage \|\| !objectStorage[key]) { return null; } return objectStorage[key]; }, setItem(key, value) { if (!objectStorage) { storage.clear(); } objectStorage[key] = String(value); }, clear() { objectStorage = / @__PURE__ / Object.create(null); } }; var object_default = storage; ;// ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/default.js let default_storage; try { default_storage = window.localStorage; default_storage.setItem("__wpDataTestLocalStorage", ""); default_storage.removeItem("__wpDataTestLocalStorage"); } catch (error) { default_storage = object_default; } var default_default = default_storage; ;// ./node_modules/@wordpress/data/build-module/plugins/persistence/index.js const DEFAULT_STORAGE = default_default; const DEFAULT_STORAGE_KEY = "WP_DATA"; const withLazySameState = (reducer) => (state, action) => { if (action.nextState === state) { return state; } return reducer(state, action); }; function createPersistenceInterface(options) { const { storage = DEFAULT_STORAGE, storageKey = DEFAULT_STORAGE_KEY } = options; let data; function getData() { if (data === void 0) { const persisted = storage.getItem(storageKey); if (persisted === null) { data = {}; } else { try { data = JSON.parse(persisted); } catch (error) { data = {}; } } } return data; } function setData(key, value) { data = { ...data, [key]: value }; storage.setItem(storageKey, JSON.stringify(data)); } return { get: getData, set: setData }; } function persistencePlugin(registry, pluginOptions) { const persistence = createPersistenceInterface(pluginOptions); function createPersistOnChange(getState, storeName, keys) { let getPersistedState; if (Array.isArray(keys)) { const reducers = keys.reduce( (accumulator, key) => Object.assign(accumulator, { [key]: (state, action) => action.nextState[key] }), {} ); getPersistedState = withLazySameState( build_module_combineReducers(reducers) ); } else { getPersistedState = (state, action) => action.nextState; } let lastState = getPersistedState(void 0, { nextState: getState() }); return () => { const state = getPersistedState(lastState, { nextState: getState() }); if (state !== lastState) { persistence.set(storeName, state); lastState = state; } }; } return { registerStore(storeName, options) { if (!options.persist) { return registry.registerStore(storeName, options); } const persistedState = persistence.get()[storeName]; if (persistedState !== void 0) { let initialState = options.reducer(options.initialState, { type: "@@WP/PERSISTENCE_RESTORE" }); if (is_plain_object_isPlainObject(initialState) && is_plain_object_isPlainObject(persistedState)) { initialState = cjs_default()(initialState, persistedState, { isMergeableObject: is_plain_object_isPlainObject }); } else { initialState = persistedState; } options = { ...options, initialState }; } const store = registry.registerStore(storeName, options); store.subscribe( createPersistOnChange( store.getState, storeName, options.persist ) ); return store; } }; } persistencePlugin.__unstableMigrate = () => { }; var persistence_default = persistencePlugin; ;// ./node_modules/@wordpress/data/build-module/plugins/index.js ;// external "ReactJSXRuntime" const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"]; ;// external ["wp","priorityQueue"] const external_wp_priorityQueue_namespaceObject = window["wp"]["priorityQueue"]; ;// external ["wp","element"] const external_wp_element_namespaceObject = window["wp"]["element"]; ;// external ["wp","isShallowEqual"] const external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"]; var external_wp_isShallowEqual_default = /#__PURE__/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject); ;// ./node_modules/@wordpress/data/build-module/components/registry-provider/context.js const Context = (0,external_wp_element_namespaceObject.createContext)(default_registry_default); Context.displayName = "RegistryProviderContext"; const { Consumer, Provider } = Context; const RegistryConsumer = Consumer; var context_default = Provider; ;// ./node_modules/@wordpress/data/build-module/components/registry-provider/use-registry.js function useRegistry() { return (0,external_wp_element_namespaceObject.useContext)(Context); } ;// ./node_modules/@wordpress/data/build-module/components/async-mode-provider/context.js const context_Context = (0,external_wp_element_namespaceObject.createContext)(false); context_Context.displayName = "AsyncModeContext"; const { Consumer: context_Consumer, Provider: context_Provider } = context_Context; const AsyncModeConsumer = (/ unused pure expression or super / null && (context_Consumer)); var context_context_default = context_Provider; ;// ./node_modules/@wordpress/data/build-module/components/async-mode-provider/use-async-mode.js function useAsyncMode() { return (0,external_wp_element_namespaceObject.useContext)(context_Context); } ;// ./node_modules/@wordpress/data/build-module/components/use-select/index.js const renderQueue = (0,external_wp_priorityQueue_namespaceObject.createQueue)(); function warnOnUnstableReference(a, b) { if (!a \|\| !b) { return; } const keys = typeof a === "object" && typeof b === "object" ? Object.keys(a).filter((k) => a[k] !== b[k]) : []; console.warn( "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", keys.join(", ") ); } function Store(registry, suspense) { const select = suspense ? registry.suspendSelect : registry.select; const queueContext = {}; let lastMapSelect; let lastMapResult; let lastMapResultValid = false; let lastIsAsync; let subscriber; let didWarnUnstableReference; const storeStatesOnMount = / @__PURE__ / new Map(); function getStoreState(name) { return registry.stores[name]?.store?.getState?.() ?? {}; } const createSubscriber = (stores) => { const activeStores = [...stores]; const activeSubscriptions = / @__PURE__ / new Set(); function subscribe(listener) { if (lastMapResultValid) { for (const name of activeStores) { if (storeStatesOnMount.get(name) !== getStoreState(name)) { lastMapResultValid = false; } } } storeStatesOnMount.clear(); const onStoreChange = () => { lastMapResultValid = false; listener(); }; const onChange = () => { if (lastIsAsync) { renderQueue.add(queueContext, onStoreChange); } else { onStoreChange(); } }; const unsubs = []; function subscribeStore(storeName) { unsubs.push(registry.subscribe(onChange, storeName)); } for (const storeName of activeStores) { subscribeStore(storeName); } activeSubscriptions.add(subscribeStore); return () => { activeSubscriptions.delete(subscribeStore); for (const unsub of unsubs.values()) { unsub?.(); } renderQueue.cancel(queueContext); }; } function updateStores(newStores) { for (const newStore of newStores) { if (activeStores.includes(newStore)) { continue; } activeStores.push(newStore); for (const subscription of activeSubscriptions) { subscription(newStore); } } } return { subscribe, updateStores }; }; return (mapSelect, isAsync) => { function updateValue() { if (lastMapResultValid && mapSelect === lastMapSelect) { return lastMapResult; } const listeningStores = { current: null }; const mapResult = registry.__unstableMarkListeningStores( () => mapSelect(select, registry), listeningStores ); if (true) { if (!didWarnUnstableReference) { const secondMapResult = mapSelect(select, registry); if (!external_wp_isShallowEqual_default()(mapResult, secondMapResult)) { warnOnUnstableReference(mapResult, secondMapResult); didWarnUnstableReference = true; } } } if (!subscriber) { for (const name of listeningStores.current) { storeStatesOnMount.set(name, getStoreState(name)); } subscriber = createSubscriber(listeningStores.current); } else { subscriber.updateStores(listeningStores.current); } if (!external_wp_isShallowEqual_default()(lastMapResult, mapResult)) { lastMapResult = mapResult; } lastMapSelect = mapSelect; lastMapResultValid = true; } function getValue() { updateValue(); return lastMapResult; } if (lastIsAsync && !isAsync) { lastMapResultValid = false; renderQueue.cancel(queueContext); } updateValue(); lastIsAsync = isAsync; return { subscribe: subscriber.subscribe, getValue }; }; } function _useStaticSelect(storeName) { return useRegistry().select(storeName); } function _useMappingSelect(suspense, mapSelect, deps) { const registry = useRegistry(); const isAsync = useAsyncMode(); const store = (0,external_wp_element_namespaceObject.useMemo)( () => Store(registry, suspense), [registry, suspense] ); const selector = (0,external_wp_element_namespaceObject.useCallback)(mapSelect, deps); const { subscribe, getValue } = store(selector, isAsync); const result = (0,external_wp_element_namespaceObject.useSyncExternalStore)(subscribe, getValue, getValue); (0,external_wp_element_namespaceObject.useDebugValue)(result); return result; } function useSelect(mapSelect, deps) { const staticSelectMode = typeof mapSelect !== "function"; const staticSelectModeRef = (0,external_wp_element_namespaceObject.useRef)(staticSelectMode); if (staticSelectMode !== staticSelectModeRef.current) { const prevMode = staticSelectModeRef.current ? "static" : "mapping"; const nextMode = staticSelectMode ? "static" : "mapping"; throw new Error( `Switching useSelect from ${prevMode} to ${nextMode} is not allowed` ); } return staticSelectMode ? _useStaticSelect(mapSelect) : _useMappingSelect(false, mapSelect, deps); } function useSuspenseSelect(mapSelect, deps) { return _useMappingSelect(true, mapSelect, deps); } ;// ./node_modules/@wordpress/data/build-module/components/with-select/index.js const withSelect = (mapSelectToProps) => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)( (WrappedComponent) => (0,external_wp_compose_namespaceObject.pure)((ownProps) => { const mapSelect = (select, registry) => mapSelectToProps(select, ownProps, registry); const mergeProps = useSelect(mapSelect); return / @__PURE__ / (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { ...ownProps, ...mergeProps }); }), "withSelect" ); var with_select_default = withSelect; ;// ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch-with-map.js const useDispatchWithMap = (dispatchMap, deps) => { const registry = useRegistry(); const currentDispatchMapRef = (0,external_wp_element_namespaceObject.useRef)(dispatchMap); (0,external_wp_compose_namespaceObject.useIsomorphicLayoutEffect)(() => { currentDispatchMapRef.current = dispatchMap; }); return (0,external_wp_element_namespaceObject.useMemo)(() => { const currentDispatchProps = currentDispatchMapRef.current( registry.dispatch, registry ); return Object.fromEntries( Object.entries(currentDispatchProps).map( ([propName, dispatcher]) => { if (typeof dispatcher !== "function") { console.warn( `Property ${propName} returned from dispatchMap in useDispatchWithMap must be a function.` ); } return [ propName, (...args) => currentDispatchMapRef.current(registry.dispatch, registry)[propName](...args) ]; } ) ); }, [registry, ...deps]); }; var use_dispatch_with_map_default = useDispatchWithMap; ;// ./node_modules/@wordpress/data/build-module/components/with-dispatch/index.js const withDispatch = (mapDispatchToProps) => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)( (WrappedComponent) => (ownProps) => { const mapDispatch = (dispatch, registry) => mapDispatchToProps(dispatch, ownProps, registry); const dispatchProps = use_dispatch_with_map_default(mapDispatch, []); return / @__PURE__ / (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { ...ownProps, ...dispatchProps }); }, "withDispatch" ); var with_dispatch_default = withDispatch; ;// ./node_modules/@wordpress/data/build-module/components/with-registry/index.js const withRegistry = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)( (OriginalComponent) => (props) => / @__PURE__ / (0,external_ReactJSXRuntime_namespaceObject.jsx)(RegistryConsumer, { children: (registry) => / @__PURE__ / (0,external_ReactJSXRuntime_namespaceObject.jsx)(OriginalComponent, { ...props, registry }) }), "withRegistry" ); var with_registry_default = withRegistry; ;// ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch.js const useDispatch = (storeNameOrDescriptor) => { const { dispatch } = useRegistry(); return storeNameOrDescriptor === void 0 ? dispatch : dispatch(storeNameOrDescriptor); }; var use_dispatch_default = useDispatch; ;// ./node_modules/@wordpress/data/build-module/dispatch.js function dispatch_dispatch(storeNameOrDescriptor) { return default_registry_default.dispatch(storeNameOrDescriptor); } ;// ./node_modules/@wordpress/data/build-module/select.js function select_select(storeNameOrDescriptor) { return default_registry_default.select(storeNameOrDescriptor); } ;// ./node_modules/@wordpress/data/build-module/index.js const build_module_combineReducers = combine_reducers_combineReducers; const build_module_resolveSelect = default_registry_default.resolveSelect; const suspendSelect = default_registry_default.suspendSelect; const subscribe = default_registry_default.subscribe; const registerGenericStore = default_registry_default.registerGenericStore; const registerStore = default_registry_default.registerStore; const use = default_registry_default.use; const register = default_registry_default.register; (window.wp = window.wp \|\| {}).data = __webpack_exports__; /*****/ })() ; Back

Edit File : data.js | Size : 88.15 KB

/******/ (() => { // webpackBootstrap
/******/ 	"use strict";
/******/ 	var __webpack_modules__ = ({

/***/ 66:
/***/ ((module) => {

var isMergeableObject = function isMergeableObject(value) {
	return isNonNullObject(value)
		&& !isSpecial(value)
};

function isNonNullObject(value) {
	return !!value && typeof value === 'object'
}

function isSpecial(value) {
	var stringValue = Object.prototype.toString.call(value);

return stringValue === '[object RegExp]'
		|| stringValue === '[object Date]'
		|| isReactElement(value)
}

// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;

function isReactElement(value) {
	return value.$$typeof === REACT_ELEMENT_TYPE
}

function emptyTarget(val) {
	return Array.isArray(val) ? [] : {}
}

function cloneUnlessOtherwiseSpecified(value, options) {
	return (options.clone !== false && options.isMergeableObject(value))
		? deepmerge(emptyTarget(value), value, options)
		: value
}

function defaultArrayMerge(target, source, options) {
	return target.concat(source).map(function(element) {
		return cloneUnlessOtherwiseSpecified(element, options)
	})
}

function getMergeFunction(key, options) {
	if (!options.customMerge) {
		return deepmerge
	}
	var customMerge = options.customMerge(key);
	return typeof customMerge === 'function' ? customMerge : deepmerge
}

function getEnumerableOwnPropertySymbols(target) {
	return Object.getOwnPropertySymbols
		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
			return Object.propertyIsEnumerable.call(target, symbol)
		})
		: []
}

function getKeys(target) {
	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
}

function propertyIsOnObject(object, property) {
	try {
		return property in object
	} catch(_) {
		return false
	}
}

// Protects from prototype poisoning and unexpected merging up the prototype chain.
function propertyIsUnsafe(target, key) {
	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
}

if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
			destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
		} else {
			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
		}
	});
	return destination
}

function deepmerge(target, source, options) {
	options = options || {};
	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
	// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
	// implementations can use it. The caller may not replace it.
	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;

var sourceIsArray = Array.isArray(source);
	var targetIsArray = Array.isArray(target);
	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;

if (!sourceAndTargetTypesMatch) {
		return cloneUnlessOtherwiseSpecified(source, options)
	} else if (sourceIsArray) {
		return options.arrayMerge(target, source, options)
	} else {
		return mergeObject(target, source, options)
	}
}

deepmerge.all = function deepmergeAll(array, options) {
	if (!Array.isArray(array)) {
		throw new Error('first argument should be an array')
	}

return array.reduce(function(prev, next) {
		return deepmerge(prev, next, options)
	}, {})
};

var deepmerge_1 = deepmerge;

module.exports = deepmerge_1;

/***/ }),

/***/ 3249:
/***/ ((module) => {

return _typeof(obj);
}

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

/**
 * Given an instance of EquivalentKeyMap, returns its internal value pair tuple
 * for a key, if one exists. The tuple members consist of the last reference
 * value for the key (used in efficient subsequent lookups) and the value
 * assigned for the key at the leaf node.
 *
 * @param {EquivalentKeyMap} instance EquivalentKeyMap instance.
 * @param {*} key                     The key for which to return value pair.
 *
 * @return {?Array} Value pair, if exists.
 */
function getValuePair(instance, key) {
  var _map = instance._map,
      _arrayTreeMap = instance._arrayTreeMap,
      _objectTreeMap = instance._objectTreeMap; // Map keeps a reference to the last object-like key used to set the
  // value, which can be used to shortcut immediately to the value.

if (_map.has(key)) {
    return _map.get(key);
  } // Sort keys to ensure stable retrieval from tree.

var properties = Object.keys(key).sort(); // Tree by type to avoid conflicts on numeric object keys, empty value.

var map = Array.isArray(key) ? _arrayTreeMap : _objectTreeMap;

for (var i = 0; i < properties.length; i++) {
    var property = properties[i];
    map = map.get(property);

if (map === undefined) {
      return;
    }

var propertyValue = key[property];
    map = map.get(propertyValue);

if (map === undefined) {
      return;
    }
  }

var valuePair = map.get('_ekm_value');

if (!valuePair) {
    return;
  } // If reached, it implies that an object-like key was set with another
  // reference, so delete the reference and replace with the current.

_map.delete(valuePair[0]);

valuePair[0] = key;
  map.set('_ekm_value', valuePair);

_map.set(key, valuePair);

return valuePair;
}
/**
 * Variant of a Map object which enables lookup by equivalent (deeply equal)
 * object and array keys.
 */

var EquivalentKeyMap =
/*#__PURE__*/
function () {
  /**
   * Constructs a new instance of EquivalentKeyMap.
   *
   * @param {Iterable.<*>} iterable Initial pair of key, value for map.
   */
  function EquivalentKeyMap(iterable) {
    _classCallCheck(this, EquivalentKeyMap);

this.clear();

if (iterable instanceof EquivalentKeyMap) {
      // Map#forEach is only means of iterating with support for IE11.
      var iterablePairs = [];
      iterable.forEach(function (value, key) {
        iterablePairs.push([key, value]);
      });
      iterable = iterablePairs;
    }

if (iterable != null) {
      for (var i = 0; i < iterable.length; i++) {
        this.set(iterable[i][0], iterable[i][1]);
      }
    }
  }
  /**
   * Accessor property returning the number of elements.
   *
   * @return {number} Number of elements.
   */

_createClass(EquivalentKeyMap, [{
    key: "set",

/**
     * Add or update an element with a specified key and value.
     *
     * @param {*} key   The key of the element to add.
     * @param {*} value The value of the element to add.
     *
     * @return {EquivalentKeyMap} Map instance.
     */
    value: function set(key, value) {
      // Shortcut non-object-like to set on internal Map.
      if (key === null || _typeof(key) !== 'object') {
        this._map.set(key, value);

return this;
      } // Sort keys to ensure stable assignment into tree.

var properties = Object.keys(key).sort();
      var valuePair = [key, value]; // Tree by type to avoid conflicts on numeric object keys, empty value.

var map = Array.isArray(key) ? this._arrayTreeMap : this._objectTreeMap;

for (var i = 0; i < properties.length; i++) {
        var property = properties[i];

if (!map.has(property)) {
          map.set(property, new EquivalentKeyMap());
        }

map = map.get(property);
        var propertyValue = key[property];

if (!map.has(propertyValue)) {
          map.set(propertyValue, new EquivalentKeyMap());
        }

map = map.get(propertyValue);
      } // If an _ekm_value exists, there was already an equivalent key. Before
      // overriding, ensure that the old key reference is removed from map to
      // avoid memory leak of accumulating equivalent keys. This is, in a
      // sense, a poor man's WeakMap, while still enabling iterability.

var previousValuePair = map.get('_ekm_value');

if (previousValuePair) {
        this._map.delete(previousValuePair[0]);
      }

map.set('_ekm_value', valuePair);

this._map.set(key, valuePair);

return this;
    }
    /**
     * Returns a specified element.
     *
     * @param {*} key The key of the element to return.
     *
     * @return {?*} The element associated with the specified key or undefined
     *              if the key can't be found.
     */

}, {
    key: "get",
    value: function get(key) {
      // Shortcut non-object-like to get from internal Map.
      if (key === null || _typeof(key) !== 'object') {
        return this._map.get(key);
      }

var valuePair = getValuePair(this, key);

if (valuePair) {
        return valuePair[1];
      }
    }
    /**
     * Returns a boolean indicating whether an element with the specified key
     * exists or not.
     *
     * @param {*} key The key of the element to test for presence.
     *
     * @return {boolean} Whether an element with the specified key exists.
     */

}, {
    key: "has",
    value: function has(key) {
      if (key === null || _typeof(key) !== 'object') {
        return this._map.has(key);
      } // Test on the _presence_ of the pair, not its value, as even undefined
      // can be a valid member value for a key.

return getValuePair(this, key) !== undefined;
    }
    /**
     * Removes the specified element.
     *
     * @param {*} key The key of the element to remove.
     *
     * @return {boolean} Returns true if an element existed and has been
     *                   removed, or false if the element does not exist.
     */

}, {
    key: "delete",
    value: function _delete(key) {
      if (!this.has(key)) {
        return false;
      } // This naive implementation will leave orphaned child trees. A better
      // implementation should traverse and remove orphans.

this.set(key, undefined);
      return true;
    }
    /**
     * Executes a provided function once per each key/value pair, in insertion
     * order.
     *
     * @param {Function} callback Function to execute for each element.
     * @param {*}        thisArg  Value to use as `this` when executing
     *                            `callback`.
     */

}, {
    key: "forEach",
    value: function forEach(callback) {
      var _this = this;

var thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this;

this._map.forEach(function (value, key) {
        // Unwrap value from object-like value pair.
        if (key !== null && _typeof(key) === 'object') {
          value = value[1];
        }

callback.call(thisArg, value, key, _this);
      });
    }
    /**
     * Removes all elements.
     */

}, {
    key: "clear",
    value: function clear() {
      this._map = new Map();
      this._arrayTreeMap = new Map();
      this._objectTreeMap = new Map();
    }
  }, {
    key: "size",
    get: function get() {
      return this._map.size;
    }
  }]);

return EquivalentKeyMap;
}();

module.exports = EquivalentKeyMap;

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	(() => {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = (module) => {
/******/ 			var getter = module && module.__esModule ?
/******/ 				() => (module['default']) :
/******/ 				() => (module);
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() => {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (exports, definition) => {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	(() => {
/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() => {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (exports) => {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	})();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);

// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  AsyncModeProvider: () => (/* reexport */ context_context_default),
  RegistryConsumer: () => (/* reexport */ RegistryConsumer),
  RegistryProvider: () => (/* reexport */ context_default),
  combineReducers: () => (/* binding */ build_module_combineReducers),
  controls: () => (/* reexport */ controls),
  createReduxStore: () => (/* reexport */ createReduxStore),
  createRegistry: () => (/* reexport */ createRegistry),
  createRegistryControl: () => (/* reexport */ createRegistryControl),
  createRegistrySelector: () => (/* reexport */ createRegistrySelector),
  createSelector: () => (/* reexport */ rememo),
  dispatch: () => (/* reexport */ dispatch_dispatch),
  plugins: () => (/* reexport */ plugins_namespaceObject),
  register: () => (/* binding */ register),
  registerGenericStore: () => (/* binding */ registerGenericStore),
  registerStore: () => (/* binding */ registerStore),
  resolveSelect: () => (/* binding */ build_module_resolveSelect),
  select: () => (/* reexport */ select_select),
  subscribe: () => (/* binding */ subscribe),
  suspendSelect: () => (/* binding */ suspendSelect),
  use: () => (/* binding */ use),
  useDispatch: () => (/* reexport */ use_dispatch_default),
  useRegistry: () => (/* reexport */ useRegistry),
  useSelect: () => (/* reexport */ useSelect),
  useSuspenseSelect: () => (/* reexport */ useSuspenseSelect),
  withDispatch: () => (/* reexport */ with_dispatch_default),
  withRegistry: () => (/* reexport */ with_registry_default),
  withSelect: () => (/* reexport */ with_select_default)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js
var selectors_namespaceObject = {};
__webpack_require__.r(selectors_namespaceObject);
__webpack_require__.d(selectors_namespaceObject, {
  countSelectorsByStatus: () => (countSelectorsByStatus),
  getCachedResolvers: () => (getCachedResolvers),
  getIsResolving: () => (getIsResolving),
  getResolutionError: () => (getResolutionError),
  getResolutionState: () => (getResolutionState),
  hasFinishedResolution: () => (hasFinishedResolution),
  hasResolutionFailed: () => (hasResolutionFailed),
  hasResolvingSelectors: () => (hasResolvingSelectors),
  hasStartedResolution: () => (hasStartedResolution),
  isResolving: () => (isResolving)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js
var actions_namespaceObject = {};
__webpack_require__.r(actions_namespaceObject);
__webpack_require__.d(actions_namespaceObject, {
  failResolution: () => (failResolution),
  failResolutions: () => (failResolutions),
  finishResolution: () => (finishResolution),
  finishResolutions: () => (finishResolutions),
  invalidateResolution: () => (invalidateResolution),
  invalidateResolutionForStore: () => (invalidateResolutionForStore),
  invalidateResolutionForStoreSelector: () => (invalidateResolutionForStoreSelector),
  startResolution: () => (startResolution),
  startResolutions: () => (startResolutions)
});

// NAMESPACE OBJECT: ./node_modules/@wordpress/data/build-module/plugins/index.js
var plugins_namespaceObject = {};
__webpack_require__.r(plugins_namespaceObject);
__webpack_require__.d(plugins_namespaceObject, {
  persistence: () => (persistence_default)
});

;// external ["wp","deprecated"]
const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
;// ./node_modules/redux/dist/redux.mjs
// src/utils/formatProdErrorMessage.ts
function formatProdErrorMessage(code) {
  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. `;
}

// src/utils/symbol-observable.ts
var $$observable = /* @__PURE__ */ (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
var symbol_observable_default = $$observable;

// src/utils/actionTypes.ts
var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
var ActionTypes = {
  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
};
var actionTypes_default = ActionTypes;

// src/utils/isPlainObject.ts
function isPlainObject(obj) {
  if (typeof obj !== "object" || obj === null)
    return false;
  let proto = obj;
  while (Object.getPrototypeOf(proto) !== null) {
    proto = Object.getPrototypeOf(proto);
  }
  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
}

// src/utils/kindOf.ts
function miniKindOf(val) {
  if (val === void 0)
    return "undefined";
  if (val === null)
    return "null";
  const type = typeof val;
  switch (type) {
    case "boolean":
    case "string":
    case "number":
    case "symbol":
    case "function": {
      return type;
    }
  }
  if (Array.isArray(val))
    return "array";
  if (isDate(val))
    return "date";
  if (isError(val))
    return "error";
  const constructorName = ctorName(val);
  switch (constructorName) {
    case "Symbol":
    case "Promise":
    case "WeakMap":
    case "WeakSet":
    case "Map":
    case "Set":
      return constructorName;
  }
  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
}
function ctorName(val) {
  return typeof val.constructor === "function" ? val.constructor.name : null;
}
function isError(val) {
  return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
}
function isDate(val) {
  if (val instanceof Date)
    return true;
  return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
}
function kindOf(val) {
  let typeOfVal = typeof val;
  if (false) {}
  return typeOfVal;
}

// src/createStore.ts
function createStore(reducer, preloadedState, enhancer) {
  if (typeof reducer !== "function") {
    throw new Error( true ? formatProdErrorMessage(2) : 0);
  }
  if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") {
    throw new Error( true ? formatProdErrorMessage(0) : 0);
  }
  if (typeof preloadedState === "function" && typeof enhancer === "undefined") {
    enhancer = preloadedState;
    preloadedState = void 0;
  }
  if (typeof enhancer !== "undefined") {
    if (typeof enhancer !== "function") {
      throw new Error( true ? formatProdErrorMessage(1) : 0);
    }
    return enhancer(createStore)(reducer, preloadedState);
  }
  let currentReducer = reducer;
  let currentState = preloadedState;
  let currentListeners = /* @__PURE__ */ new Map();
  let nextListeners = currentListeners;
  let listenerIdCounter = 0;
  let isDispatching = false;
  function ensureCanMutateNextListeners() {
    if (nextListeners === currentListeners) {
      nextListeners = /* @__PURE__ */ new Map();
      currentListeners.forEach((listener, key) => {
        nextListeners.set(key, listener);
      });
    }
  }
  function getState() {
    if (isDispatching) {
      throw new Error( true ? formatProdErrorMessage(3) : 0);
    }
    return currentState;
  }
  function subscribe(listener) {
    if (typeof listener !== "function") {
      throw new Error( true ? formatProdErrorMessage(4) : 0);
    }
    if (isDispatching) {
      throw new Error( true ? formatProdErrorMessage(5) : 0);
    }
    let isSubscribed = true;
    ensureCanMutateNextListeners();
    const listenerId = listenerIdCounter++;
    nextListeners.set(listenerId, listener);
    return function unsubscribe() {
      if (!isSubscribed) {
        return;
      }
      if (isDispatching) {
        throw new Error( true ? formatProdErrorMessage(6) : 0);
      }
      isSubscribed = false;
      ensureCanMutateNextListeners();
      nextListeners.delete(listenerId);
      currentListeners = null;
    };
  }
  function dispatch(action) {
    if (!isPlainObject(action)) {
      throw new Error( true ? formatProdErrorMessage(7) : 0);
    }
    if (typeof action.type === "undefined") {
      throw new Error( true ? formatProdErrorMessage(8) : 0);
    }
    if (typeof action.type !== "string") {
      throw new Error( true ? formatProdErrorMessage(17) : 0);
    }
    if (isDispatching) {
      throw new Error( true ? formatProdErrorMessage(9) : 0);
    }
    try {
      isDispatching = true;
      currentState = currentReducer(currentState, action);
    } finally {
      isDispatching = false;
    }
    const listeners = currentListeners = nextListeners;
    listeners.forEach((listener) => {
      listener();
    });
    return action;
  }
  function replaceReducer(nextReducer) {
    if (typeof nextReducer !== "function") {
      throw new Error( true ? formatProdErrorMessage(10) : 0);
    }
    currentReducer = nextReducer;
    dispatch({
      type: actionTypes_default.REPLACE
    });
  }
  function observable() {
    const outerSubscribe = subscribe;
    return {
      /**
       * The minimal observable subscription method.
       * @param observer Any object that can be used as an observer.
       * The observer object should have a `next` method.
       * @returns An object with an `unsubscribe` method that can
       * be used to unsubscribe the observable from the store, and prevent further
       * emission of values from the observable.
       */
      subscribe(observer) {
        if (typeof observer !== "object" || observer === null) {
          throw new Error( true ? formatProdErrorMessage(11) : 0);
        }
        function observeState() {
          const observerAsObserver = observer;
          if (observerAsObserver.next) {
            observerAsObserver.next(getState());
          }
        }
        observeState();
        const unsubscribe = outerSubscribe(observeState);
        return {
          unsubscribe
        };
      },
      [symbol_observable_default]() {
        return this;
      }
    };
  }
  dispatch({
    type: actionTypes_default.INIT
  });
  const store = {
    dispatch,
    subscribe,
    getState,
    replaceReducer,
    [symbol_observable_default]: observable
  };
  return store;
}
function legacy_createStore(reducer, preloadedState, enhancer) {
  return createStore(reducer, preloadedState, enhancer);
}

// src/utils/warning.ts
function warning(message) {
  if (typeof console !== "undefined" && typeof console.error === "function") {
    console.error(message);
  }
  try {
    throw new Error(message);
  } catch (e) {
  }
}

// src/combineReducers.ts
function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
  const reducerKeys = Object.keys(reducers);
  const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer";
  if (reducerKeys.length === 0) {
    return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.";
  }
  if (!isPlainObject(inputState)) {
    return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`;
  }
  const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);
  unexpectedKeys.forEach((key) => {
    unexpectedKeyCache[key] = true;
  });
  if (action && action.type === actionTypes_default.REPLACE)
    return;
  if (unexpectedKeys.length > 0) {
    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.`;
  }
}
function assertReducerShape(reducers) {
  Object.keys(reducers).forEach((key) => {
    const reducer = reducers[key];
    const initialState = reducer(void 0, {
      type: actionTypes_default.INIT
    });
    if (typeof initialState === "undefined") {
      throw new Error( true ? formatProdErrorMessage(12) : 0);
    }
    if (typeof reducer(void 0, {
      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
    }) === "undefined") {
      throw new Error( true ? formatProdErrorMessage(13) : 0);
    }
  });
}
function combineReducers(reducers) {
  const reducerKeys = Object.keys(reducers);
  const finalReducers = {};
  for (let i = 0; i < reducerKeys.length; i++) {
    const key = reducerKeys[i];
    if (false) {}
    if (typeof reducers[key] === "function") {
      finalReducers[key] = reducers[key];
    }
  }
  const finalReducerKeys = Object.keys(finalReducers);
  let unexpectedKeyCache;
  if (false) {}
  let shapeAssertionError;
  try {
    assertReducerShape(finalReducers);
  } catch (e) {
    shapeAssertionError = e;
  }
  return function combination(state = {}, action) {
    if (shapeAssertionError) {
      throw shapeAssertionError;
    }
    if (false) {}
    let hasChanged = false;
    const nextState = {};
    for (let i = 0; i < finalReducerKeys.length; i++) {
      const key = finalReducerKeys[i];
      const reducer = finalReducers[key];
      const previousStateForKey = state[key];
      const nextStateForKey = reducer(previousStateForKey, action);
      if (typeof nextStateForKey === "undefined") {
        const actionType = action && action.type;
        throw new Error( true ? formatProdErrorMessage(14) : 0);
      }
      nextState[key] = nextStateForKey;
      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
    }
    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
    return hasChanged ? nextState : state;
  };
}

// src/bindActionCreators.ts
function bindActionCreator(actionCreator, dispatch) {
  return function(...args) {
    return dispatch(actionCreator.apply(this, args));
  };
}
function bindActionCreators(actionCreators, dispatch) {
  if (typeof actionCreators === "function") {
    return bindActionCreator(actionCreators, dispatch);
  }
  if (typeof actionCreators !== "object" || actionCreators === null) {
    throw new Error( true ? formatProdErrorMessage(16) : 0);
  }
  const boundActionCreators = {};
  for (const key in actionCreators) {
    const actionCreator = actionCreators[key];
    if (typeof actionCreator === "function") {
      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
    }
  }
  return boundActionCreators;
}

// src/compose.ts
function compose(...funcs) {
  if (funcs.length === 0) {
    return (arg) => arg;
  }
  if (funcs.length === 1) {
    return funcs[0];
  }
  return funcs.reduce((a, b) => (...args) => a(b(...args)));
}

// src/applyMiddleware.ts
function applyMiddleware(...middlewares) {
  return (createStore2) => (reducer, preloadedState) => {
    const store = createStore2(reducer, preloadedState);
    let dispatch = () => {
      throw new Error( true ? formatProdErrorMessage(15) : 0);
    };
    const middlewareAPI = {
      getState: store.getState,
      dispatch: (action, ...args) => dispatch(action, ...args)
    };
    const chain = middlewares.map((middleware) => middleware(middlewareAPI));
    dispatch = compose(...chain)(store.dispatch);
    return {
      ...store,
      dispatch
    };
  };
}

// src/utils/isAction.ts
function isAction(action) {
  return isPlainObject(action) && "type" in action && typeof action.type === "string";
}

//# sourceMappingURL=redux.mjs.map
// EXTERNAL MODULE: ./node_modules/equivalent-key-map/equivalent-key-map.js
var equivalent_key_map = __webpack_require__(3249);
var equivalent_key_map_default = /*#__PURE__*/__webpack_require__.n(equivalent_key_map);
;// external ["wp","reduxRoutine"]
const external_wp_reduxRoutine_namespaceObject = window["wp"]["reduxRoutine"];
var external_wp_reduxRoutine_default = /*#__PURE__*/__webpack_require__.n(external_wp_reduxRoutine_namespaceObject);
;// external ["wp","compose"]
const external_wp_compose_namespaceObject = window["wp"]["compose"];
;// ./node_modules/@wordpress/data/build-module/redux-store/combine-reducers.js
function combine_reducers_combineReducers(reducers) {
  const keys = Object.keys(reducers);
  return function combinedReducer(state = {}, action) {
    const nextState = {};
    let hasChanged = false;
    for (const key of keys) {
      const reducer = reducers[key];
      const prevStateForKey = state[key];
      const nextStateForKey = reducer(prevStateForKey, action);
      nextState[key] = nextStateForKey;
      hasChanged = hasChanged || nextStateForKey !== prevStateForKey;
    }
    return hasChanged ? nextState : state;
  };
}

;// ./node_modules/@wordpress/data/build-module/factory.js
function createRegistrySelector(registrySelector) {
  const selectorsByRegistry = /* @__PURE__ */ new WeakMap();
  const wrappedSelector = (...args) => {
    let selector = selectorsByRegistry.get(wrappedSelector.registry);
    if (!selector) {
      selector = registrySelector(wrappedSelector.registry.select);
      selectorsByRegistry.set(wrappedSelector.registry, selector);
    }
    return selector(...args);
  };
  wrappedSelector.isRegistrySelector = true;
  return wrappedSelector;
}
function createRegistryControl(registryControl) {
  registryControl.isRegistryControl = true;
  return registryControl;
}

;// ./node_modules/@wordpress/data/build-module/controls.js

;// external ["wp","privateApis"]
const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
;// ./node_modules/@wordpress/data/build-module/lock-unlock.js

const { lock, unlock } = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
  "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
  "@wordpress/data"
);

;// ./node_modules/is-promise/index.mjs
function isPromise(obj) {
  return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
}

;// ./node_modules/@wordpress/data/build-module/promise-middleware.js

;// ./node_modules/@wordpress/data/build-module/resolvers-cache-middleware.js
const createResolversCacheMiddleware = (registry, storeName) => () => (next) => (action) => {
  const resolvers = registry.select(storeName).getCachedResolvers();
  const resolverEntries = Object.entries(resolvers);
  resolverEntries.forEach(([selectorName, resolversByArgs]) => {
    const resolver = registry.stores[storeName]?.resolvers?.[selectorName];
    if (!resolver || !resolver.shouldInvalidate) {
      return;
    }
    resolversByArgs.forEach((value, args) => {
      if (value === void 0) {
        return;
      }
      if (value.status !== "finished" && value.status !== "error") {
        return;
      }
      if (!resolver.shouldInvalidate(action, ...args)) {
        return;
      }
      registry.dispatch(storeName).invalidateResolution(selectorName, args);
    });
  });
  return next(action);
};
var resolvers_cache_middleware_default = createResolversCacheMiddleware;

;// ./node_modules/@wordpress/data/build-module/redux-store/thunk-middleware.js
function createThunkMiddleware(args) {
  return () => (next) => (action) => {
    if (typeof action === "function") {
      return action(args);
    }
    return next(action);
  };
}

;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/utils.js
const onSubKey = (actionProperty) => (reducer) => (state = {}, action) => {
  const key = action[actionProperty];
  if (key === void 0) {
    return state;
  }
  const nextKeyState = reducer(state[key], action);
  if (nextKeyState === state[key]) {
    return state;
  }
  return {
    ...state,
    [key]: nextKeyState
  };
};
function selectorArgsToStateKey(args) {
  if (args === void 0 || args === null) {
    return [];
  }
  const len = args.length;
  let idx = len;
  while (idx > 0 && args[idx - 1] === void 0) {
    idx--;
  }
  return idx === len ? args : args.slice(0, idx);
}

;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/reducer.js

;// ./node_modules/rememo/rememo.js

/** @typedef {(...args: any[]) => *[]} GetDependants */

/** @typedef {() => void} Clear */

/**
 * @typedef {{
 *   getDependants: GetDependants,
 *   clear: Clear
 * }} EnhancedSelector
 */

/**
 * Internal cache entry.
 *
 * @typedef CacheNode
 *
 * @property {?CacheNode|undefined} [prev] Previous node.
 * @property {?CacheNode|undefined} [next] Next node.
 * @property {*[]} args Function arguments for cache entry.
 * @property {*} val Function result.
 */

/**
 * @typedef Cache
 *
 * @property {Clear} clear Function to clear cache.
 * @property {boolean} [isUniqueByDependants] Whether dependants are valid in
 * considering cache uniqueness. A cache is unique if dependents are all arrays
 * or objects.
 * @property {CacheNode?} [head] Cache head.
 * @property {*[]} [lastDependants] Dependants from previous invocation.
 */

/**
 * Arbitrary value used as key for referencing cache object in WeakMap tree.
 *
 * @type {{}}
 */
var LEAF_KEY = {};

/**
 * Returns the first argument as the sole entry in an array.
 *
 * @template T
 *
 * @param {T} value Value to return.
 *
 * @return {[T]} Value returned as entry in array.
 */
function arrayOf(value) {
	return [value];
}

/**
 * Returns true if the value passed is object-like, or false otherwise. A value
 * is object-like if it can support property assignment, e.g. object or array.
 *
 * @param {*} value Value to test.
 *
 * @return {boolean} Whether value is object-like.
 */
function isObjectLike(value) {
	return !!value && 'object' === typeof value;
}

/**
 * Creates and returns a new cache object.
 *
 * @return {Cache} Cache object.
 */
function createCache() {
	/** @type {Cache} */
	var cache = {
		clear: function () {
			cache.head = null;
		},
	};

return cache;
}

/**
 * Returns true if entries within the two arrays are strictly equal by
 * reference from a starting index.
 *
 * @param {*[]} a First array.
 * @param {*[]} b Second array.
 * @param {number} fromIndex Index from which to start comparison.
 *
 * @return {boolean} Whether arrays are shallowly equal.
 */
function isShallowEqual(a, b, fromIndex) {
	var i;

if (a.length !== b.length) {
		return false;
	}

for (i = fromIndex; i < a.length; i++) {
		if (a[i] !== b[i]) {
			return false;
		}
	}

return true;
}

/**
 * Returns a memoized selector function. The getDependants function argument is
 * called before the memoized selector and is expected to return an immutable
 * reference or array of references on which the selector depends for computing
 * its own return value. The memoize cache is preserved only as long as those
 * dependant references remain the same. If getDependants returns a different
 * reference(s), the cache is cleared and the selector value regenerated.
 *
 * @template {(...args: *[]) => *} S
 *
 * @param {S} selector Selector function.
 * @param {GetDependants=} getDependants Dependant getter returning an array of
 * references used in cache bust consideration.
 */
/* harmony default export */ function rememo(selector, getDependants) {
	/** @type {WeakMap<*,*>} */
	var rootCache;

/** @type {GetDependants} */
	var normalizedGetDependants = getDependants ? getDependants : arrayOf;

/**
	 * Returns the cache for a given dependants array. When possible, a WeakMap
	 * will be used to create a unique cache for each set of dependants. This
	 * is feasible due to the nature of WeakMap in allowing garbage collection
	 * to occur on entries where the key object is no longer referenced. Since
	 * WeakMap requires the key to be an object, this is only possible when the
	 * dependant is object-like. The root cache is created as a hierarchy where
	 * each top-level key is the first entry in a dependants set, the value a
	 * WeakMap where each key is the next dependant, and so on. This continues
	 * so long as the dependants are object-like. If no dependants are object-
	 * like, then the cache is shared across all invocations.
	 *
	 * @see isObjectLike
	 *
	 * @param {*[]} dependants Selector dependants.
	 *
	 * @return {Cache} Cache object.
	 */
	function getCache(dependants) {
		var caches = rootCache,
			isUniqueByDependants = true,
			i,
			dependant,
			map,
			cache;

for (i = 0; i < dependants.length; i++) {
			dependant = dependants[i];

// Can only compose WeakMap from object-like key.
			if (!isObjectLike(dependant)) {
				isUniqueByDependants = false;
				break;
			}

// Does current segment of cache already have a WeakMap?
			if (caches.has(dependant)) {
				// Traverse into nested WeakMap.
				caches = caches.get(dependant);
			} else {
				// Create, set, and traverse into a new one.
				map = new WeakMap();
				caches.set(dependant, map);
				caches = map;
			}
		}

// We use an arbitrary (but consistent) object as key for the last item
		// in the WeakMap to serve as our running cache.
		if (!caches.has(LEAF_KEY)) {
			cache = createCache();
			cache.isUniqueByDependants = isUniqueByDependants;
			caches.set(LEAF_KEY, cache);
		}

return caches.get(LEAF_KEY);
	}

/**
	 * Resets root memoization cache.
	 */
	function clear() {
		rootCache = new WeakMap();
	}

/* eslint-disable jsdoc/check-param-names */
	/**
	 * The augmented selector call, considering first whether dependants have
	 * changed before passing it to underlying memoize function.
	 *
	 * @param {*}    source    Source object for derivation.
	 * @param {...*} extraArgs Additional arguments to pass to selector.
	 *
	 * @return {*} Selector result.
	 */
	/* eslint-enable jsdoc/check-param-names */
	function callSelector(/* source, ...extraArgs */) {
		var len = arguments.length,
			cache,
			node,
			i,
			args,
			dependants;

// Create copy of arguments (avoid leaking deoptimization).
		args = new Array(len);
		for (i = 0; i < len; i++) {
			args[i] = arguments[i];
		}

dependants = normalizedGetDependants.apply(null, args);
		cache = getCache(dependants);

// If not guaranteed uniqueness by dependants (primitive type), shallow
		// compare against last dependants and, if references have changed,
		// destroy cache to recalculate result.
		if (!cache.isUniqueByDependants) {
			if (
				cache.lastDependants &&
				!isShallowEqual(dependants, cache.lastDependants, 0)
			) {
				cache.clear();
			}

cache.lastDependants = dependants;
		}

node = cache.head;
		while (node) {
			// Check whether node arguments match arguments
			if (!isShallowEqual(node.args, args, 1)) {
				node = node.next;
				continue;
			}

// At this point we can assume we've found a match

// Surface matched node to head if not already
			if (node !== cache.head) {
				// Adjust siblings to point to each other.
				/** @type {CacheNode} */ (node.prev).next = node.next;
				if (node.next) {
					node.next.prev = node.prev;
				}

node.next = cache.head;
				node.prev = null;
				/** @type {CacheNode} */ (cache.head).prev = node;
				cache.head = node;
			}

// Return immediately
			return node.val;
		}

// No cached value found. Continue to insertion phase:

node = /** @type {CacheNode} */ ({
			// Generate the result from original function
			val: selector.apply(null, args),
		});

// Avoid including the source object in the cache.
		args[0] = null;
		node.args = args;

// Don't need to check whether node is already head, since it would
		// have been returned above already if it was

// Shift existing head down list
		if (cache.head) {
			cache.head.prev = node;
			node.next = cache.head;
		}

cache.head = node;

return node.val;
	}

callSelector.getDependants = normalizedGetDependants;
	callSelector.clear = clear;
	clear();

return /** @type {S & EnhancedSelector} */ (callSelector);
}

;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/selectors.js

;// ./node_modules/@wordpress/data/build-module/redux-store/metadata/actions.js
function startResolution(selectorName, args) {
  return {
    type: "START_RESOLUTION",
    selectorName,
    args
  };
}
function finishResolution(selectorName, args) {
  return {
    type: "FINISH_RESOLUTION",
    selectorName,
    args
  };
}
function failResolution(selectorName, args, error) {
  return {
    type: "FAIL_RESOLUTION",
    selectorName,
    args,
    error
  };
}
function startResolutions(selectorName, args) {
  return {
    type: "START_RESOLUTIONS",
    selectorName,
    args
  };
}
function finishResolutions(selectorName, args) {
  return {
    type: "FINISH_RESOLUTIONS",
    selectorName,
    args
  };
}
function failResolutions(selectorName, args, errors) {
  return {
    type: "FAIL_RESOLUTIONS",
    selectorName,
    args,
    errors
  };
}
function invalidateResolution(selectorName, args) {
  return {
    type: "INVALIDATE_RESOLUTION",
    selectorName,
    args
  };
}
function invalidateResolutionForStore() {
  return {
    type: "INVALIDATE_RESOLUTION_FOR_STORE"
  };
}
function invalidateResolutionForStoreSelector(selectorName) {
  return {
    type: "INVALIDATE_RESOLUTION_FOR_STORE_SELECTOR",
    selectorName
  };
}

;// ./node_modules/@wordpress/data/build-module/redux-store/index.js

;// ./node_modules/@wordpress/data/build-module/store/index.js
const coreDataStore = {
  name: "core/data",
  instantiate(registry) {
    const getCoreDataSelector = (selectorName) => (key, ...args) => {
      return registry.select(key)[selectorName](...args);
    };
    const getCoreDataAction = (actionName) => (key, ...args) => {
      return registry.dispatch(key)[actionName](...args);
    };
    return {
      getSelectors() {
        return Object.fromEntries(
          [
            "getIsResolving",
            "hasStartedResolution",
            "hasFinishedResolution",
            "isResolving",
            "getCachedResolvers"
          ].map((selectorName) => [
            selectorName,
            getCoreDataSelector(selectorName)
          ])
        );
      },
      getActions() {
        return Object.fromEntries(
          [
            "startResolution",
            "finishResolution",
            "invalidateResolution",
            "invalidateResolutionForStore",
            "invalidateResolutionForStoreSelector"
          ].map((actionName) => [
            actionName,
            getCoreDataAction(actionName)
          ])
        );
      },
      subscribe() {
        return () => () => {
        };
      }
    };
  }
};
var store_default = coreDataStore;

;// ./node_modules/@wordpress/data/build-module/utils/emitter.js
function createEmitter() {
  let isPaused = false;
  let isPending = false;
  const listeners = /* @__PURE__ */ new Set();
  const notifyListeners = () => (
    // We use Array.from to clone the listeners Set
    // This ensures that we don't run a listener
    // that was added as a response to another listener.
    Array.from(listeners).forEach((listener) => listener())
  );
  return {
    get isPaused() {
      return isPaused;
    },
    subscribe(listener) {
      listeners.add(listener);
      return () => listeners.delete(listener);
    },
    pause() {
      isPaused = true;
    },
    resume() {
      isPaused = false;
      if (isPending) {
        isPending = false;
        notifyListeners();
      }
    },
    emit() {
      if (isPaused) {
        isPending = true;
        return;
      }
      notifyListeners();
    }
  };
}

;// ./node_modules/@wordpress/data/build-module/registry.js

;// ./node_modules/@wordpress/data/build-module/default-registry.js

var default_registry_default = createRegistry();

;// ./node_modules/is-plain-object/dist/is-plain-object.mjs
/*!
 * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
 *
 * Copyright (c) 2014-2017, Jon Schlinkert.
 * Released under the MIT License.
 */

function is_plain_object_isObject(o) {
  return Object.prototype.toString.call(o) === '[object Object]';
}

function is_plain_object_isPlainObject(o) {
  var ctor,prot;

if (is_plain_object_isObject(o) === false) return false;

// If has modified constructor
  ctor = o.constructor;
  if (ctor === undefined) return true;

// If has modified prototype
  prot = ctor.prototype;
  if (is_plain_object_isObject(prot) === false) return false;

// If constructor does not have an Object-specific method
  if (prot.hasOwnProperty('isPrototypeOf') === false) {
    return false;
  }

// Most likely a plain Object
  return true;
}

// EXTERNAL MODULE: ./node_modules/deepmerge/dist/cjs.js
var cjs = __webpack_require__(66);
var cjs_default = /*#__PURE__*/__webpack_require__.n(cjs);
;// ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/object.js
let objectStorage;
const storage = {
  getItem(key) {
    if (!objectStorage || !objectStorage[key]) {
      return null;
    }
    return objectStorage[key];
  },
  setItem(key, value) {
    if (!objectStorage) {
      storage.clear();
    }
    objectStorage[key] = String(value);
  },
  clear() {
    objectStorage = /* @__PURE__ */ Object.create(null);
  }
};
var object_default = storage;

;// ./node_modules/@wordpress/data/build-module/plugins/persistence/storage/default.js

let default_storage;
try {
  default_storage = window.localStorage;
  default_storage.setItem("__wpDataTestLocalStorage", "");
  default_storage.removeItem("__wpDataTestLocalStorage");
} catch (error) {
  default_storage = object_default;
}
var default_default = default_storage;

;// ./node_modules/@wordpress/data/build-module/plugins/persistence/index.js

;// ./node_modules/@wordpress/data/build-module/plugins/index.js

;// external "ReactJSXRuntime"
const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
;// external ["wp","priorityQueue"]
const external_wp_priorityQueue_namespaceObject = window["wp"]["priorityQueue"];
;// external ["wp","element"]
const external_wp_element_namespaceObject = window["wp"]["element"];
;// external ["wp","isShallowEqual"]
const external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"];
var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
;// ./node_modules/@wordpress/data/build-module/components/registry-provider/context.js

const Context = (0,external_wp_element_namespaceObject.createContext)(default_registry_default);
Context.displayName = "RegistryProviderContext";
const { Consumer, Provider } = Context;
const RegistryConsumer = Consumer;
var context_default = Provider;

;// ./node_modules/@wordpress/data/build-module/components/registry-provider/use-registry.js

function useRegistry() {
  return (0,external_wp_element_namespaceObject.useContext)(Context);
}

;// ./node_modules/@wordpress/data/build-module/components/async-mode-provider/context.js

const context_Context = (0,external_wp_element_namespaceObject.createContext)(false);
context_Context.displayName = "AsyncModeContext";
const { Consumer: context_Consumer, Provider: context_Provider } = context_Context;
const AsyncModeConsumer = (/* unused pure expression or super */ null && (context_Consumer));
var context_context_default = context_Provider;

;// ./node_modules/@wordpress/data/build-module/components/async-mode-provider/use-async-mode.js

function useAsyncMode() {
  return (0,external_wp_element_namespaceObject.useContext)(context_Context);
}

;// ./node_modules/@wordpress/data/build-module/components/use-select/index.js

;// ./node_modules/@wordpress/data/build-module/components/with-select/index.js

const withSelect = (mapSelectToProps) => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(
  (WrappedComponent) => (0,external_wp_compose_namespaceObject.pure)((ownProps) => {
    const mapSelect = (select, registry) => mapSelectToProps(select, ownProps, registry);
    const mergeProps = useSelect(mapSelect);
    return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { ...ownProps, ...mergeProps });
  }),
  "withSelect"
);
var with_select_default = withSelect;

;// ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch-with-map.js

;// ./node_modules/@wordpress/data/build-module/components/with-dispatch/index.js

const withDispatch = (mapDispatchToProps) => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(
  (WrappedComponent) => (ownProps) => {
    const mapDispatch = (dispatch, registry) => mapDispatchToProps(dispatch, ownProps, registry);
    const dispatchProps = use_dispatch_with_map_default(mapDispatch, []);
    return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, { ...ownProps, ...dispatchProps });
  },
  "withDispatch"
);
var with_dispatch_default = withDispatch;

;// ./node_modules/@wordpress/data/build-module/components/with-registry/index.js

const withRegistry = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(
  (OriginalComponent) => (props) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RegistryConsumer, { children: (registry) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(OriginalComponent, { ...props, registry }) }),
  "withRegistry"
);
var with_registry_default = withRegistry;

;// ./node_modules/@wordpress/data/build-module/components/use-dispatch/use-dispatch.js

const useDispatch = (storeNameOrDescriptor) => {
  const { dispatch } = useRegistry();
  return storeNameOrDescriptor === void 0 ? dispatch : dispatch(storeNameOrDescriptor);
};
var use_dispatch_default = useDispatch;

;// ./node_modules/@wordpress/data/build-module/dispatch.js

function dispatch_dispatch(storeNameOrDescriptor) {
  return default_registry_default.dispatch(storeNameOrDescriptor);
}

;// ./node_modules/@wordpress/data/build-module/select.js

function select_select(storeNameOrDescriptor) {
  return default_registry_default.select(storeNameOrDescriptor);
}

;// ./node_modules/@wordpress/data/build-module/index.js

const build_module_combineReducers = combine_reducers_combineReducers;
const build_module_resolveSelect = default_registry_default.resolveSelect;
const suspendSelect = default_registry_default.suspendSelect;
const subscribe = default_registry_default.subscribe;
const registerGenericStore = default_registry_default.registerGenericStore;
const registerStore = default_registry_default.registerStore;
const use = default_registry_default.use;
const register = default_registry_default.register;

(window.wp = window.wp || {}).data = __webpack_exports__;
/******/ })()
;

Back