FM / dist

/home/techb158/public_html/wp-includes/js/dist/

/home/techb158/public_html/wp-includes/js/dist

Name	Size	Mode	Actions
development/	-	0777	rm
script-modules/	-	0755	rm
vendor/	-	0777	rm
a11y.js	5697	0666	edit dl rm
a11y.min.js	2616	0666	edit dl rm
annotations.js	15952	0666	edit dl rm
annotations.min.js	5978	0666	edit dl rm
api-fetch.js	20003	0666	edit dl rm
api-fetch.min.js	7510	0666	edit dl rm
autop.js	10019	0666	edit dl rm
autop.min.js	5694	0666	edit dl rm
base-styles.js	115	0666	edit dl rm
base-styles.min.js	142	0666	edit dl rm
blob.js	2410	0666	edit dl rm
blob.min.js	1243	0666	edit dl rm
block-directory.js	381638	0666	edit dl rm
block-directory.min.js	129573	0666	edit dl rm
block-editor.js	3779291	0666	edit dl rm
block-editor.min.js	1411106	0666	edit dl rm
block-library.js	3022684	0666	edit dl rm
block-library.min.js	1304378	0666	edit dl rm
block-serialization-default-parser.js	6800	0666	edit dl rm
block-serialization-default-parser.min.js	2560	0666	edit dl rm
block-serialization-spec-parser.js	51796	0666	edit dl rm
block-serialization-spec-parser.min.js	10728	0666	edit dl rm
blocks.js	299905	0666	edit dl rm
blocks.min.js	146426	0666	edit dl rm
commands.js	131739	0666	edit dl rm
commands.min.js	57227	0666	edit dl rm
components.js	3821298	0666	edit dl rm
components.min.js	836689	0666	edit dl rm
compose.js	85752	0666	edit dl rm
compose.min.js	30098	0666	edit dl rm
core-commands.js	29805	0666	edit dl rm
core-commands.min.js	12489	0666	edit dl rm
core-data.js	675840	0666	edit dl rm
core-data.min.js	231957	0666	edit dl rm
customize-widgets.js	114226	0666	edit dl rm
customize-widgets.min.js	44466	0666	edit dl rm
data-controls.js	4301	0666	edit dl rm
data-controls.min.js	1885	0666	edit dl rm
data.js	85698	0666	edit dl rm
data.min.js	26664	0666	edit dl rm
date.js	180935	0666	edit dl rm
date.min.js	144747	0666	edit dl rm
deprecated.js	3180	0666	edit dl rm
deprecated.min.js	1382	0666	edit dl rm
dom-ready.js	1571	0666	edit dl rm
dom-ready.min.js	881	0666	edit dl rm
dom.js	35962	0666	edit dl rm
dom.min.js	13172	0666	edit dl rm
edit-post.js	451359	0666	edit dl rm
edit-post.min.js	160157	0666	edit dl rm
edit-site.js	2304757	0666	edit dl rm
edit-site.min.js	905288	0666	edit dl rm
edit-widgets.js	184620	0666	edit dl rm
edit-widgets.min.js	70465	0666	edit dl rm
editor.js	3968367	0666	edit dl rm
editor.min.js	1573886	0666	edit dl rm
element.js	27971	0666	edit dl rm
element.min.js	12468	0666	edit dl rm
escape-html.js	2413	0666	edit dl rm
escape-html.min.js	1158	0666	edit dl rm
format-library.js	234957	0666	edit dl rm
format-library.min.js	98495	0666	edit dl rm
hooks.js	12299	0666	edit dl rm
hooks.min.js	5107	0666	edit dl rm
html-entities.js	1756	0666	edit dl rm
html-entities.min.js	950	0666	edit dl rm
i18n.js	15725	0666	edit dl rm
i18n.min.js	5791	0666	edit dl rm
is-shallow-equal.js	2833	0666	edit dl rm
is-shallow-equal.min.js	1197	0666	edit dl rm
keyboard-shortcuts.js	10508	0666	edit dl rm
keyboard-shortcuts.min.js	3682	0666	edit dl rm
keycodes.js	8564	0666	edit dl rm
keycodes.min.js	3038	0666	edit dl rm
list-reusable-blocks.js	13662	0666	edit dl rm
list-reusable-blocks.min.js	5539	0666	edit dl rm
media-utils.js	1065027	0666	edit dl rm
media-utils.min.js	390995	0666	edit dl rm
notices.js	9783	0666	edit dl rm
notices.min.js	3947	0666	edit dl rm
nux.js	4423	0666	edit dl rm
nux.min.js	1749	0666	edit dl rm
patterns.js	90184	0666	edit dl rm
patterns.min.js	38302	0666	edit dl rm
plugins.js	21220	0666	edit dl rm
plugins.min.js	7253	0666	edit dl rm
preferences-persistence.js	17720	0666	edit dl rm
preferences-persistence.min.js	5713	0666	edit dl rm
preferences.js	21531	0666	edit dl rm
preferences.min.js	8028	0666	edit dl rm
primitives.js	5270	0666	edit dl rm
primitives.min.js	2093	0666	edit dl rm
priority-queue.js	10338	0666	edit dl rm
priority-queue.min.js	3505	0666	edit dl rm
private-apis.js	4531	0666	edit dl rm
private-apis.min.js	3017	0666	edit dl rm
react-i18n.js	4064	0666	edit dl rm
react-i18n.min.js	1627	0666	edit dl rm
redux-routine.js	25346	0666	edit dl rm
redux-routine.min.js	9952	0666	edit dl rm
reusable-blocks.js	22391	0666	edit dl rm
reusable-blocks.min.js	8185	0666	edit dl rm
rich-text.js	107405	0666	edit dl rm
rich-text.min.js	43182	0666	edit dl rm
router.js	37079	0666	edit dl rm
router.min.js	14552	0666	edit dl rm
server-side-render.js	11588	0666	edit dl rm
server-side-render.min.js	4198	0666	edit dl rm
shortcode.js	8215	0666	edit dl rm
shortcode.min.js	3426	0666	edit dl rm
style-engine.js	18810	0666	edit dl rm
style-engine.min.js	6946	0666	edit dl rm
theme.js	138733	0666	edit dl rm
theme.min.js	61144	0666	edit dl rm
token-list.js	6327	0666	edit dl rm
token-list.min.js	1723	0666	edit dl rm
undo-manager.js	5491	0666	edit dl rm
undo-manager.min.js	1808	0666	edit dl rm
upload-media.js	118036	0666	edit dl rm
upload-media.min.js	49874	0666	edit dl rm
url.js	23957	0666	edit dl rm
url.min.js	10423	0666	edit dl rm
viewport.js	7312	0666	edit dl rm
viewport.min.js	2374	0666	edit dl rm
warning.js	1616	0666	edit dl rm
warning.min.js	816	0666	edit dl rm
widgets.js	51346	0666	edit dl rm
widgets.min.js	21475	0666	edit dl rm
wordcount.js	7166	0666	edit dl rm
wordcount.min.js	2570	0666	edit dl rm

Edit: /home/techb158/public_html/wp-includes/js/dist/element.js (27971B)

// vendor-external:react
  var require_react = __commonJS({
    "vendor-external:react"(exports, module) {
      module.exports = window.React;
    }
  });

// vendor-external:react-dom
  var require_react_dom = __commonJS({
    "vendor-external:react-dom"(exports, module) {
      module.exports = window.ReactDOM;
    }
  });

// vendor-external:react-dom/client
  var require_client = __commonJS({
    "vendor-external:react-dom/client"(exports, module) {
      module.exports = window.ReactDOM;
    }
  });

// package-external:@wordpress/escape-html
  var require_escape_html = __commonJS({
    "package-external:@wordpress/escape-html"(exports, module) {
      module.exports = window.wp.escapeHtml;
    }
  });

// packages/element/build-module/index.mjs
  var index_exports = {};
  __export(index_exports, {
    Children: () => import_react.Children,
    Component: () => import_react.Component,
    Fragment: () => import_react.Fragment,
    Platform: () => platform_default,
    PureComponent: () => import_react.PureComponent,
    RawHTML: () => RawHTML,
    StrictMode: () => import_react.StrictMode,
    Suspense: () => import_react.Suspense,
    cloneElement: () => import_react.cloneElement,
    concatChildren: () => concatChildren,
    createContext: () => import_react.createContext,
    createElement: () => import_react.createElement,
    createInterpolateElement: () => create_interpolate_element_default,
    createPortal: () => import_react_dom.createPortal,
    createRef: () => import_react.createRef,
    createRoot: () => import_client.createRoot,
    findDOMNode: () => import_react_dom.findDOMNode,
    flushSync: () => import_react_dom.flushSync,
    forwardRef: () => import_react.forwardRef,
    hydrate: () => import_react_dom.hydrate,
    hydrateRoot: () => import_client.hydrateRoot,
    isEmptyElement: () => isEmptyElement,
    isValidElement: () => import_react.isValidElement,
    lazy: () => import_react.lazy,
    memo: () => import_react.memo,
    render: () => import_react_dom.render,
    renderToString: () => serialize_default,
    startTransition: () => import_react.startTransition,
    switchChildrenNodeName: () => switchChildrenNodeName,
    unmountComponentAtNode: () => import_react_dom.unmountComponentAtNode,
    useCallback: () => import_react.useCallback,
    useContext: () => import_react.useContext,
    useDebugValue: () => import_react.useDebugValue,
    useDeferredValue: () => import_react.useDeferredValue,
    useEffect: () => import_react.useEffect,
    useId: () => import_react.useId,
    useImperativeHandle: () => import_react.useImperativeHandle,
    useInsertionEffect: () => import_react.useInsertionEffect,
    useLayoutEffect: () => import_react.useLayoutEffect,
    useMemo: () => import_react.useMemo,
    useReducer: () => import_react.useReducer,
    useRef: () => import_react.useRef,
    useState: () => import_react.useState,
    useSyncExternalStore: () => import_react.useSyncExternalStore,
    useTransition: () => import_react.useTransition
  });

// packages/element/build-module/react.mjs
  var import_react = __toESM(require_react(), 1);
  function concatChildren(...childrenArguments) {
    return childrenArguments.reduce(
      (accumulator, children, i) => {
        import_react.Children.forEach(children, (child, j) => {
          if ((0, import_react.isValidElement)(child) && typeof child !== "string") {
            child = (0, import_react.cloneElement)(child, {
              key: [i, j].join()
            });
          }
          accumulator.push(child);
        });
        return accumulator;
      },
      []
    );
  }
  function switchChildrenNodeName(children, nodeName) {
    return children && import_react.Children.map(children, (elt, index) => {
      if (typeof elt?.valueOf() === "string") {
        return (0, import_react.createElement)(nodeName, { key: index }, elt);
      }
      if (!(0, import_react.isValidElement)(elt)) {
        return elt;
      }
      const { children: childrenProp, ...props } = elt.props;
      return (0, import_react.createElement)(
        nodeName,
        { key: index, ...props },
        childrenProp
      );
    });
  }

// packages/element/build-module/create-interpolate-element.mjs
  var indoc;
  var offset;
  var output;
  var stack;
  var tokenizer = /<(\/)?(\w+)\s*(\/)?>/g;
  function createFrame(element, tokenStart, tokenLength, prevOffset, leadingTextStart) {
    return {
      element,
      tokenStart,
      tokenLength,
      prevOffset,
      leadingTextStart,
      children: []
    };
  }
  function 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 {
    } while (proceed(conversionMap));
    return (0, import_react.createElement)(import_react.Fragment, null, ...output);
  }
  var isValidConversionMap = (conversionMap) => {
    const isObject2 = typeof conversionMap === "object" && conversionMap !== null;
    const values = isObject2 && Object.values(conversionMap);
    return isObject2 && values.length > 0 && values.every((element) => (0, import_react.isValidElement)(element));
  };
  function proceed(conversionMap) {
    const next = nextToken();
    const [tokenType, name, startOffset, tokenLength] = next;
    const stackDepth = stack.length;
    const leadingTextStart = startOffset > offset ? offset : null;
    if (name && !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;
        }
        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 (1 === stackDepth) {
          closeOuterElement(startOffset);
          offset = startOffset + tokenLength;
          return true;
        }
        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;
    }
  }
  function nextToken() {
    const matches = tokenizer.exec(indoc);
    if (null === matches) {
      return ["no-more-tokens"];
    }
    const startedAt = matches.index;
    const [match, isClosing, name, isSelfClosed] = matches;
    const length = match.length;
    if (isSelfClosed) {
      return ["self-closed", name, startedAt, length];
    }
    if (isClosing) {
      return ["closer", name, startedAt, length];
    }
    return ["opener", name, startedAt, length];
  }
  function addText() {
    const length = indoc.length - offset;
    if (0 === length) {
      return;
    }
    output.push(indoc.substr(offset, length));
  }
  function addChild(frame) {
    const { element, tokenStart, tokenLength, prevOffset, children } = frame;
    const parent = stack[stack.length - 1];
    const text = indoc.substr(
      parent.prevOffset,
      tokenStart - parent.prevOffset
    );
    if (text) {
      parent.children.push(text);
    }
    parent.children.push((0, import_react.cloneElement)(element, null, ...children));
    parent.prevOffset = prevOffset ? prevOffset : tokenStart + tokenLength;
  }
  function closeOuterElement(endOffset) {
    const { element, leadingTextStart, prevOffset, tokenStart, children } = stack.pop();
    const text = endOffset ? indoc.substr(prevOffset, endOffset - prevOffset) : indoc.substr(prevOffset);
    if (text) {
      children.push(text);
    }
    if (null !== leadingTextStart) {
      output.push(
        indoc.substr(leadingTextStart, tokenStart - leadingTextStart)
      );
    }
    output.push((0, import_react.cloneElement)(element, null, ...children));
  }
  var create_interpolate_element_default = createInterpolateElement;

// packages/element/build-module/react-platform.mjs
  var import_react_dom = __toESM(require_react_dom(), 1);
  var import_client = __toESM(require_client(), 1);

// packages/element/build-module/utils.mjs
  var isEmptyElement = (element) => {
    if (typeof element === "number") {
      return false;
    }
    if (typeof element?.valueOf() === "string" || Array.isArray(element)) {
      return !element.length;
    }
    return !element;
  };

// packages/element/build-module/platform.mjs
  var Platform = {
    /** Platform identifier. Will always be `'web'` in this module. */
    OS: "web",
    /**
     * Select a value based on the platform.
     *
     * @template T
     * @param    spec - Object with optional platform-specific values.
     * @return The selected value.
     */
    select(spec) {
      return "web" in spec ? spec.web : spec.default;
    },
    /** Whether the platform is web */
    isWeb: true
  };
  var platform_default = Platform;

// node_modules/is-plain-object/dist/is-plain-object.mjs
  function isObject(o) {
    return Object.prototype.toString.call(o) === "[object Object]";
  }
  function isPlainObject(o) {
    var ctor, prot;
    if (isObject(o) === false) return false;
    ctor = o.constructor;
    if (ctor === void 0) return true;
    prot = ctor.prototype;
    if (isObject(prot) === false) return false;
    if (prot.hasOwnProperty("isPrototypeOf") === false) {
      return false;
    }
    return true;
  }

// node_modules/tslib/tslib.es6.mjs
  var __assign = function() {
    __assign = Object.assign || function __assign2(t) {
      for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
      }
      return t;
    };
    return __assign.apply(this, arguments);
  };

// node_modules/lower-case/dist.es2015/index.js
  function lowerCase(str) {
    return str.toLowerCase();
  }

// node_modules/no-case/dist.es2015/index.js
  var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
  var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
  function noCase(input, options) {
    if (options === void 0) {
      options = {};
    }
    var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
    var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
    var start = 0;
    var end = result.length;
    while (result.charAt(start) === "\0")
      start++;
    while (result.charAt(end - 1) === "\0")
      end--;
    return result.slice(start, end).split("\0").map(transform).join(delimiter);
  }
  function replace(input, re, value) {
    if (re instanceof RegExp)
      return input.replace(re, value);
    return re.reduce(function(input2, re2) {
      return input2.replace(re2, value);
    }, input);
  }

// node_modules/dot-case/dist.es2015/index.js
  function dotCase(input, options) {
    if (options === void 0) {
      options = {};
    }
    return noCase(input, __assign({ delimiter: "." }, options));
  }

// node_modules/param-case/dist.es2015/index.js
  function paramCase(input, options) {
    if (options === void 0) {
      options = {};
    }
    return dotCase(input, __assign({ delimiter: "-" }, options));
  }

// packages/element/build-module/serialize.mjs
  var import_escape_html = __toESM(require_escape_html(), 1);

// packages/element/build-module/raw-html.mjs
  function RawHTML({ children, ...props }) {
    let rawHtml = "";
    import_react.Children.toArray(children).forEach((child) => {
      if (typeof child === "string" && child.trim() !== "") {
        rawHtml += child;
      }
    });
    return (0, import_react.createElement)("div", {
      dangerouslySetInnerHTML: { __html: rawHtml },
      ...props
    });
  }

// packages/element/build-module/serialize.mjs
  var Context = (0, import_react.createContext)(void 0);
  Context.displayName = "ElementContext";
  var { Provider, Consumer } = Context;
  var ForwardRef = (0, import_react.forwardRef)(() => {
    return null;
  });
  var ATTRIBUTES_TYPES = /* @__PURE__ */ new Set(["string", "boolean", "number"]);
  var SELF_CLOSING_TAGS = /* @__PURE__ */ new Set([
    "area",
    "base",
    "br",
    "col",
    "command",
    "embed",
    "hr",
    "img",
    "input",
    "keygen",
    "link",
    "meta",
    "param",
    "source",
    "track",
    "wbr"
  ]);
  var BOOLEAN_ATTRIBUTES = /* @__PURE__ */ new Set([
    "allowfullscreen",
    "allowpaymentrequest",
    "allowusermedia",
    "async",
    "autofocus",
    "autoplay",
    "checked",
    "controls",
    "default",
    "defer",
    "disabled",
    "download",
    "formnovalidate",
    "hidden",
    "ismap",
    "itemscope",
    "loop",
    "multiple",
    "muted",
    "nomodule",
    "novalidate",
    "open",
    "playsinline",
    "readonly",
    "required",
    "reversed",
    "selected",
    "typemustmatch"
  ]);
  var ENUMERATED_ATTRIBUTES = /* @__PURE__ */ new Set([
    "autocapitalize",
    "autocomplete",
    "charset",
    "contenteditable",
    "crossorigin",
    "decoding",
    "dir",
    "draggable",
    "enctype",
    "formenctype",
    "formmethod",
    "http-equiv",
    "inputmode",
    "kind",
    "method",
    "preload",
    "scope",
    "shape",
    "spellcheck",
    "translate",
    "type",
    "wrap"
  ]);
  var CSS_PROPERTIES_SUPPORTS_UNITLESS = /* @__PURE__ */ new Set([
    "animation",
    "animationIterationCount",
    "baselineShift",
    "borderImageOutset",
    "borderImageSlice",
    "borderImageWidth",
    "columnCount",
    "cx",
    "cy",
    "fillOpacity",
    "flexGrow",
    "flexShrink",
    "floodOpacity",
    "fontWeight",
    "gridColumnEnd",
    "gridColumnStart",
    "gridRowEnd",
    "gridRowStart",
    "lineHeight",
    "opacity",
    "order",
    "orphans",
    "r",
    "rx",
    "ry",
    "shapeImageThreshold",
    "stopOpacity",
    "strokeDasharray",
    "strokeDashoffset",
    "strokeMiterlimit",
    "strokeOpacity",
    "strokeWidth",
    "tabSize",
    "widows",
    "x",
    "y",
    "zIndex",
    "zoom"
  ]);
  function hasPrefix(string, prefixes) {
    return prefixes.some((prefix) => string.indexOf(prefix) === 0);
  }
  function isInternalAttribute(attribute) {
    return "key" === attribute || "children" === attribute;
  }
  function getNormalAttributeValue(attribute, value) {
    switch (attribute) {
      case "style":
        return renderStyle(value);
    }
    return value;
  }
  var SVG_ATTRIBUTE_WITH_DASHES_LIST = [
    "accentHeight",
    "alignmentBaseline",
    "arabicForm",
    "baselineShift",
    "capHeight",
    "clipPath",
    "clipRule",
    "colorInterpolation",
    "colorInterpolationFilters",
    "colorProfile",
    "colorRendering",
    "dominantBaseline",
    "enableBackground",
    "fillOpacity",
    "fillRule",
    "floodColor",
    "floodOpacity",
    "fontFamily",
    "fontSize",
    "fontSizeAdjust",
    "fontStretch",
    "fontStyle",
    "fontVariant",
    "fontWeight",
    "glyphName",
    "glyphOrientationHorizontal",
    "glyphOrientationVertical",
    "horizAdvX",
    "horizOriginX",
    "imageRendering",
    "letterSpacing",
    "lightingColor",
    "markerEnd",
    "markerMid",
    "markerStart",
    "overlinePosition",
    "overlineThickness",
    "paintOrder",
    "panose1",
    "pointerEvents",
    "renderingIntent",
    "shapeRendering",
    "stopColor",
    "stopOpacity",
    "strikethroughPosition",
    "strikethroughThickness",
    "strokeDasharray",
    "strokeDashoffset",
    "strokeLinecap",
    "strokeLinejoin",
    "strokeMiterlimit",
    "strokeOpacity",
    "strokeWidth",
    "textAnchor",
    "textDecoration",
    "textRendering",
    "underlinePosition",
    "underlineThickness",
    "unicodeBidi",
    "unicodeRange",
    "unitsPerEm",
    "vAlphabetic",
    "vHanging",
    "vIdeographic",
    "vMathematical",
    "vectorEffect",
    "vertAdvY",
    "vertOriginX",
    "vertOriginY",
    "wordSpacing",
    "writingMode",
    "xmlnsXlink",
    "xHeight"
  ].reduce(
    (map, attribute) => {
      map[attribute.toLowerCase()] = attribute;
      return map;
    },
    {}
  );
  var CASE_SENSITIVE_SVG_ATTRIBUTES = [
    "allowReorder",
    "attributeName",
    "attributeType",
    "autoReverse",
    "baseFrequency",
    "baseProfile",
    "calcMode",
    "clipPathUnits",
    "contentScriptType",
    "contentStyleType",
    "diffuseConstant",
    "edgeMode",
    "externalResourcesRequired",
    "filterRes",
    "filterUnits",
    "glyphRef",
    "gradientTransform",
    "gradientUnits",
    "kernelMatrix",
    "kernelUnitLength",
    "keyPoints",
    "keySplines",
    "keyTimes",
    "lengthAdjust",
    "limitingConeAngle",
    "markerHeight",
    "markerUnits",
    "markerWidth",
    "maskContentUnits",
    "maskUnits",
    "numOctaves",
    "pathLength",
    "patternContentUnits",
    "patternTransform",
    "patternUnits",
    "pointsAtX",
    "pointsAtY",
    "pointsAtZ",
    "preserveAlpha",
    "preserveAspectRatio",
    "primitiveUnits",
    "refX",
    "refY",
    "repeatCount",
    "repeatDur",
    "requiredExtensions",
    "requiredFeatures",
    "specularConstant",
    "specularExponent",
    "spreadMethod",
    "startOffset",
    "stdDeviation",
    "stitchTiles",
    "suppressContentEditableWarning",
    "suppressHydrationWarning",
    "surfaceScale",
    "systemLanguage",
    "tableValues",
    "targetX",
    "targetY",
    "textLength",
    "viewBox",
    "viewTarget",
    "xChannelSelector",
    "yChannelSelector"
  ].reduce(
    (map, attribute) => {
      map[attribute.toLowerCase()] = attribute;
      return map;
    },
    {}
  );
  var SVG_ATTRIBUTES_WITH_COLONS = [
    "xlink:actuate",
    "xlink:arcrole",
    "xlink:href",
    "xlink:role",
    "xlink:show",
    "xlink:title",
    "xlink:type",
    "xml:base",
    "xml:lang",
    "xml:space",
    "xmlns:xlink"
  ].reduce(
    (map, attribute) => {
      map[attribute.replace(":", "").toLowerCase()] = attribute;
      return map;
    },
    {}
  );
  function getNormalAttributeName(attribute) {
    switch (attribute) {
      case "htmlFor":
        return "for";
      case "className":
        return "class";
    }
    const attributeLowerCase = attribute.toLowerCase();
    if (CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase]) {
      return CASE_SENSITIVE_SVG_ATTRIBUTES[attributeLowerCase];
    } else if (SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]) {
      return paramCase(
        SVG_ATTRIBUTE_WITH_DASHES_LIST[attributeLowerCase]
      );
    } else if (SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase]) {
      return SVG_ATTRIBUTES_WITH_COLONS[attributeLowerCase];
    }
    return attributeLowerCase;
  }
  function getNormalStylePropertyName(property) {
    if (property.startsWith("--")) {
      return property;
    }
    if (hasPrefix(property, ["ms", "O", "Moz", "Webkit"])) {
      return "-" + paramCase(property);
    }
    return paramCase(property);
  }
  function getNormalStylePropertyValue(property, value) {
    if (typeof value === "number" && 0 !== value && !hasPrefix(property, ["--"]) && !CSS_PROPERTIES_SUPPORTS_UNITLESS.has(property)) {
      return value + "px";
    }
    return value;
  }
  function renderElement(element, context, legacyContext = {}) {
    if (null === element || void 0 === element || false === element) {
      return "";
    }
    if (Array.isArray(element)) {
      return renderChildren(element, context, legacyContext);
    }
    switch (typeof element) {
      case "string":
        return (0, import_escape_html.escapeHTML)(element);
      case "number":
        return element.toString();
    }
    const { type, props } = element;
    switch (type) {
      case import_react.StrictMode:
      case import_react.Fragment:
        return renderChildren(props.children, context, legacyContext);
      case RawHTML:
        const { children, ...wrapperProps } = props;
        return renderNativeComponent(
          !Object.keys(wrapperProps).length ? null : "div",
          {
            ...wrapperProps,
            dangerouslySetInnerHTML: { __html: children }
          },
          context,
          legacyContext
        );
    }
    switch (typeof type) {
      case "string":
        return renderNativeComponent(type, props, context, legacyContext);
      case "function":
        if (type.prototype && typeof type.prototype.render === "function") {
          return renderComponent(type, props, context, legacyContext);
        }
        return renderElement(
          type(props, legacyContext),
          context,
          legacyContext
        );
    }
    switch (type && type.$$typeof) {
      case Provider.$$typeof:
        return renderChildren(props.children, props.value, legacyContext);
      case Consumer.$$typeof:
        return renderElement(
          props.children(context || type._currentValue),
          context,
          legacyContext
        );
      case ForwardRef.$$typeof:
        return renderElement(
          type.render(props),
          context,
          legacyContext
        );
    }
    return "";
  }
  function renderNativeComponent(type, props, context, legacyContext = {}) {
    let content = "";
    if (type === "textarea" && props.hasOwnProperty("value")) {
      content = renderChildren(props.value, context, legacyContext);
      const { value, ...restProps } = props;
      props = restProps;
    } else if (props.dangerouslySetInnerHTML && typeof props.dangerouslySetInnerHTML.__html === "string") {
      content = props.dangerouslySetInnerHTML.__html;
    } else if (typeof props.children !== "undefined") {
      content = renderChildren(props.children, context, legacyContext);
    }
    if (!type) {
      return content;
    }
    const attributes = renderAttributes(props);
    if (SELF_CLOSING_TAGS.has(type)) {
      return "<" + type + attributes + "/>";
    }
    return "<" + type + attributes + ">" + content + "</" + type + ">";
  }
  function renderComponent(Component2, props, context, legacyContext = {}) {
    const instance = new Component2(props, legacyContext);
    if (typeof instance.getChildContext === "function") {
      Object.assign(legacyContext, instance.getChildContext());
    }
    const html = renderElement(instance.render(), context, legacyContext);
    return html;
  }
  function renderChildren(children, context, legacyContext = {}) {
    let result = "";
    const childrenArray = Array.isArray(children) ? children : [children];
    for (let i = 0; i < childrenArray.length; i++) {
      const child = childrenArray[i];
      result += renderElement(child, context, legacyContext);
    }
    return result;
  }
  function renderAttributes(props) {
    let result = "";
    for (const key in props) {
      const attribute = getNormalAttributeName(key);
      if (!(0, import_escape_html.isValidAttributeName)(attribute)) {
        continue;
      }
      let value = getNormalAttributeValue(key, props[key]);
      if (!ATTRIBUTES_TYPES.has(typeof value)) {
        continue;
      }
      if (isInternalAttribute(key)) {
        continue;
      }
      const isBooleanAttribute = BOOLEAN_ATTRIBUTES.has(attribute);
      if (isBooleanAttribute && value === false) {
        continue;
      }
      const isMeaningfulAttribute = isBooleanAttribute || hasPrefix(key, ["data-", "aria-"]) || ENUMERATED_ATTRIBUTES.has(attribute);
      if (typeof value === "boolean" && !isMeaningfulAttribute) {
        continue;
      }
      result += " " + attribute;
      if (isBooleanAttribute) {
        continue;
      }
      if (typeof value === "string") {
        value = (0, import_escape_html.escapeAttribute)(value);
      }
      result += '="' + value + '"';
    }
    return result;
  }
  function renderStyle(style) {
    if (!isPlainObject(style)) {
      return style;
    }
    let result;
    const styleObj = style;
    for (const property in styleObj) {
      const value = styleObj[property];
      if (null === value || void 0 === value) {
        continue;
      }
      if (result) {
        result += ";";
      } else {
        result = "";
      }
      const normalName = getNormalStylePropertyName(property);
      const normalValue = getNormalStylePropertyValue(property, value);
      result += normalName + ":" + normalValue;
    }
    return result;
  }
  var serialize_default = renderElement;
  return __toCommonJS(index_exports);
})();
/*! Bundled license information:

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.
   *)
*/
(window.wp ||= {}).element = wp.element;
})();

cmd: