✏️ Editing: element.js Writable

"use strict";
var wp;
(wp ||= {}).element = (() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __commonJS = (cb, mod) => function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

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

// node_modules/react-dom/client.js
  var require_client = __commonJS({
    "node_modules/react-dom/client.js"(exports) {
      "use strict";
      var m = require_react_dom();
      if (false) {
        exports.createRoot = m.createRoot;
        exports.hydrateRoot = m.hydrateRoot;
      } else {
        i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
        exports.createRoot = function(c, o) {
          i.usingClientEntryPoint = true;
          try {
            return m.createRoot(c, o);
          } finally {
            i.usingClientEntryPoint = false;
          }
        };
        exports.hydrateRoot = function(c, h, o) {
          i.usingClientEntryPoint = true;
          try {
            return m.hydrateRoot(c, h, o);
          } finally {
            i.usingClientEntryPoint = false;
          }
        };
      }
      var i;
    }
  });

// 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: []
    };
  }
  var 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.
   *)
*/

🔐 Sid Gifari File Manager Pro