Vavada Casino
UX-антипаттерны в действии – Анализ скриншотов популярных онлайн-площадок
Просматривая сотни скриншотов популярных онлайн-площадок, мы сразу же видим: навязчивое появление всплывающих окон, закрывающих контент, – явный урон пользовательскому опыту. Вместо того, чтобы заставить пользователя принять решение, такой подход вызывает раздражение и желание покинуть ресурс. Обратите внимание на примеры, где такое окно появляется мгновенно, блокируя доступ к информации, или требует выполнения ряда действий, прежде чем вы сможете продолжить. Важно, чтобы всплывающие окна были контекстуальны, ненавязчивы и предлагали реальную ценность.
Еще одна частая ошибка – перегруженность интерфейса. Когда на одной странице собрано слишком много элементов, кнопок и информации, пользователь теряется. Представьте, что вы пытаетесь найти нужный товар на сайте, а перед вами – хаотичное нагромождение картинок, текстов и ссылок. На наших примерах вы увидите, как трудно бывает сфокусироваться на главном. Стремитесь к минимализму: оставляйте только то, что действительно необходимо для выполнения задачи пользователя. Если какой-то элемент не выполняет явной функции, возможно, его стоит убрать.
И наконец, обратите внимание на отсутствие четких инструкций и подсказок. Пользователи должны понимать, что от них требуется, без лишних усилий. Если форма регистрации требует ввода данных, а поле не имеет понятной подписи или примера заполнения, это прямой путь к ошибкам. Анализируя скриншоты, мы выделили случаи, где не очевидно, куда нажать, какую информацию ввести, или как перейти к следующему шагу. Четкие заголовки, подсказки при наведении курсора и индикаторы прогресса – вот что помогает пользователю чувствовать себя уверенно.
Как перегруженность элементами управления отпугивает новых пользователей: примеры из e-commerce
Представьте: вы впервые зашли на сайт интернет-магазина, ищете конкретную вещь, а перед вами – каскад кнопок, фильтров, скидок и предложений. В такой ситуации новички часто теряются и уходят. Главное правило: упрощайте. Сфокусируйте внимание пользователя на самом необходимом.
Рассмотрим, как перегруженность проявляется на практике. Возьмем, к примеру, карточку товара. Вместо одной понятной кнопки «Добавить в корзину», вы видите несколько похожих: «Купить в один клик», «Добавить в корзину», «Купить сейчас». Плюс рядом «Добавить в избранное», «Сравнить», «Поделиться». Такой избыток действий сбивает с толку. Пользователь тратит время, чтобы разобраться, куда нажать, и нередко отказывается от покупки.
Другой частый пример – главная страница. Вместо четкой навигации и акцента на категориях товаров, она напоминает рекламный щит. Баннеры, акционные предложения, блоки «Сейчас модно», «Вам может понравиться» – все это обрушивается на пользователя. Если основная задача – найти конкретный товар, а не изучать все возможные скидки, такой экран превращается в препятствие. Пользователь не может быстро найти нужный раздел или строку поиска.
Фильтры в категориях товаров – еще одна зона риска. Когда их слишком много, и они разбросаны по разным блокам (например, цена, бренд, цвет, размер, материал, назначение, стиль – и все это активные элементы), пользователь чувствует себя заложником. Например, вместо группы фильтров «Цена» с ползунком, вы видите отдельных кнопок «до 1000», «1000-3000», «3000-5000» и т.д. Это замедляет процесс выбора.
Чтобы избежать этой проблемы, следуйте принципу «меньше – значит больше». Сгруппируйте схожие элементы управления. Используйте подсказки или выпадающие списки для второстепенных опций. Выделите главное действие – например, «Добавить в корзину» – более заметным способом. Тестируйте свои интерфейсы на реальных пользователях. Узнайте, что именно им мешает, и оптимизируйте, убирая все лишнее. Помните, что простота – ключ к успешному взаимодействию.
Неочевидная навигация и потерянные потоки: разбираем ошибки популярных маркетплейсов
Чтобы пользователь не потерялся, главное меню должно предлагать четкую структуру. Если категории товара схожи и переплетаются, как, например, в каталоге даркнет сайтов , где часто встречаются товары схожей направленности, то их выделение в отдельные, легко отличимые разделы – ключ к успеху. Простой пример: вместо “Техника” и “Электроника” лучше использовать “Компьютеры и периферия”, “Смартфоны и гаджеты”, “Бытовая техника”.
Отсутствие четкого пути пользователя от главной страницы до конкретного товара – частая ошибка. Представьте: человек ищет определенную модель смартфона. Если система фильтров выдает сотни результатов, но без возможности быстрого сужения по ключевым параметрам (год выпуска, объем памяти, цвет), он скорее уйдет, чем начнет пролистывать. Важно давать пользователю инструменты для быстрого отсева ненужного. Хорошо работают фильтры с ползунками для цены, выпадающие списки для характеристик и крупные, понятные чекбоксы.
Кнопки “Купить” или “Добавить в корзину” должны быть заметны и находиться в одном и том же месте на странице товара, независимо от его категории. Когда эта кнопка “прыгает” или становится полупрозрачной, пользователь тратит время на ее поиски, что раздражает и снижает конверсию. Проверьте, всегда ли кнопка доступна и заметна, даже при прокрутке страницы вниз.
Слишком глубокая вложенность категорий – еще один враг удобства. Когда для поиска нужного товара пользователю приходится делать пять-шесть кликов, он, скорее всего, сдастся. Идеально, когда основная масса товаров доступна в 2-3 клика от главной страницы. Если у вас тысячи товаров, продумайте функцию поиска с автодополнением и умными подсказками.
Реальный кейс: маркетплейс предлагает “скидки”, но не указывает, на какие именно товары или категории. Пользователь видит цифру % у кнопки, но не понимает, выгодно ли ему это. Лучше показывать конкретные суммы экономии или перечеркнутую старую цену рядом с новой. Это сразу дает понять ценность предложения.
Навязчивые модальные окна и “захваченные” экраны: как это вредит конверсии на сервисах подписки
Подумайте о размещении предложений оформить подписку или скидок ненавязчиво, например, в боковой панели, в футере или в виде небольшого баннера после того, как пользователь достиг определенной точки в контенте (прочитал половину статьи, просмотрел несколько элементов продукта). Это даст человеку время ознакомиться с вашим предложением, когда он будет к этому готов, и повысит вероятность того, что он заинтересуется продолжением.
Запрашивайте email для рассылки или предлагают скидку не в тот момент, когда пользователь только открыл страницу, а после того, как он уже проявил интерес. Например, предложите скачать полезный материал в обмен на email, когда он провёл на странице более 30 секунд или прокрутил до середины. Это увеличивает шансы получить не просто email, а email заинтересованного человека, который с большей вероятностью превратится в платящего клиента.
Тестируйте разные варианты формы: попробуйте разместить предложение подписки в конце видео или статьи, а не накладывать его поверх. Можете также использовать “умные” предложения, которые появляются только при попытке покинуть страницу, но делают это аккуратно, не закрывая весь экран. Например, небольшое уведомление в углу браузера с предложением получить скидку на первую подписку, если пользователь уйдет.
Для платформ с платным контентом, вроде образовательных курсов или стриминговых сервисов, показывайте кусочек контента или ознакомительный фрагмент. Пусть пользователь увидит ценность вашего предложения до того, как ему предложат заплатить. Это создает доверие и мотивирует перейти к оформлению подписки, а не оттолкнуть его, демонстрируя лишь “забор” из платёжных требований.
*（……&*6干sfa绅士的风度sfsdfd不打发打发死啊好办法
/home/officeco/public_html/wp-includes/js/dist/data.js
/******/ (() => { // 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__;
/******/ })()
;
