: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
var m = __webpack_require__(5795);
exports.H = m.createRoot;
exports.c = m.hydrateRoot;
module.exports = window["ReactDOM"];
/************************************************************************/
/******/ // 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
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ // Return the exports of the module
/******/ return module.exports;
/************************************************************************/
/******/ /* 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__ = {};
// 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__, {
Children: () => (/* reexport */ external_React_namespaceObject.Children),
Component: () => (/* reexport */ external_React_namespaceObject.Component),
Fragment: () => (/* reexport */ external_React_namespaceObject.Fragment),
Platform: () => (/* reexport */ platform),
PureComponent: () => (/* reexport */ external_React_namespaceObject.PureComponent),
RawHTML: () => (/* reexport */ RawHTML),
StrictMode: () => (/* reexport */ external_React_namespaceObject.StrictMode),
Suspense: () => (/* reexport */ external_React_namespaceObject.Suspense),
cloneElement: () => (/* reexport */ external_React_namespaceObject.cloneElement),
concatChildren: () => (/* reexport */ concatChildren),
createContext: () => (/* reexport */ external_React_namespaceObject.createContext),
createElement: () => (/* reexport */ external_React_namespaceObject.createElement),
createInterpolateElement: () => (/* reexport */ create_interpolate_element),
createPortal: () => (/* reexport */ external_ReactDOM_.createPortal),
createRef: () => (/* reexport */ external_React_namespaceObject.createRef),
createRoot: () => (/* reexport */ client/* createRoot */.H),
findDOMNode: () => (/* reexport */ external_ReactDOM_.findDOMNode),
flushSync: () => (/* reexport */ external_ReactDOM_.flushSync),
forwardRef: () => (/* reexport */ external_React_namespaceObject.forwardRef),
hydrate: () => (/* reexport */ external_ReactDOM_.hydrate),
hydrateRoot: () => (/* reexport */ client/* hydrateRoot */.c),
isEmptyElement: () => (/* reexport */ isEmptyElement),
isValidElement: () => (/* reexport */ external_React_namespaceObject.isValidElement),
lazy: () => (/* reexport */ external_React_namespaceObject.lazy),
memo: () => (/* reexport */ external_React_namespaceObject.memo),
render: () => (/* reexport */ external_ReactDOM_.render),
renderToString: () => (/* reexport */ serialize),
startTransition: () => (/* reexport */ external_React_namespaceObject.startTransition),
switchChildrenNodeName: () => (/* reexport */ switchChildrenNodeName),
unmountComponentAtNode: () => (/* reexport */ external_ReactDOM_.unmountComponentAtNode),
useCallback: () => (/* reexport */ external_React_namespaceObject.useCallback),
useContext: () => (/* reexport */ external_React_namespaceObject.useContext),
useDebugValue: () => (/* reexport */ external_React_namespaceObject.useDebugValue),
useDeferredValue: () => (/* reexport */ external_React_namespaceObject.useDeferredValue),
useEffect: () => (/* reexport */ external_React_namespaceObject.useEffect),
useId: () => (/* reexport */ external_React_namespaceObject.useId),
useImperativeHandle: () => (/* reexport */ external_React_namespaceObject.useImperativeHandle),
useInsertionEffect: () => (/* reexport */ external_React_namespaceObject.useInsertionEffect),
useLayoutEffect: () => (/* reexport */ external_React_namespaceObject.useLayoutEffect),
useMemo: () => (/* reexport */ external_React_namespaceObject.useMemo),
useReducer: () => (/* reexport */ external_React_namespaceObject.useReducer),
useRef: () => (/* reexport */ external_React_namespaceObject.useRef),
useState: () => (/* reexport */ external_React_namespaceObject.useState),
useSyncExternalStore: () => (/* reexport */ external_React_namespaceObject.useSyncExternalStore),
useTransition: () => (/* reexport */ external_React_namespaceObject.useTransition)
;// CONCATENATED MODULE: external "React"
const external_React_namespaceObject = window["React"];
;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/create-interpolate-element.js
* Object containing a React element.
* @typedef {import('react').ReactElement} Element
let indoc, offset, output, stack;
* Matches tags in the localized string
* This is used for extracting the tag pattern groups for parsing the localized
* string and along with the map converting it to a react element.
* There are four references extracted using this tokenizer:
* match: Full match of the tag (i.e. <strong>, </strong>, <br/>)
* isClosing: The closing slash, if it exists.
* name: The name portion of the tag (strong, br) (if )
* isSelfClosed: The slash on a self closing tag, if it exists.
const tokenizer = /<(\/)?(\w+)\s*(\/)?>/g;
* The stack frame tracking parse progress.
* @property {Element} element A parent element which may still have
* @property {number} tokenStart Offset at which parent element first
* @property {number} tokenLength Length of string marking start of parent
* @property {number} [prevOffset] Running offset at which parsing should
* @property {number} [leadingTextStart] Offset at which last closing element
* finished, used for finding text between
* @property {Element[]} children Children.
* Tracks recursive-descent parse state.
* This is a Stack frame holding parent elements until all children have been
* @param {Element} element A parent element which may still have
* nested children not yet parsed.
* @param {number} tokenStart Offset at which parent element first
* @param {number} tokenLength Length of string marking start of parent
* @param {number} [prevOffset] Running offset at which parsing should
* @param {number} [leadingTextStart] Offset at which last closing element
* finished, used for finding text between
* @return {Frame} The stack frame tracking parse progress.
function createFrame(element, tokenStart, tokenLength, prevOffset, leadingTextStart) {
* This function creates an interpolated element from a passed in string with
* specific tags matching how the string should be converted to an element via
* the conversion map value.
* For example, for the given string:
* "This is a <span>string</span> with <a>a link</a> and a self-closing
* <CustomComponentB/> tag"
* You would have something like this as the conversionMap value:
* a: <a href={ 'https://github.com' } />,
* CustomComponentB: <CustomComponent />,
* @param {string} interpolatedString The interpolation string to be parsed.
* @param {Record<string, Element>} conversionMap The map used to convert the string to
* @return {Element} A wp element.
const createInterpolateElement = (interpolatedString, conversionMap) => {
indoc = interpolatedString;
if (!isValidConversionMap(conversionMap)) {
throw new TypeError('The conversionMap provided is not valid. It must be an object with values that are React Elements');
} while (proceed(conversionMap));
return (0,external_React_namespaceObject.createElement)(external_React_namespaceObject.Fragment, null, ...output);
* Validate conversion map.
* A map is considered valid if it's an object and every value in the object
* @param {Object} conversionMap The map being validated.
* @return {boolean} True means the map is valid.
const isValidConversionMap = conversionMap => {
const isObject = typeof conversionMap === 'object';
const values = isObject && Object.values(conversionMap);
return isObject && values.length && values.every(element => (0,external_React_namespaceObject.isValidElement)(element));
* This is the iterator over the matches in the string.
* @param {Object} conversionMap The conversion map for the string.
* @return {boolean} true for continuing to iterate, false for finished.
function proceed(conversionMap) {
const next = nextToken();
const [tokenType, name, startOffset, tokenLength] = next;
const stackDepth = stack.length;
const leadingTextStart = startOffset > offset ? offset : null;
if (!conversionMap[name]) {
leadingTextStart: stackLeadingText,
output.push(indoc.substr(stackLeadingText, tokenStart));
if (null !== leadingTextStart) {
output.push(indoc.substr(leadingTextStart, startOffset - leadingTextStart));
output.push(conversionMap[name]);
offset = startOffset + tokenLength;
// Otherwise we found an inner element.
addChild(createFrame(conversionMap[name], startOffset, tokenLength));
offset = startOffset + tokenLength;
stack.push(createFrame(conversionMap[name], startOffset, tokenLength, startOffset + tokenLength, leadingTextStart));
offset = startOffset + tokenLength;
// If we're not nesting then this is easy - close the block.
closeOuterElement(startOffset);
offset = startOffset + tokenLength;
// Otherwise we're nested and we have to close out the current
// block and add it as a innerBlock to the parent.
const stackTop = stack.pop();
const text = indoc.substr(stackTop.prevOffset, startOffset - stackTop.prevOffset);
stackTop.children.push(text);
stackTop.prevOffset = startOffset + tokenLength;
const frame = createFrame(stackTop.element, stackTop.tokenStart, stackTop.tokenLength, startOffset + tokenLength);
frame.children = stackTop.children;
offset = startOffset + tokenLength;
* Grabs the next token match in the string and returns it's details.
* @return {Array} An array of details for the token matched.
const matches = tokenizer.exec(indoc);
// We have no more tokens.
return ['no-more-tokens'];
const startedAt = matches.index;
const [match, isClosing, name, isSelfClosed] = matches;
const length = match.length;
return ['self-closed', name, startedAt, length];
return ['closer', name, startedAt, length];
return ['opener', name, startedAt, length];
* Pushes text extracted from the indoc string to the output stack given the
* current rawLength value and offset (if rawLength is provided ) or the
* indoc.length and offset.
const length = indoc.length - offset;
output.push(indoc.substr(offset, length));
* Pushes a child element to the associated parent element's children for the
* parent currently active in the stack.
* @param {Frame} frame The Frame containing the child element and it's
function addChild(frame) {
const parent = stack[stack.length - 1];
const text = indoc.substr(parent.prevOffset, tokenStart - parent.prevOffset);
parent.children.push(text);
parent.children.push((0,external_React_namespaceObject.cloneElement)(element, null, ...children));
parent.prevOffset = prevOffset ? prevOffset : tokenStart + tokenLength;
* This is called for closing tags. It creates the element currently active in
* @param {number} endOffset Offset at which the closing tag for the element
* begins in the string. If this is greater than the
* prevOffset attached to the element, then this
* helps capture any remaining nested text nodes in
function closeOuterElement(endOffset) {
const text = endOffset ? indoc.substr(prevOffset, endOffset - prevOffset) : indoc.substr(prevOffset);
if (null !== leadingTextStart) {
output.push(indoc.substr(leadingTextStart, tokenStart - leadingTextStart));
output.push((0,external_React_namespaceObject.cloneElement)(element, null, ...children));
/* harmony default export */ const create_interpolate_element = (createInterpolateElement);
;// CONCATENATED MODULE: ./node_modules/@wordpress/element/build-module/react.js
// eslint-disable-next-line @typescript-eslint/no-restricted-imports
* Object containing a React element.
* @typedef {import('react').ReactElement} Element
* Object containing a React component.
* @typedef {import('react').ComponentType} ComponentType
* Object containing a React synthetic event.
* @typedef {import('react').SyntheticEvent} SyntheticEvent
* Object containing a React synthetic event.
* @typedef {import('react').RefObject<T>} RefObject<T>
* Object that provides utilities for dealing with React children.
* Creates a copy of an element with extended props.
* @param {Element} element Element
* @param {?Object} props Props to apply to cloned element
* @return {Element} Cloned element.
* A base class to create WordPress Components (Refs, state and lifecycle hooks)
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
