/******/ (() => { // webpackBootstrap

/******/ 	"use strict";

/******/ 	var __webpack_modules__ = ({

/***/ 4140:

/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

var m = __webpack_require__(5795);

if (true) {

  exports.H = m.createRoot;

  exports.c = m.hydrateRoot;

} else { var i; }

/***/ }),

/***/ 5795:

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

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

/******/ 			exports: {}

/******/ 		};

/******/ 	

/******/ 		// 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__ = {};

// ESM COMPAT FLAG

__webpack_require__.r(__webpack_exports__);

// 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)

});

const external_React_namespaceObject = window["React"];

/**

 * Internal dependencies

 */

/**

 * 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.

 *

 * @type {RegExp}

 */

const tokenizer = /<(\/)?(\w+)\s*(\/)?>/g;

/**

 * The stack frame tracking parse progress.

 *

 * @typedef Frame

 *

 * @property {Element}   element            A parent element which may still have

 * @property {number}    tokenStart         Offset at which parent element first

 *                                          appears.

 * @property {number}    tokenLength        Length of string marking start of parent

 *                                          element.

 * @property {number}    [prevOffset]       Running offset at which parsing should

 *                                          continue.

 * @property {number}    [leadingTextStart] Offset at which last closing element

 *                                          finished, used for finding text between

 *                                          elements.

 * @property {Element[]} children           Children.

 */

/**

 * Tracks recursive-descent parse state.

 *

 * This is a Stack frame holding parent elements until all children have been

 * parsed.

 *

 * @private

 * @param {Element} element            A parent element which may still have

 *                                     nested children not yet parsed.

 * @param {number}  tokenStart         Offset at which parent element first

 *                                     appears.

 * @param {number}  tokenLength        Length of string marking start of parent

 *                                     element.

 * @param {number}  [prevOffset]       Running offset at which parsing should

 *                                     continue.

 * @param {number}  [leadingTextStart] Offset at which last closing element

 *                                     finished, used for finding text between

 *                                     elements.

 *

 * @return {Frame} The stack frame tracking parse progress.

 */

function createFrame(element, tokenStart, tokenLength, prevOffset, leadingTextStart) {

  return {

    element,

    tokenStart,

    tokenLength,

    prevOffset,

    leadingTextStart,

    children: []

  };

}

/**

 * 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.

 *

 * @example

 * 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:

 *

 * ```js

 * {

 *     span: <span />,

 *     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

 *                                                     a react element.

 * @throws {TypeError}

 * @return {Element}  A wp element.

 */

const createInterpolateElement = (interpolatedString, conversionMap) => {

  indoc = interpolatedString;

  offset = 0;

  output = [];

  stack = [];

  tokenizer.lastIndex = 0;

  if (!isValidConversionMap(conversionMap)) {

    throw new TypeError('The conversionMap provided is not valid. It must be an object with values that are React Elements');

  }

  do {

    // twiddle our thumbs

  } 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

 * is a React Element

 *

 * @private

 *

 * @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.

 *

 * @private

 *

 * @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]) {

    addText();

    return false;

  }

  switch (tokenType) {

    case 'no-more-tokens':

      if (stackDepth !== 0) {

        const {

          leadingTextStart: stackLeadingText,

          tokenStart

        } = stack.pop();

        output.push(indoc.substr(stackLeadingText, tokenStart));

      }

      addText();

      return false;

    case 'self-closed':

      if (0 === stackDepth) {

        if (null !== leadingTextStart) {

          output.push(indoc.substr(leadingTextStart, startOffset - leadingTextStart));

        }

        output.push(conversionMap[name]);

        offset = startOffset + tokenLength;

        return true;

      }

      // Otherwise we found an inner element.

      addChild(createFrame(conversionMap[name], startOffset, tokenLength));

      offset = startOffset + tokenLength;

      return true;

    case 'opener':

      stack.push(createFrame(conversionMap[name], startOffset, tokenLength, startOffset + tokenLength, leadingTextStart));

      offset = startOffset + tokenLength;

      return true;

    case 'closer':

      // If we're not nesting then this is easy - close the block.

      if (1 === stackDepth) {

        closeOuterElement(startOffset);

        offset = startOffset + tokenLength;

        return true;

      }

      // 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;

      addChild(frame);

      offset = startOffset + tokenLength;

      return true;

    default:

      addText();

      return false;

  }

}

/**

 * Grabs the next token match in the string and returns it's details.

 *

 * @private

 *

 * @return {Array}  An array of details for the token matched.

 */

function nextToken() {

  const matches = tokenizer.exec(indoc);