: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
/******/ __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__ = {};
// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
AsyncModeProvider: () => (/* reexport */ async_mode_provider_context),
RegistryConsumer: () => (/* reexport */ RegistryConsumer),
RegistryProvider: () => (/* reexport */ context),
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),
useRegistry: () => (/* reexport */ useRegistry),
useSelect: () => (/* reexport */ useSelect),
useSuspenseSelect: () => (/* reexport */ useSuspenseSelect),
withDispatch: () => (/* reexport */ with_dispatch),
withRegistry: () => (/* reexport */ with_registry),
withSelect: () => (/* reexport */ with_select)
// 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)
;// CONCATENATED MODULE: external ["wp","deprecated"]
const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
"@babel/helpers - typeof";
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPrimitive.js
function _toPrimitive(input, hint) {
if (_typeof(input) !== "object" || input === null) return input;
var prim = input[Symbol.toPrimitive];
if (prim !== undefined) {
var res = prim.call(input, hint || "default");
if (_typeof(res) !== "object") return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
return (hint === "string" ? String : Number)(input);
;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
function _toPropertyKey(arg) {
var key = _toPrimitive(arg, "string");
return _typeof(key) === "symbol" ? key : String(key);
;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
function _defineProperty(obj, key, value) {
key = _toPropertyKey(key);
Object.defineProperty(obj, key, {
;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function (r) {
return Object.getOwnPropertyDescriptor(e, r).enumerable;
function _objectSpread2(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
_defineProperty(e, r, t[r]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
;// CONCATENATED MODULE: ./node_modules/redux/es/redux.js
* Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js
* Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes
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. ';
// Inlined version of the `symbol-observable` polyfill
var $$observable = (function () {
return typeof Symbol === 'function' && Symbol.observable || '@@observable';
* These are private action types reserved by Redux.
* For any unknown actions, you must return the current state.
* If the current state is undefined, you must return the initial state.
* Do not reference these action types directly in your code.
var randomString = function randomString() {
return Math.random().toString(36).substring(7).split('').join('.');
INIT: "@@redux/INIT" + randomString(),
REPLACE: "@@redux/REPLACE" + randomString(),
PROBE_UNKNOWN_ACTION: function PROBE_UNKNOWN_ACTION() {
return "@@redux/PROBE_UNKNOWN_ACTION" + randomString();
* @param {any} obj The object to inspect.
* @returns {boolean} True if the argument appears to be a plain object.
function isPlainObject(obj) {
if (typeof obj !== 'object' || obj === null) return false;
while (Object.getPrototypeOf(proto) !== null) {
proto = Object.getPrototypeOf(proto);
return Object.getPrototypeOf(obj) === proto;
// Inlined / shortened version of `kindOf` from https://github.com/jonschlinkert/kind-of
function miniKindOf(val) {
if (val === void 0) return 'undefined';
if (val === null) return 'null';
if (Array.isArray(val)) return 'array';
if (isDate(val)) return 'date';
if (isError(val)) return 'error';
var constructorName = ctorName(val);
switch (constructorName) {
return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
return typeof val.constructor === 'function' ? val.constructor.name : null;
return val instanceof Error || typeof val.message === 'string' && val.constructor && typeof val.constructor.stackTraceLimit === 'number';
if (val instanceof Date) return true;
return typeof val.toDateString === 'function' && typeof val.getDate === 'function' && typeof val.setDate === 'function';
var typeOfVal = typeof val;
* **We recommend using the `configureStore` method
* of the `@reduxjs/toolkit` package**, which replaces `createStore`.
* Redux Toolkit is our recommended approach for writing Redux logic today,
* including store setup, reducers, data fetching, and more.
* **For more details, please read this Redux docs page:**
* **https://redux.js.org/introduction/why-rtk-is-redux-today**
* `configureStore` from Redux Toolkit is an improved version of `createStore` that
* simplifies setup and helps avoid common bugs.
* You should not be using the `redux` core package by itself today, except for learning purposes.
* The `createStore` method from the core `redux` package will not be removed, but we encourage
* all users to migrate to using Redux Toolkit for all Redux code.
* If you want to use `createStore` without this visual deprecation warning, use
* the `legacy_createStore` import instead:
* `import { legacy_createStore as createStore} from 'redux'`
function createStore(reducer, preloadedState, enhancer) {
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 = undefined;
if (typeof enhancer !== 'undefined') {
if (typeof enhancer !== 'function') {
throw new Error( true ? formatProdErrorMessage(1) : 0);
return enhancer(createStore)(reducer, preloadedState);
if (typeof reducer !== 'function') {
throw new Error( true ? formatProdErrorMessage(2) : 0);
var currentReducer = reducer;
var currentState = preloadedState;
var currentListeners = [];
var nextListeners = currentListeners;
var isDispatching = false;
* This makes a shallow copy of currentListeners so we can use
* nextListeners as a temporary list while dispatching.
* This prevents any bugs around consumers calling
* subscribe/unsubscribe in the middle of a dispatch.
function ensureCanMutateNextListeners() {
if (nextListeners === currentListeners) {
nextListeners = currentListeners.slice();
* Reads the state tree managed by the store.
* @returns {any} The current state tree of your application.
throw new Error( true ? formatProdErrorMessage(3) : 0);
* Adds a change listener. It will be called any time an action is dispatched,
* and some part of the state tree may potentially have changed. You may then
* call `getState()` to read the current state tree inside the callback.
* You may call `dispatch()` from a change listener, with the following
* 1. The subscriptions are snapshotted just before every `dispatch()` call.
* If you subscribe or unsubscribe while the listeners are being invoked, this
* will not have any effect on the `dispatch()` that is currently in progress.
* However, the next `dispatch()` call, whether nested or not, will use a more
* recent snapshot of the subscription list.
* 2. The listener should not expect to see all state changes, as the state
* might have been updated multiple times during a nested `dispatch()` before
* the listener is called. It is, however, guaranteed that all subscribers
* registered before the `dispatch()` started will be called with the latest
* state by the time it exits.
* @param {Function} listener A callback to be invoked on every dispatch.
* @returns {Function} A function to remove this change listener.
function subscribe(listener) {
if (typeof listener !== 'function') {
throw new Error( true ? formatProdErrorMessage(4) : 0);
throw new Error( true ? formatProdErrorMessage(5) : 0);
ensureCanMutateNextListeners();
nextListeners.push(listener);
return function unsubscribe() {
throw new Error( true ? formatProdErrorMessage(6) : 0);
ensureCanMutateNextListeners();
var index = nextListeners.indexOf(listener);
nextListeners.splice(index, 1);
* Dispatches an action. It is the only way to trigger a state change.
* The `reducer` function, used to create the store, will be called with the
* current state tree and the given `action`. Its return value will
* be considered the **next** state of the tree, and the change listeners
* The base implementation only supports plain object actions. If you want to
* dispatch a Promise, an Observable, a thunk, or something else, you need to
* wrap your store creating function into the corresponding middleware. For
* example, see the documentation for the `redux-thunk` package. Even the
* middleware will eventually dispatch plain object actions using this method.
* @param {Object} action A plain object representing “what changed”. It is
* a good idea to keep actions serializable so you can record and replay user
* sessions, or use the time travelling `redux-devtools`. An action must have
* a `type` property which may not be `undefined`. It is a good idea to use
* string constants for action types.
* @returns {Object} For convenience, the same action object you dispatched.
* Note that, if you use a custom middleware, it may wrap `dispatch()` to
* return something else (for example, a Promise you can await).
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);
throw new Error( true ? formatProdErrorMessage(9) : 0);
currentState = currentReducer(currentState, action);
var listeners = currentListeners = nextListeners;
for (var i = 0; i < listeners.length; i++) {
var listener = listeners[i];
* Replaces the reducer currently used by the store to calculate the state.
* You might need this if your app implements code splitting and you want to
* load some of the reducers dynamically. You might also need this if you
* implement a hot reloading mechanism for Redux.
* @param {Function} nextReducer The reducer for the store to use instead.
function replaceReducer(nextReducer) {
if (typeof nextReducer !== 'function') {
throw new Error( true ? formatProdErrorMessage(10) : 0);
currentReducer = nextReducer; // This action has a similiar effect to ActionTypes.INIT.
// Any reducers that existed in both the new and old rootReducer
// will receive the previous state. This effectively populates
// the new state tree with any relevant data from the old one.
type: ActionTypes.REPLACE
* Interoperability point for observable/reactive libraries.
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
