Server : Apache System : Linux 122.228.205.92.host.secureserver.net 5.14.0-362.18.1.el9_3.x86_64 #1 SMP PREEMPT_DYNAMIC Mon Jan 29 07:05:48 EST 2024 x86_64 User : ondostategov ( 1002) PHP Version : 8.1.33 Disable Function : NONE Directory : /home/ondostategov/public_html/wp-includes/js/dist/ |
/******/ (() => { // 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__;
/******/ })()
;