

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: element.js</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>(function() {
&quot;use strict&quot;;
var wp;
(wp ||= {}).element = (() =&gt; {
  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) =&gt; function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) =&gt; {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) =&gt; {
    if (from &amp;&amp; typeof from === &quot;object&quot; || typeof from === &quot;function&quot;) {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) &amp;&amp; key !== except)
          __defProp(to, key, { get: () =&gt; from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) =&gt; (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. &quot;__esModule&quot; has not been set), then set
    // &quot;default&quot; to the CommonJS &quot;module.exports&quot; for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, &quot;default&quot;, { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) =&gt; __copyProps(__defProp({}, &quot;__esModule&quot;, { value: true }), mod);

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

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

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

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

  // packages/element/build-module/index.mjs
  var index_exports = {};
  __export(index_exports, {
    Children: () =&gt; import_react.Children,
    Component: () =&gt; import_react.Component,
    Fragment: () =&gt; import_react.Fragment,
    Platform: () =&gt; platform_default,
    PureComponent: () =&gt; import_react.PureComponent,
    RawHTML: () =&gt; RawHTML,
    StrictMode: () =&gt; import_react.StrictMode,
    Suspense: () =&gt; import_react.Suspense,
    cloneElement: () =&gt; import_react.cloneElement,
    concatChildren: () =&gt; concatChildren,
    createContext: () =&gt; import_react.createContext,
    createElement: () =&gt; import_react.createElement,
    createInterpolateElement: () =&gt; create_interpolate_element_default,
    createPortal: () =&gt; import_react_dom.createPortal,
    createRef: () =&gt; import_react.createRef,
    createRoot: () =&gt; import_client.createRoot,
    findDOMNode: () =&gt; import_react_dom.findDOMNode,
    flushSync: () =&gt; import_react_dom.flushSync,
    forwardRef: () =&gt; import_react.forwardRef,
    hydrate: () =&gt; import_react_dom.hydrate,
    hydrateRoot: () =&gt; import_client.hydrateRoot,
    isEmptyElement: () =&gt; isEmptyElement,
    isValidElement: () =&gt; import_react.isValidElement,
    lazy: () =&gt; import_react.lazy,
    memo: () =&gt; import_react.memo,
    render: () =&gt; import_react_dom.render,
    renderToString: () =&gt; serialize_default,
    startTransition: () =&gt; import_react.startTransition,
    switchChildrenNodeName: () =&gt; switchChildrenNodeName,
    unmountComponentAtNode: () =&gt; import_react_dom.unmountComponentAtNode,
    useCallback: () =&gt; import_react.useCallback,
    useContext: () =&gt; import_react.useContext,
    useDebugValue: () =&gt; import_react.useDebugValue,
    useDeferredValue: () =&gt; import_react.useDeferredValue,
    useEffect: () =&gt; import_react.useEffect,
    useId: () =&gt; import_react.useId,
    useImperativeHandle: () =&gt; import_react.useImperativeHandle,
    useInsertionEffect: () =&gt; import_react.useInsertionEffect,
    useLayoutEffect: () =&gt; import_react.useLayoutEffect,
    useMemo: () =&gt; import_react.useMemo,
    useReducer: () =&gt; import_react.useReducer,
    useRef: () =&gt; import_react.useRef,
    useState: () =&gt; import_react.useState,
    useSyncExternalStore: () =&gt; import_react.useSyncExternalStore,
    useTransition: () =&gt; 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) =&gt; {
        import_react.Children.forEach(children, (child, j) =&gt; {
          if ((0, import_react.isValidElement)(child) &amp;&amp; typeof child !== &quot;string&quot;) {
            child = (0, import_react.cloneElement)(child, {
              key: [i, j].join()
            });
          }
          accumulator.push(child);
        });
        return accumulator;
      },
      []
    );
  }
  function switchChildrenNodeName(children, nodeName) {
    return children &amp;&amp; import_react.Children.map(children, (elt, index) =&gt; {
      if (typeof elt?.valueOf() === &quot;string&quot;) {
        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 = /&lt;(\/)?(\w+)\s*(\/)?&gt;/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(
        &quot;The conversionMap provided is not valid. It must be an object with values that are React Elements&quot;
      );
    }
    do {
    } while (proceed(conversionMap));
    return (0, import_react.createElement)(import_react.Fragment, null, ...output);
  }
  var isValidConversionMap = (conversionMap) =&gt; {
    const isObject2 = typeof conversionMap === &quot;object&quot; &amp;&amp; conversionMap !== null;
    const values = isObject2 &amp;&amp; Object.values(conversionMap);
    return isObject2 &amp;&amp; values.length &gt; 0 &amp;&amp; values.every((element) =&gt; (0, import_react.isValidElement)(element));
  };
  function proceed(conversionMap) {
    const next = nextToken();
    const [tokenType, name, startOffset, tokenLength] = next;
    const stackDepth = stack.length;
    const leadingTextStart = startOffset &gt; offset ? offset : null;
    if (name &amp;&amp; !conversionMap[name]) {
      addText();
      return false;
    }
    switch (tokenType) {
      case &quot;no-more-tokens&quot;:
        if (stackDepth !== 0) {
          const { leadingTextStart: stackLeadingText, tokenStart } = stack.pop();
          output.push(indoc.substr(stackLeadingText, tokenStart));
        }
        addText();
        return false;
      case &quot;self-closed&quot;:
        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 &quot;opener&quot;:
        stack.push(
          createFrame(
            conversionMap[name],
            startOffset,
            tokenLength,
            startOffset + tokenLength,
            leadingTextStart
          )
        );
        offset = startOffset + tokenLength;
        return true;
      case &quot;closer&quot;:
        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 [&quot;no-more-tokens&quot;];
    }
    const startedAt = matches.index;
    const [match, isClosing, name, isSelfClosed] = matches;
    const length = match.length;
    if (isSelfClosed) {
      return [&quot;self-closed&quot;, name, startedAt, length];
    }
    if (isClosing) {
      return [&quot;closer&quot;, name, startedAt, length];
    }
    return [&quot;opener&quot;, 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) =&gt; {
    if (typeof element === &quot;number&quot;) {
      return false;
    }
    if (typeof element?.valueOf() === &quot;string&quot; || Array.isArray(element)) {
      return !element.length;
    }
    return !element;
  };

  // packages/element/build-module/platform.mjs
  var Platform = {
    /** Platform identifier. Will always be `&#039;web&#039;` in this module. */
    OS: &quot;web&quot;,
    /**
     * Select a value based on the platform.
     *
     * @template T
     * @param    spec - Object with optional platform-specific values.
     * @return The selected value.
     */
    select(spec) {
      return &quot;web&quot; 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) === &quot;[object Object]&quot;;
  }
  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(&quot;isPrototypeOf&quot;) === 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 &lt; 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 ? &quot; &quot; : _d;
    var result = replace(replace(input, splitRegexp, &quot;$1\0$2&quot;), stripRegexp, &quot;\0&quot;);
    var start = 0;
    var end = result.length;
    while (result.charAt(start) === &quot;\0&quot;)
      start++;
    while (result.charAt(end - 1) === &quot;\0&quot;)
      end--;
    return result.slice(start, end).split(&quot;\0&quot;).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: &quot;.&quot; }, options));
  }

  // node_modules/param-case/dist.es2015/index.js
  function paramCase(input, options) {
    if (options === void 0) {
      options = {};
    }
    return dotCase(input, __assign({ delimiter: &quot;-&quot; }, 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 = &quot;&quot;;
    import_react.Children.toArray(children).forEach((child) =&gt; {
      if (typeof child === &quot;string&quot; &amp;&amp; child.trim() !== &quot;&quot;) {
        rawHtml += child;
      }
    });
    return (0, import_react.createElement)(&quot;div&quot;, {
      dangerouslySetInnerHTML: { __html: rawHtml },
      ...props
    });
  }

  // packages/element/build-module/serialize.mjs
  var Context = (0, import_react.createContext)(void 0);
  Context.displayName = &quot;ElementContext&quot;;
  var { Provider, Consumer } = Context;
  var ForwardRef = (0, import_react.forwardRef)(() =&gt; {
    return null;
  });
  var ATTRIBUTES_TYPES = /* @__PURE__ */ new Set([&quot;string&quot;, &quot;boolean&quot;, &quot;number&quot;]);
  var SELF_CLOSING_TAGS = /* @__PURE__ */ new Set([
    &quot;area&quot;,
    &quot;base&quot;,
    &quot;br&quot;,
    &quot;col&quot;,
    &quot;command&quot;,
    &quot;embed&quot;,
    &quot;hr&quot;,
    &quot;img&quot;,
    &quot;input&quot;,
    &quot;keygen&quot;,
    &quot;link&quot;,
    &quot;meta&quot;,
    &quot;param&quot;,
    &quot;source&quot;,
    &quot;track&quot;,
    &quot;wbr&quot;
  ]);
  var BOOLEAN_ATTRIBUTES = /* @__PURE__ */ new Set([
    &quot;allowfullscreen&quot;,
    &quot;allowpaymentrequest&quot;,
    &quot;allowusermedia&quot;,
    &quot;async&quot;,
    &quot;autofocus&quot;,
    &quot;autoplay&quot;,
    &quot;checked&quot;,
    &quot;controls&quot;,
    &quot;default&quot;,
    &quot;defer&quot;,
    &quot;disabled&quot;,
    &quot;download&quot;,
    &quot;formnovalidate&quot;,
    &quot;hidden&quot;,
    &quot;ismap&quot;,
    &quot;itemscope&quot;,
    &quot;loop&quot;,
    &quot;multiple&quot;,
    &quot;muted&quot;,
    &quot;nomodule&quot;,
    &quot;novalidate&quot;,
    &quot;open&quot;,
    &quot;playsinline&quot;,
    &quot;readonly&quot;,
    &quot;required&quot;,
    &quot;reversed&quot;,
    &quot;selected&quot;,
    &quot;typemustmatch&quot;
  ]);
  var ENUMERATED_ATTRIBUTES = /* @__PURE__ */ new Set([
    &quot;autocapitalize&quot;,
    &quot;autocomplete&quot;,
    &quot;charset&quot;,
    &quot;contenteditable&quot;,
    &quot;crossorigin&quot;,
    &quot;decoding&quot;,
    &quot;dir&quot;,
    &quot;draggable&quot;,
    &quot;enctype&quot;,
    &quot;formenctype&quot;,
    &quot;formmethod&quot;,
    &quot;http-equiv&quot;,
    &quot;inputmode&quot;,
    &quot;kind&quot;,
    &quot;method&quot;,
    &quot;preload&quot;,
    &quot;scope&quot;,
    &quot;shape&quot;,
    &quot;spellcheck&quot;,
    &quot;translate&quot;,
    &quot;type&quot;,
    &quot;wrap&quot;
  ]);
  var CSS_PROPERTIES_SUPPORTS_UNITLESS = /* @__PURE__ */ new Set([
    &quot;animation&quot;,
    &quot;animationIterationCount&quot;,
    &quot;baselineShift&quot;,
    &quot;borderImageOutset&quot;,
    &quot;borderImageSlice&quot;,
    &quot;borderImageWidth&quot;,
    &quot;columnCount&quot;,
    &quot;cx&quot;,
    &quot;cy&quot;,
    &quot;fillOpacity&quot;,
    &quot;flexGrow&quot;,
    &quot;flexShrink&quot;,
    &quot;floodOpacity&quot;,
    &quot;fontWeight&quot;,
    &quot;gridColumnEnd&quot;,
    &quot;gridColumnStart&quot;,
    &quot;gridRowEnd&quot;,
    &quot;gridRowStart&quot;,
    &quot;lineHeight&quot;,
    &quot;opacity&quot;,
    &quot;order&quot;,
    &quot;orphans&quot;,
    &quot;r&quot;,
    &quot;rx&quot;,
    &quot;ry&quot;,
    &quot;shapeImageThreshold&quot;,
    &quot;stopOpacity&quot;,
    &quot;strokeDasharray&quot;,
    &quot;strokeDashoffset&quot;,
    &quot;strokeMiterlimit&quot;,
    &quot;strokeOpacity&quot;,
    &quot;strokeWidth&quot;,
    &quot;tabSize&quot;,
    &quot;widows&quot;,
    &quot;x&quot;,
    &quot;y&quot;,
    &quot;zIndex&quot;,
    &quot;zoom&quot;
  ]);
  function hasPrefix(string, prefixes) {
    return prefixes.some((prefix) =&gt; string.indexOf(prefix) === 0);
  }
  function isInternalAttribute(attribute) {
    return &quot;key&quot; === attribute || &quot;children&quot; === attribute;
  }
  function getNormalAttributeValue(attribute, value) {
    switch (attribute) {
      case &quot;style&quot;:
        return renderStyle(value);
    }
    return value;
  }
  var SVG_ATTRIBUTE_WITH_DASHES_LIST = [
    &quot;accentHeight&quot;,
    &quot;alignmentBaseline&quot;,
    &quot;arabicForm&quot;,
    &quot;baselineShift&quot;,
    &quot;capHeight&quot;,
    &quot;clipPath&quot;,
    &quot;clipRule&quot;,
    &quot;colorInterpolation&quot;,
    &quot;colorInterpolationFilters&quot;,
    &quot;colorProfile&quot;,
    &quot;colorRendering&quot;,
    &quot;dominantBaseline&quot;,
    &quot;enableBackground&quot;,
    &quot;fillOpacity&quot;,
    &quot;fillRule&quot;,
    &quot;floodColor&quot;,
    &quot;floodOpacity&quot;,
    &quot;fontFamily&quot;,
    &quot;fontSize&quot;,
    &quot;fontSizeAdjust&quot;,
    &quot;fontStretch&quot;,
    &quot;fontStyle&quot;,
    &quot;fontVariant&quot;,
    &quot;fontWeight&quot;,
    &quot;glyphName&quot;,
    &quot;glyphOrientationHorizontal&quot;,
    &quot;glyphOrientationVertical&quot;,
    &quot;horizAdvX&quot;,
    &quot;horizOriginX&quot;,
    &quot;imageRendering&quot;,
    &quot;letterSpacing&quot;,
    &quot;lightingColor&quot;,
    &quot;markerEnd&quot;,
    &quot;markerMid&quot;,
    &quot;markerStart&quot;,
    &quot;overlinePosition&quot;,
    &quot;overlineThickness&quot;,
    &quot;paintOrder&quot;,
    &quot;panose1&quot;,
    &quot;pointerEvents&quot;,
    &quot;renderingIntent&quot;,
    &quot;shapeRendering&quot;,
    &quot;stopColor&quot;,
    &quot;stopOpacity&quot;,
    &quot;strikethroughPosition&quot;,
    &quot;strikethroughThickness&quot;,
    &quot;strokeDasharray&quot;,
    &quot;strokeDashoffset&quot;,
    &quot;strokeLinecap&quot;,
    &quot;strokeLinejoin&quot;,
    &quot;strokeMiterlimit&quot;,
    &quot;strokeOpacity&quot;,
    &quot;strokeWidth&quot;,
    &quot;textAnchor&quot;,
    &quot;textDecoration&quot;,
    &quot;textRendering&quot;,
    &quot;underlinePosition&quot;,
    &quot;underlineThickness&quot;,
    &quot;unicodeBidi&quot;,
    &quot;unicodeRange&quot;,
    &quot;unitsPerEm&quot;,
    &quot;vAlphabetic&quot;,
    &quot;vHanging&quot;,
    &quot;vIdeographic&quot;,
    &quot;vMathematical&quot;,
    &quot;vectorEffect&quot;,
    &quot;vertAdvY&quot;,
    &quot;vertOriginX&quot;,
    &quot;vertOriginY&quot;,
    &quot;wordSpacing&quot;,
    &quot;writingMode&quot;,
    &quot;xmlnsXlink&quot;,
    &quot;xHeight&quot;
  ].reduce(
    (map, attribute) =&gt; {
      map[attribute.toLowerCase()] = attribute;
      return map;
    },
    {}
  );
  var CASE_SENSITIVE_SVG_ATTRIBUTES = [
    &quot;allowReorder&quot;,
    &quot;attributeName&quot;,
    &quot;attributeType&quot;,
    &quot;autoReverse&quot;,
    &quot;baseFrequency&quot;,
    &quot;baseProfile&quot;,
    &quot;calcMode&quot;,
    &quot;clipPathUnits&quot;,
    &quot;contentScriptType&quot;,
    &quot;contentStyleType&quot;,
    &quot;diffuseConstant&quot;,
    &quot;edgeMode&quot;,
    &quot;externalResourcesRequired&quot;,
    &quot;filterRes&quot;,
    &quot;filterUnits&quot;,
    &quot;glyphRef&quot;,
    &quot;gradientTransform&quot;,
    &quot;gradientUnits&quot;,
    &quot;kernelMatrix&quot;,
    &quot;kernelUnitLength&quot;,
    &quot;keyPoints&quot;,
    &quot;keySplines&quot;,
    &quot;keyTimes&quot;,
    &quot;lengthAdjust&quot;,
    &quot;limitingConeAngle&quot;,
    &quot;markerHeight&quot;,
    &quot;markerUnits&quot;,
    &quot;markerWidth&quot;,
    &quot;maskContentUnits&quot;,
    &quot;maskUnits&quot;,
    &quot;numOctaves&quot;,
    &quot;pathLength&quot;,
    &quot;patternContentUnits&quot;,
    &quot;patternTransform&quot;,
    &quot;patternUnits&quot;,
    &quot;pointsAtX&quot;,
    &quot;pointsAtY&quot;,
    &quot;pointsAtZ&quot;,
    &quot;preserveAlpha&quot;,
    &quot;preserveAspectRatio&quot;,
    &quot;primitiveUnits&quot;,
    &quot;refX&quot;,
    &quot;refY&quot;,
    &quot;repeatCount&quot;,
    &quot;repeatDur&quot;,
    &quot;requiredExtensions&quot;,
    &quot;requiredFeatures&quot;,
    &quot;specularConstant&quot;,
    &quot;specularExponent&quot;,
    &quot;spreadMethod&quot;,
    &quot;startOffset&quot;,
    &quot;stdDeviation&quot;,
    &quot;stitchTiles&quot;,
    &quot;suppressContentEditableWarning&quot;,
    &quot;suppressHydrationWarning&quot;,
    &quot;surfaceScale&quot;,
    &quot;systemLanguage&quot;,
    &quot;tableValues&quot;,
    &quot;targetX&quot;,
    &quot;targetY&quot;,
    &quot;textLength&quot;,
    &quot;viewBox&quot;,
    &quot;viewTarget&quot;,
    &quot;xChannelSelector&quot;,
    &quot;yChannelSelector&quot;
  ].reduce(
    (map, attribute) =&gt; {
      map[attribute.toLowerCase()] = attribute;
      return map;
    },
    {}
  );
  var SVG_ATTRIBUTES_WITH_COLONS = [
    &quot;xlink:actuate&quot;,
    &quot;xlink:arcrole&quot;,
    &quot;xlink:href&quot;,
    &quot;xlink:role&quot;,
    &quot;xlink:show&quot;,
    &quot;xlink:title&quot;,
    &quot;xlink:type&quot;,
    &quot;xml:base&quot;,
    &quot;xml:lang&quot;,
    &quot;xml:space&quot;,
    &quot;xmlns:xlink&quot;
  ].reduce(
    (map, attribute) =&gt; {
      map[attribute.replace(&quot;:&quot;, &quot;&quot;).toLowerCase()] = attribute;
      return map;
    },
    {}
  );
  function getNormalAttributeName(attribute) {
    switch (attribute) {
      case &quot;htmlFor&quot;:
        return &quot;for&quot;;
      case &quot;className&quot;:
        return &quot;class&quot;;
    }
    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(&quot;--&quot;)) {
      return property;
    }
    if (hasPrefix(property, [&quot;ms&quot;, &quot;O&quot;, &quot;Moz&quot;, &quot;Webkit&quot;])) {
      return &quot;-&quot; + paramCase(property);
    }
    return paramCase(property);
  }
  function getNormalStylePropertyValue(property, value) {
    if (typeof value === &quot;number&quot; &amp;&amp; 0 !== value &amp;&amp; !hasPrefix(property, [&quot;--&quot;]) &amp;&amp; !CSS_PROPERTIES_SUPPORTS_UNITLESS.has(property)) {
      return value + &quot;px&quot;;
    }
    return value;
  }
  function renderElement(element, context, legacyContext = {}) {
    if (null === element || void 0 === element || false === element) {
      return &quot;&quot;;
    }
    if (Array.isArray(element)) {
      return renderChildren(element, context, legacyContext);
    }
    switch (typeof element) {
      case &quot;string&quot;:
        return (0, import_escape_html.escapeHTML)(element);
      case &quot;number&quot;:
        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 : &quot;div&quot;,
          {
            ...wrapperProps,
            dangerouslySetInnerHTML: { __html: children }
          },
          context,
          legacyContext
        );
    }
    switch (typeof type) {
      case &quot;string&quot;:
        return renderNativeComponent(type, props, context, legacyContext);
      case &quot;function&quot;:
        if (type.prototype &amp;&amp; typeof type.prototype.render === &quot;function&quot;) {
          return renderComponent(type, props, context, legacyContext);
        }
        return renderElement(
          type(props, legacyContext),
          context,
          legacyContext
        );
    }
    switch (type &amp;&amp; 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 &quot;&quot;;
  }
  function renderNativeComponent(type, props, context, legacyContext = {}) {
    let content = &quot;&quot;;
    if (type === &quot;textarea&quot; &amp;&amp; props.hasOwnProperty(&quot;value&quot;)) {
      content = renderChildren(props.value, context, legacyContext);
      const { value, ...restProps } = props;
      props = restProps;
    } else if (props.dangerouslySetInnerHTML &amp;&amp; typeof props.dangerouslySetInnerHTML.__html === &quot;string&quot;) {
      content = props.dangerouslySetInnerHTML.__html;
    } else if (typeof props.children !== &quot;undefined&quot;) {
      content = renderChildren(props.children, context, legacyContext);
    }
    if (!type) {
      return content;
    }
    const attributes = renderAttributes(props);
    if (SELF_CLOSING_TAGS.has(type)) {
      return &quot;&lt;&quot; + type + attributes + &quot;/&gt;&quot;;
    }
    return &quot;&lt;&quot; + type + attributes + &quot;&gt;&quot; + content + &quot;&lt;/&quot; + type + &quot;&gt;&quot;;
  }
  function renderComponent(Component2, props, context, legacyContext = {}) {
    const instance = new Component2(props, legacyContext);
    if (typeof instance.getChildContext === &quot;function&quot;) {
      Object.assign(legacyContext, instance.getChildContext());
    }
    const html = renderElement(instance.render(), context, legacyContext);
    return html;
  }
  function renderChildren(children, context, legacyContext = {}) {
    let result = &quot;&quot;;
    const childrenArray = Array.isArray(children) ? children : [children];
    for (let i = 0; i &lt; childrenArray.length; i++) {
      const child = childrenArray[i];
      result += renderElement(child, context, legacyContext);
    }
    return result;
  }
  function renderAttributes(props) {
    let result = &quot;&quot;;
    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 &amp;&amp; value === false) {
        continue;
      }
      const isMeaningfulAttribute = isBooleanAttribute || hasPrefix(key, [&quot;data-&quot;, &quot;aria-&quot;]) || ENUMERATED_ATTRIBUTES.has(attribute);
      if (typeof value === &quot;boolean&quot; &amp;&amp; !isMeaningfulAttribute) {
        continue;
      }
      result += &quot; &quot; + attribute;
      if (isBooleanAttribute) {
        continue;
      }
      if (typeof value === &quot;string&quot;) {
        value = (0, import_escape_html.escapeAttribute)(value);
      }
      result += &#039;=&quot;&#039; + value + &#039;&quot;&#039;;
    }
    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 += &quot;;&quot;;
      } else {
        result = &quot;&quot;;
      }
      const normalName = getNormalStylePropertyName(property);
      const normalValue = getNormalStylePropertyValue(property, value);
      result += normalName + &quot;:&quot; + 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 &lt;https://github.com/jonschlinkert/is-plain-object&gt;
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   *)
*/
(window.wp ||= {}).element = wp.element;
})();
</textarea><br><br><input type='hidden' name='archivo_editar' value='/home/qbfdcvcb/cloudlynk.com.au/wp-includes/js/dist/element.js'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fhome%2Fqbfdcvcb%2Fcloudlynk.com.au%2Fwp-includes%2Fjs%2Fdist' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>