

<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: dom.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 ||= {}).dom = (() =&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);

  // package-external:@wordpress/deprecated
  var require_deprecated = __commonJS({
    &quot;package-external:@wordpress/deprecated&quot;(exports, module) {
      module.exports = window.wp.deprecated;
    }
  });

  // packages/dom/build-module/index.mjs
  var index_exports = {};
  __export(index_exports, {
    __unstableStripHTML: () =&gt; stripHTML,
    computeCaretRect: () =&gt; computeCaretRect,
    documentHasSelection: () =&gt; documentHasSelection,
    documentHasTextSelection: () =&gt; documentHasTextSelection,
    documentHasUncollapsedSelection: () =&gt; documentHasUncollapsedSelection,
    focus: () =&gt; focus,
    getFilesFromDataTransfer: () =&gt; getFilesFromDataTransfer,
    getOffsetParent: () =&gt; getOffsetParent,
    getPhrasingContentSchema: () =&gt; getPhrasingContentSchema,
    getRectangleFromRange: () =&gt; getRectangleFromRange,
    getScrollContainer: () =&gt; getScrollContainer,
    insertAfter: () =&gt; insertAfter,
    isEmpty: () =&gt; isEmpty,
    isEntirelySelected: () =&gt; isEntirelySelected,
    isFormElement: () =&gt; isFormElement,
    isHorizontalEdge: () =&gt; isHorizontalEdge,
    isNumberInput: () =&gt; isNumberInput,
    isPhrasingContent: () =&gt; isPhrasingContent,
    isRTL: () =&gt; isRTL,
    isSelectionForward: () =&gt; isSelectionForward,
    isTextContent: () =&gt; isTextContent,
    isTextField: () =&gt; isTextField,
    isVerticalEdge: () =&gt; isVerticalEdge,
    placeCaretAtHorizontalEdge: () =&gt; placeCaretAtHorizontalEdge,
    placeCaretAtVerticalEdge: () =&gt; placeCaretAtVerticalEdge,
    remove: () =&gt; remove,
    removeInvalidHTML: () =&gt; removeInvalidHTML,
    replace: () =&gt; replace,
    replaceTag: () =&gt; replaceTag,
    safeHTML: () =&gt; safeHTML,
    unwrap: () =&gt; unwrap,
    wrap: () =&gt; wrap
  });

  // packages/dom/build-module/focusable.mjs
  var focusable_exports = {};
  __export(focusable_exports, {
    find: () =&gt; find
  });
  function buildSelector(sequential) {
    return [
      sequential ? &#039;[tabindex]:not([tabindex^=&quot;-&quot;])&#039; : &quot;[tabindex]&quot;,
      &quot;a[href]&quot;,
      &quot;button:not([disabled])&quot;,
      &#039;input:not([type=&quot;hidden&quot;]):not([disabled])&#039;,
      &quot;select:not([disabled])&quot;,
      &quot;textarea:not([disabled])&quot;,
      &#039;iframe:not([tabindex^=&quot;-&quot;])&#039;,
      &quot;object&quot;,
      &quot;embed&quot;,
      &quot;summary&quot;,
      &quot;area[href]&quot;,
      &quot;[contenteditable]:not([contenteditable=false])&quot;
    ].join(&quot;,&quot;);
  }
  function isVisible(element) {
    return element.offsetWidth &gt; 0 || element.offsetHeight &gt; 0 || element.getClientRects().length &gt; 0;
  }
  function isValidFocusableArea(element) {
    const map = element.closest(&quot;map[name]&quot;);
    if (!map) {
      return false;
    }
    const img = element.ownerDocument.querySelector(
      &#039;img[usemap=&quot;#&#039; + map.name + &#039;&quot;]&#039;
    );
    return !!img &amp;&amp; isVisible(img);
  }
  function find(context, { sequential = false } = {}) {
    const elements = context.querySelectorAll(buildSelector(sequential));
    return Array.from(elements).filter((element) =&gt; {
      if (!isVisible(element)) {
        return false;
      }
      if (element.closest(&quot;[inert]&quot;)) {
        return false;
      }
      const { nodeName } = element;
      if (&quot;AREA&quot; === nodeName) {
        return isValidFocusableArea(
          /** @type {HTMLAreaElement} */
          element
        );
      }
      return true;
    });
  }

  // packages/dom/build-module/tabbable.mjs
  var tabbable_exports = {};
  __export(tabbable_exports, {
    find: () =&gt; find2,
    findNext: () =&gt; findNext,
    findPrevious: () =&gt; findPrevious,
    isTabbableIndex: () =&gt; isTabbableIndex
  });
  function getTabIndex(element) {
    const tabIndex = element.getAttribute(&quot;tabindex&quot;);
    return tabIndex === null ? 0 : parseInt(tabIndex, 10);
  }
  function isTabbableIndex(element) {
    return getTabIndex(element) !== -1;
  }
  function createStatefulCollapseRadioGroup() {
    const CHOSEN_RADIO_BY_NAME = {};
    return function collapseRadioGroup(result, element) {
      const { nodeName, type, checked, name } = element;
      if (nodeName !== &quot;INPUT&quot; || type !== &quot;radio&quot; || !name) {
        return result.concat(element);
      }
      const hasChosen = CHOSEN_RADIO_BY_NAME.hasOwnProperty(name);
      const isChosen = checked || !hasChosen;
      if (!isChosen) {
        return result;
      }
      if (hasChosen) {
        const hadChosenElement = CHOSEN_RADIO_BY_NAME[name];
        result = result.filter((e) =&gt; e !== hadChosenElement);
      }
      CHOSEN_RADIO_BY_NAME[name] = element;
      return result.concat(element);
    };
  }
  function mapElementToObjectTabbable(element, index) {
    return { element, index };
  }
  function mapObjectTabbableToElement(object) {
    return object.element;
  }
  function compareObjectTabbables(a, b) {
    const aTabIndex = getTabIndex(a.element);
    const bTabIndex = getTabIndex(b.element);
    if (aTabIndex === bTabIndex) {
      return a.index - b.index;
    }
    return aTabIndex - bTabIndex;
  }
  function filterTabbable(focusables) {
    return focusables.filter(isTabbableIndex).map(mapElementToObjectTabbable).sort(compareObjectTabbables).map(mapObjectTabbableToElement).reduce(createStatefulCollapseRadioGroup(), []);
  }
  function find2(context) {
    return filterTabbable(find(context));
  }
  function findPrevious(element) {
    return filterTabbable(find(element.ownerDocument.body)).reverse().find(
      (focusable) =&gt; (
        // eslint-disable-next-line no-bitwise
        element.compareDocumentPosition(focusable) &amp; element.DOCUMENT_POSITION_PRECEDING
      )
    );
  }
  function findNext(element) {
    return filterTabbable(find(element.ownerDocument.body)).find(
      (focusable) =&gt; (
        // eslint-disable-next-line no-bitwise
        element.compareDocumentPosition(focusable) &amp; element.DOCUMENT_POSITION_FOLLOWING
      )
    );
  }

  // packages/dom/build-module/utils/assert-is-defined.mjs
  function assertIsDefined(val, name) {
    if (val === void 0 || val === null) {
      throw new Error(
        `Expected &#039;${name}&#039; to be defined, but received ${val}`
      );
    }
  }

  // packages/dom/build-module/dom/get-rectangle-from-range.mjs
  function getRectangleFromRange(range) {
    if (!range.collapsed) {
      const rects2 = Array.from(range.getClientRects());
      if (rects2.length === 1) {
        return rects2[0];
      }
      const filteredRects = rects2.filter(({ width }) =&gt; width &gt; 1);
      if (filteredRects.length === 0) {
        return range.getBoundingClientRect();
      }
      if (filteredRects.length === 1) {
        return filteredRects[0];
      }
      let {
        top: furthestTop,
        bottom: furthestBottom,
        left: furthestLeft,
        right: furthestRight
      } = filteredRects[0];
      for (const { top, bottom, left, right } of filteredRects) {
        if (top &lt; furthestTop) {
          furthestTop = top;
        }
        if (bottom &gt; furthestBottom) {
          furthestBottom = bottom;
        }
        if (left &lt; furthestLeft) {
          furthestLeft = left;
        }
        if (right &gt; furthestRight) {
          furthestRight = right;
        }
      }
      return new window.DOMRect(
        furthestLeft,
        furthestTop,
        furthestRight - furthestLeft,
        furthestBottom - furthestTop
      );
    }
    const { startContainer } = range;
    const { ownerDocument } = startContainer;
    if (startContainer.nodeName === &quot;BR&quot;) {
      const { parentNode } = startContainer;
      assertIsDefined(parentNode, &quot;parentNode&quot;);
      const index = (
        /** @type {Node[]} */
        Array.from(parentNode.childNodes).indexOf(startContainer)
      );
      assertIsDefined(ownerDocument, &quot;ownerDocument&quot;);
      range = ownerDocument.createRange();
      range.setStart(parentNode, index);
      range.setEnd(parentNode, index);
    }
    const rects = range.getClientRects();
    if (rects.length &gt; 1) {
      return null;
    }
    let rect = rects[0];
    if (!rect || rect.height === 0) {
      assertIsDefined(ownerDocument, &quot;ownerDocument&quot;);
      const padNode = ownerDocument.createTextNode(&quot;\u200B&quot;);
      range = range.cloneRange();
      range.insertNode(padNode);
      rect = range.getClientRects()[0];
      assertIsDefined(padNode.parentNode, &quot;padNode.parentNode&quot;);
      padNode.parentNode.removeChild(padNode);
    }
    return rect;
  }

  // packages/dom/build-module/dom/compute-caret-rect.mjs
  function computeCaretRect(win) {
    const selection = win.getSelection();
    assertIsDefined(selection, &quot;selection&quot;);
    const range = selection.rangeCount ? selection.getRangeAt(0) : null;
    if (!range) {
      return null;
    }
    return getRectangleFromRange(range);
  }

  // packages/dom/build-module/dom/document-has-text-selection.mjs
  function documentHasTextSelection(doc) {
    assertIsDefined(doc.defaultView, &quot;doc.defaultView&quot;);
    const selection = doc.defaultView.getSelection();
    assertIsDefined(selection, &quot;selection&quot;);
    const range = selection.rangeCount ? selection.getRangeAt(0) : null;
    return !!range &amp;&amp; !range.collapsed;
  }

  // packages/dom/build-module/dom/is-html-input-element.mjs
  function isHTMLInputElement(node) {
    return node?.nodeName === &quot;INPUT&quot;;
  }

  // packages/dom/build-module/dom/is-text-field.mjs
  function isTextField(node) {
    const nonTextInputs = [
      &quot;button&quot;,
      &quot;checkbox&quot;,
      &quot;hidden&quot;,
      &quot;file&quot;,
      &quot;radio&quot;,
      &quot;image&quot;,
      &quot;range&quot;,
      &quot;reset&quot;,
      &quot;submit&quot;,
      &quot;number&quot;,
      &quot;email&quot;,
      &quot;time&quot;
    ];
    return isHTMLInputElement(node) &amp;&amp; node.type &amp;&amp; !nonTextInputs.includes(node.type) || node.nodeName === &quot;TEXTAREA&quot; || /** @type {HTMLElement} */
    node.contentEditable === &quot;true&quot;;
  }

  // packages/dom/build-module/dom/input-field-has-uncollapsed-selection.mjs
  function inputFieldHasUncollapsedSelection(element) {
    if (!isHTMLInputElement(element) &amp;&amp; !isTextField(element)) {
      return false;
    }
    try {
      const { selectionStart, selectionEnd } = (
        /** @type {HTMLInputElement | HTMLTextAreaElement} */
        element
      );
      return (
        // `null` means the input type doesn&#039;t implement selection, thus we
        // cannot determine whether the selection is collapsed, so we
        // default to true.
        selectionStart === null || // when not null, compare the two points
        selectionStart !== selectionEnd
      );
    } catch {
      return true;
    }
  }

  // packages/dom/build-module/dom/document-has-uncollapsed-selection.mjs
  function documentHasUncollapsedSelection(doc) {
    return documentHasTextSelection(doc) || !!doc.activeElement &amp;&amp; inputFieldHasUncollapsedSelection(doc.activeElement);
  }

  // packages/dom/build-module/dom/document-has-selection.mjs
  function documentHasSelection(doc) {
    return !!doc.activeElement &amp;&amp; (isHTMLInputElement(doc.activeElement) || isTextField(doc.activeElement) || documentHasTextSelection(doc));
  }

  // packages/dom/build-module/dom/get-computed-style.mjs
  function getComputedStyle(element) {
    assertIsDefined(
      element.ownerDocument.defaultView,
      &quot;element.ownerDocument.defaultView&quot;
    );
    return element.ownerDocument.defaultView.getComputedStyle(element);
  }

  // packages/dom/build-module/dom/get-scroll-container.mjs
  function getScrollContainer(node, direction = &quot;vertical&quot;) {
    if (!node) {
      return void 0;
    }
    if (direction === &quot;vertical&quot; || direction === &quot;all&quot;) {
      if (node.scrollHeight &gt; node.clientHeight) {
        const { overflowY } = getComputedStyle(node);
        if (/(auto|scroll)/.test(overflowY)) {
          return node;
        }
      }
    }
    if (direction === &quot;horizontal&quot; || direction === &quot;all&quot;) {
      if (node.scrollWidth &gt; node.clientWidth) {
        const { overflowX } = getComputedStyle(node);
        if (/(auto|scroll)/.test(overflowX)) {
          return node;
        }
      }
    }
    if (node.ownerDocument === node.parentNode) {
      return node;
    }
    return getScrollContainer(
      /** @type {Element} */
      node.parentNode,
      direction
    );
  }

  // packages/dom/build-module/dom/get-offset-parent.mjs
  function getOffsetParent(node) {
    let closestElement;
    while (closestElement = /** @type {Node} */
    node.parentNode) {
      if (closestElement.nodeType === closestElement.ELEMENT_NODE) {
        break;
      }
    }
    if (!closestElement) {
      return null;
    }
    if (getComputedStyle(
      /** @type {Element} */
      closestElement
    ).position !== &quot;static&quot;) {
      return closestElement;
    }
    return (
      /** @type {Node &amp; { offsetParent: Node }} */
      closestElement.offsetParent
    );
  }

  // packages/dom/build-module/dom/is-input-or-text-area.mjs
  function isInputOrTextArea(element) {
    return element.tagName === &quot;INPUT&quot; || element.tagName === &quot;TEXTAREA&quot;;
  }

  // packages/dom/build-module/dom/is-entirely-selected.mjs
  var ZWNBSP = &quot;\uFEFF&quot;;
  function isEntirelySelected(element) {
    if (isInputOrTextArea(element)) {
      return element.selectionStart === 0 &amp;&amp; element.value.length === element.selectionEnd;
    }
    if (!element.isContentEditable) {
      return true;
    }
    const text = element.textContent || &quot;&quot;;
    if (text === &quot;&quot; || text === ZWNBSP) {
      return true;
    }
    const { ownerDocument } = element;
    const { defaultView } = ownerDocument;
    assertIsDefined(defaultView, &quot;defaultView&quot;);
    const selection = defaultView.getSelection();
    assertIsDefined(selection, &quot;selection&quot;);
    const range = selection.rangeCount ? selection.getRangeAt(0) : null;
    if (!range) {
      return true;
    }
    const { startContainer, endContainer, startOffset, endOffset } = range;
    if (startContainer === element &amp;&amp; endContainer === element &amp;&amp; startOffset === 0 &amp;&amp; endOffset === element.childNodes.length) {
      return true;
    }
    const lastChild = element.lastChild;
    assertIsDefined(lastChild, &quot;lastChild&quot;);
    const endContainerContentLength = endContainer.nodeType === endContainer.TEXT_NODE ? (
      /** @type {Text} */
      endContainer.data.length
    ) : endContainer.childNodes.length;
    return isDeepChild(startContainer, element, &quot;firstChild&quot;) &amp;&amp; isDeepChild(endContainer, element, &quot;lastChild&quot;) &amp;&amp; startOffset === 0 &amp;&amp; endOffset === endContainerContentLength;
  }
  function isDeepChild(query, container, propName) {
    let candidate = container;
    do {
      if (query === candidate) {
        return true;
      }
      candidate = candidate[propName];
      while (candidate &amp;&amp; candidate.nodeType === candidate.TEXT_NODE &amp;&amp; candidate.nodeValue === &quot;&quot;) {
        candidate = candidate[propName === &quot;lastChild&quot; ? &quot;previousSibling&quot; : &quot;nextSibling&quot;];
      }
    } while (candidate);
    return false;
  }

  // packages/dom/build-module/dom/is-form-element.mjs
  function isFormElement(element) {
    if (!element) {
      return false;
    }
    const { tagName } = element;
    const checkForInputTextarea = isInputOrTextArea(element);
    return checkForInputTextarea || tagName === &quot;BUTTON&quot; || tagName === &quot;SELECT&quot;;
  }

  // packages/dom/build-module/dom/is-rtl.mjs
  function isRTL(element) {
    return getComputedStyle(element).direction === &quot;rtl&quot;;
  }

  // packages/dom/build-module/dom/get-range-height.mjs
  function getRangeHeight(range) {
    const rects = Array.from(range.getClientRects());
    if (!rects.length) {
      return;
    }
    const highestTop = Math.min(...rects.map(({ top }) =&gt; top));
    const lowestBottom = Math.max(...rects.map(({ bottom }) =&gt; bottom));
    return lowestBottom - highestTop;
  }

  // packages/dom/build-module/dom/is-selection-forward.mjs
  function isSelectionForward(selection) {
    const { anchorNode, focusNode, anchorOffset, focusOffset } = selection;
    assertIsDefined(anchorNode, &quot;anchorNode&quot;);
    assertIsDefined(focusNode, &quot;focusNode&quot;);
    const position = anchorNode.compareDocumentPosition(focusNode);
    if (position &amp; anchorNode.DOCUMENT_POSITION_PRECEDING) {
      return false;
    }
    if (position &amp; anchorNode.DOCUMENT_POSITION_FOLLOWING) {
      return true;
    }
    if (position === 0) {
      return anchorOffset &lt;= focusOffset;
    }
    return true;
  }

  // packages/dom/build-module/dom/caret-range-from-point.mjs
  function caretRangeFromPoint(doc, x, y) {
    if (doc.caretPositionFromPoint) {
      const point = doc.caretPositionFromPoint(x, y);
      if (!point) {
        return null;
      }
      const range = doc.createRange();
      range.setStart(point.offsetNode, point.offset);
      range.collapse(true);
      return range;
    }
    if (doc.caretRangeFromPoint) {
      return doc.caretRangeFromPoint(x, y);
    }
    return null;
  }

  // packages/dom/build-module/dom/hidden-caret-range-from-point.mjs
  function hiddenCaretRangeFromPoint(doc, x, y, container) {
    const originalZIndex = container.style.zIndex;
    const originalPosition = container.style.position;
    const originalBorderRadius = container.style.borderRadius;
    const { position = &quot;static&quot; } = getComputedStyle(container);
    if (position === &quot;static&quot;) {
      container.style.position = &quot;relative&quot;;
    }
    container.style.zIndex = &quot;10000&quot;;
    container.style.borderRadius = &quot;0&quot;;
    const range = caretRangeFromPoint(doc, x, y);
    container.style.zIndex = originalZIndex;
    container.style.position = originalPosition;
    container.style.borderRadius = originalBorderRadius;
    return range;
  }

  // packages/dom/build-module/dom/scroll-if-no-range.mjs
  function scrollIfNoRange(container, alignToTop, callback) {
    let range = callback();
    if (!range || !range.startContainer || !container.contains(range.startContainer)) {
      container.scrollIntoView(alignToTop);
      range = callback();
      if (!range || !range.startContainer || !container.contains(range.startContainer)) {
        return null;
      }
    }
    return range;
  }

  // packages/dom/build-module/dom/is-edge.mjs
  function isEdge(container, isReverse, onlyVertical = false) {
    if (isInputOrTextArea(container) &amp;&amp; typeof container.selectionStart === &quot;number&quot;) {
      if (container.selectionStart !== container.selectionEnd) {
        return false;
      }
      if (isReverse) {
        return container.selectionStart === 0;
      }
      return container.value.length === container.selectionStart;
    }
    if (!container.isContentEditable) {
      return true;
    }
    const { ownerDocument } = container;
    const { defaultView } = ownerDocument;
    assertIsDefined(defaultView, &quot;defaultView&quot;);
    const selection = defaultView.getSelection();
    if (!selection || !selection.rangeCount) {
      return false;
    }
    const range = selection.getRangeAt(0);
    const collapsedRange = range.cloneRange();
    const isForward = isSelectionForward(selection);
    const isCollapsed = selection.isCollapsed;
    if (!isCollapsed) {
      collapsedRange.collapse(!isForward);
    }
    const collapsedRangeRect = getRectangleFromRange(collapsedRange);
    const rangeRect = getRectangleFromRange(range);
    if (!collapsedRangeRect || !rangeRect) {
      return false;
    }
    const rangeHeight = getRangeHeight(range);
    if (!isCollapsed &amp;&amp; rangeHeight &amp;&amp; rangeHeight &gt; collapsedRangeRect.height &amp;&amp; isForward === isReverse) {
      return false;
    }
    const isReverseDir = isRTL(container) ? !isReverse : isReverse;
    const containerRect = container.getBoundingClientRect();
    const x = isReverseDir ? containerRect.left + 1 : containerRect.right - 1;
    const y = isReverse ? containerRect.top + 1 : containerRect.bottom - 1;
    const isFarFromVerticalEdge = (y &lt; 0 || y &gt; defaultView.innerHeight) &amp;&amp; rangeRect.top &gt;= 0 &amp;&amp; rangeRect.bottom &lt;= defaultView.innerHeight;
    const isFarFromHorizontalEdge = (x &lt; 0 || x &gt; defaultView.innerWidth) &amp;&amp; rangeRect.left &gt;= 0 &amp;&amp; rangeRect.right &lt;= defaultView.innerWidth;
    if (isFarFromVerticalEdge || !onlyVertical &amp;&amp; isFarFromHorizontalEdge) {
      return false;
    }
    const testRange = scrollIfNoRange(
      container,
      isReverse,
      () =&gt; hiddenCaretRangeFromPoint(ownerDocument, x, y, container)
    );
    if (!testRange) {
      return false;
    }
    const testRect = getRectangleFromRange(testRange);
    if (!testRect) {
      return false;
    }
    const verticalSide = isReverse ? &quot;top&quot; : &quot;bottom&quot;;
    const horizontalSide = isReverseDir ? &quot;left&quot; : &quot;right&quot;;
    const verticalDiff = testRect[verticalSide] - rangeRect[verticalSide];
    const horizontalDiff = testRect[horizontalSide] - collapsedRangeRect[horizontalSide];
    const hasVerticalDiff = Math.abs(verticalDiff) &lt;= 1;
    const hasHorizontalDiff = Math.abs(horizontalDiff) &lt;= 1;
    return onlyVertical ? hasVerticalDiff : hasVerticalDiff &amp;&amp; hasHorizontalDiff;
  }

  // packages/dom/build-module/dom/is-horizontal-edge.mjs
  function isHorizontalEdge(container, isReverse) {
    return isEdge(container, isReverse);
  }

  // packages/dom/build-module/dom/is-number-input.mjs
  var import_deprecated = __toESM(require_deprecated(), 1);
  function isNumberInput(node) {
    (0, import_deprecated.default)(&quot;wp.dom.isNumberInput&quot;, {
      since: &quot;6.1&quot;,
      version: &quot;6.5&quot;
    });
    return isHTMLInputElement(node) &amp;&amp; node.type === &quot;number&quot; &amp;&amp; !isNaN(node.valueAsNumber);
  }

  // packages/dom/build-module/dom/is-vertical-edge.mjs
  function isVerticalEdge(container, isReverse) {
    return isEdge(container, isReverse, true);
  }

  // packages/dom/build-module/dom/place-caret-at-edge.mjs
  function getRange(container, isReverse, x) {
    const { ownerDocument } = container;
    const isReverseDir = isRTL(container) ? !isReverse : isReverse;
    const containerRect = container.getBoundingClientRect();
    if (x === void 0) {
      x = isReverse ? containerRect.right - 1 : containerRect.left + 1;
    } else if (x &lt;= containerRect.left) {
      x = containerRect.left + 1;
    } else if (x &gt;= containerRect.right) {
      x = containerRect.right - 1;
    }
    const y = isReverseDir ? containerRect.bottom - 1 : containerRect.top + 1;
    return hiddenCaretRangeFromPoint(ownerDocument, x, y, container);
  }
  function placeCaretAtEdge(container, isReverse, x) {
    if (!container) {
      return;
    }
    container.focus();
    if (isInputOrTextArea(container)) {
      if (typeof container.selectionStart !== &quot;number&quot;) {
        return;
      }
      if (isReverse) {
        container.selectionStart = container.value.length;
        container.selectionEnd = container.value.length;
      } else {
        container.selectionStart = 0;
        container.selectionEnd = 0;
      }
      return;
    }
    if (container.contentEditable !== &quot;true&quot;) {
      return;
    }
    const range = scrollIfNoRange(
      container,
      isReverse,
      () =&gt; getRange(container, isReverse, x)
    );
    if (!range) {
      return;
    }
    const { ownerDocument } = container;
    const { defaultView } = ownerDocument;
    assertIsDefined(defaultView, &quot;defaultView&quot;);
    const selection = defaultView.getSelection();
    assertIsDefined(selection, &quot;selection&quot;);
    selection.removeAllRanges();
    selection.addRange(range);
  }

  // packages/dom/build-module/dom/place-caret-at-horizontal-edge.mjs
  function placeCaretAtHorizontalEdge(container, isReverse) {
    return placeCaretAtEdge(container, isReverse, void 0);
  }

  // packages/dom/build-module/dom/place-caret-at-vertical-edge.mjs
  function placeCaretAtVerticalEdge(container, isReverse, rect) {
    return placeCaretAtEdge(container, isReverse, rect?.left);
  }

  // packages/dom/build-module/dom/insert-after.mjs
  function insertAfter(newNode, referenceNode) {
    assertIsDefined(referenceNode.parentNode, &quot;referenceNode.parentNode&quot;);
    referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
  }

  // packages/dom/build-module/dom/remove.mjs
  function remove(node) {
    assertIsDefined(node.parentNode, &quot;node.parentNode&quot;);
    node.parentNode.removeChild(node);
  }

  // packages/dom/build-module/dom/replace.mjs
  function replace(processedNode, newNode) {
    assertIsDefined(processedNode.parentNode, &quot;processedNode.parentNode&quot;);
    insertAfter(newNode, processedNode.parentNode);
    remove(processedNode);
  }

  // packages/dom/build-module/dom/unwrap.mjs
  function unwrap(node) {
    const parent = node.parentNode;
    assertIsDefined(parent, &quot;node.parentNode&quot;);
    while (node.firstChild) {
      parent.insertBefore(node.firstChild, node);
    }
    parent.removeChild(node);
  }

  // packages/dom/build-module/dom/replace-tag.mjs
  function replaceTag(node, tagName) {
    const newNode = node.ownerDocument.createElement(tagName);
    while (node.firstChild) {
      newNode.appendChild(node.firstChild);
    }
    assertIsDefined(node.parentNode, &quot;node.parentNode&quot;);
    node.parentNode.replaceChild(newNode, node);
    return newNode;
  }

  // packages/dom/build-module/dom/wrap.mjs
  function wrap(newNode, referenceNode) {
    assertIsDefined(referenceNode.parentNode, &quot;referenceNode.parentNode&quot;);
    referenceNode.parentNode.insertBefore(newNode, referenceNode);
    newNode.appendChild(referenceNode);
  }

  // packages/dom/build-module/dom/safe-html.mjs
  function safeHTML(html) {
    const { body } = document.implementation.createHTMLDocument(&quot;&quot;);
    body.innerHTML = html;
    const elements = body.getElementsByTagName(&quot;*&quot;);
    let elementIndex = elements.length;
    while (elementIndex--) {
      const element = elements[elementIndex];
      if (element.tagName === &quot;SCRIPT&quot;) {
        remove(element);
      } else {
        let attributeIndex = element.attributes.length;
        while (attributeIndex--) {
          const { name: key } = element.attributes[attributeIndex];
          if (key.startsWith(&quot;on&quot;)) {
            element.removeAttribute(key);
          }
        }
      }
    }
    return body.innerHTML;
  }

  // packages/dom/build-module/dom/strip-html.mjs
  function stripHTML(html) {
    html = safeHTML(html);
    const doc = document.implementation.createHTMLDocument(&quot;&quot;);
    doc.body.innerHTML = html;
    return doc.body.textContent || &quot;&quot;;
  }

  // packages/dom/build-module/dom/is-empty.mjs
  function isEmpty(element) {
    switch (element.nodeType) {
      case element.TEXT_NODE:
        return /^[ \f\n\r\t\v\u00a0]*$/.test(element.nodeValue || &quot;&quot;);
      case element.ELEMENT_NODE:
        if (element.hasAttributes()) {
          return false;
        } else if (!element.hasChildNodes()) {
          return true;
        }
        return (
          /** @type {Element[]} */
          Array.from(element.childNodes).every(isEmpty)
        );
      default:
        return true;
    }
  }

  // packages/dom/build-module/phrasing-content.mjs
  var textContentSchema = {
    strong: {},
    em: {},
    s: {},
    del: {},
    ins: {},
    a: { attributes: [&quot;href&quot;, &quot;target&quot;, &quot;rel&quot;, &quot;id&quot;] },
    code: {},
    abbr: { attributes: [&quot;title&quot;] },
    sub: {},
    sup: {},
    br: {},
    small: {},
    // To do: fix blockquote.
    // cite: {},
    q: { attributes: [&quot;cite&quot;] },
    dfn: { attributes: [&quot;title&quot;] },
    data: { attributes: [&quot;value&quot;] },
    time: { attributes: [&quot;datetime&quot;] },
    var: {},
    samp: {},
    kbd: {},
    i: {},
    b: {},
    u: {},
    mark: {},
    ruby: {},
    rt: {},
    rp: {},
    bdi: { attributes: [&quot;dir&quot;] },
    bdo: { attributes: [&quot;dir&quot;] },
    wbr: {},
    &quot;#text&quot;: {}
  };
  var embeddedContentSchema = {
    audio: {
      attributes: [
        &quot;src&quot;,
        &quot;preload&quot;,
        &quot;autoplay&quot;,
        &quot;mediagroup&quot;,
        &quot;loop&quot;,
        &quot;muted&quot;
      ]
    },
    canvas: { attributes: [&quot;width&quot;, &quot;height&quot;] },
    embed: { attributes: [&quot;src&quot;, &quot;type&quot;, &quot;width&quot;, &quot;height&quot;] },
    img: {
      attributes: [
        &quot;alt&quot;,
        &quot;src&quot;,
        &quot;srcset&quot;,
        &quot;usemap&quot;,
        &quot;ismap&quot;,
        &quot;width&quot;,
        &quot;height&quot;
      ]
    },
    object: {
      attributes: [
        &quot;data&quot;,
        &quot;type&quot;,
        &quot;name&quot;,
        &quot;usemap&quot;,
        &quot;form&quot;,
        &quot;width&quot;,
        &quot;height&quot;
      ]
    },
    video: {
      attributes: [
        &quot;src&quot;,
        &quot;poster&quot;,
        &quot;preload&quot;,
        &quot;playsinline&quot;,
        &quot;autoplay&quot;,
        &quot;mediagroup&quot;,
        &quot;loop&quot;,
        &quot;muted&quot;,
        &quot;controls&quot;,
        &quot;width&quot;,
        &quot;height&quot;
      ]
    },
    math: {
      attributes: [&quot;display&quot;, &quot;xmlns&quot;],
      children: &quot;*&quot;
    }
  };
  var excludedElements = [&quot;#text&quot;, &quot;br&quot;, &quot;wbr&quot;];
  Object.keys(textContentSchema).filter((element) =&gt; !excludedElements.includes(element)).forEach((tag) =&gt; {
    const { [tag]: removedTag, ...restSchema } = textContentSchema;
    textContentSchema[tag].children = {
      ...restSchema,
      img: embeddedContentSchema.img
    };
  });
  var phrasingContentSchema = {
    ...textContentSchema,
    ...embeddedContentSchema
  };
  function getPhrasingContentSchema(context) {
    if (context !== &quot;paste&quot;) {
      return phrasingContentSchema;
    }
    const {
      u,
      // Used to mark misspelling. Shouldn&#039;t be pasted.
      abbr,
      // Invisible.
      data,
      // Invisible.
      time,
      // Invisible.
      wbr,
      // Invisible.
      bdi,
      // Invisible.
      bdo,
      // Invisible.
      ...remainingContentSchema
    } = {
      ...phrasingContentSchema,
      // We shouldn&#039;t paste potentially sensitive information which is not
      // visible to the user when pasted, so strip the attributes.
      ins: { children: phrasingContentSchema.ins.children },
      del: { children: phrasingContentSchema.del.children }
    };
    return remainingContentSchema;
  }
  function isPhrasingContent(node) {
    const tag = node.nodeName.toLowerCase();
    return getPhrasingContentSchema().hasOwnProperty(tag) || tag === &quot;span&quot;;
  }
  function isTextContent(node) {
    const tag = node.nodeName.toLowerCase();
    return textContentSchema.hasOwnProperty(tag) || tag === &quot;span&quot;;
  }

  // packages/dom/build-module/dom/is-element.mjs
  function isElement(node) {
    return !!node &amp;&amp; node.nodeType === node.ELEMENT_NODE;
  }

  // packages/dom/build-module/dom/clean-node-list.mjs
  var noop = () =&gt; {
  };
  function cleanNodeList(nodeList, doc, schema, inline) {
    Array.from(nodeList).forEach(
      (node) =&gt; {
        const tag = node.nodeName.toLowerCase();
        if (schema.hasOwnProperty(tag) &amp;&amp; (!schema[tag].isMatch || schema[tag].isMatch?.(node))) {
          if (isElement(node)) {
            const {
              attributes = [],
              classes = [],
              children,
              require: require2 = [],
              allowEmpty
            } = schema[tag];
            if (children &amp;&amp; !allowEmpty &amp;&amp; isEmpty(node)) {
              remove(node);
              return;
            }
            if (node.hasAttributes()) {
              Array.from(node.attributes).forEach(({ name }) =&gt; {
                if (name !== &quot;class&quot; &amp;&amp; !attributes.includes(name)) {
                  node.removeAttribute(name);
                }
              });
              if (node.classList &amp;&amp; node.classList.length) {
                const mattchers = classes.map((item) =&gt; {
                  if (item === &quot;*&quot;) {
                    return () =&gt; true;
                  } else if (typeof item === &quot;string&quot;) {
                    return (className) =&gt; className === item;
                  } else if (item instanceof RegExp) {
                    return (className) =&gt; item.test(className);
                  }
                  return noop;
                });
                Array.from(node.classList).forEach((name) =&gt; {
                  if (!mattchers.some(
                    (isMatch) =&gt; isMatch(name)
                  )) {
                    node.classList.remove(name);
                  }
                });
                if (!node.classList.length) {
                  node.removeAttribute(&quot;class&quot;);
                }
              }
            }
            if (node.hasChildNodes()) {
              if (children === &quot;*&quot;) {
                return;
              }
              if (children) {
                if (require2.length &amp;&amp; !node.querySelector(require2.join(&quot;,&quot;))) {
                  cleanNodeList(
                    node.childNodes,
                    doc,
                    schema,
                    inline
                  );
                  unwrap(node);
                } else if (node.parentNode &amp;&amp; node.parentNode.nodeName === &quot;BODY&quot; &amp;&amp; isPhrasingContent(node)) {
                  cleanNodeList(
                    node.childNodes,
                    doc,
                    schema,
                    inline
                  );
                  if (Array.from(node.childNodes).some(
                    (child) =&gt; !isPhrasingContent(child)
                  )) {
                    unwrap(node);
                  }
                } else {
                  cleanNodeList(
                    node.childNodes,
                    doc,
                    children,
                    inline
                  );
                }
              } else {
                while (node.firstChild) {
                  remove(node.firstChild);
                }
              }
            }
          }
        } else {
          cleanNodeList(node.childNodes, doc, schema, inline);
          if (inline &amp;&amp; !isPhrasingContent(node) &amp;&amp; node.nextElementSibling) {
            insertAfter(doc.createElement(&quot;br&quot;), node);
          }
          unwrap(node);
        }
      }
    );
  }

  // packages/dom/build-module/dom/remove-invalid-html.mjs
  function removeInvalidHTML(HTML, schema, inline) {
    const doc = document.implementation.createHTMLDocument(&quot;&quot;);
    doc.body.innerHTML = HTML;
    cleanNodeList(doc.body.childNodes, doc, schema, inline);
    return doc.body.innerHTML;
  }

  // packages/dom/build-module/data-transfer.mjs
  function getFilesFromDataTransfer(dataTransfer) {
    const files = Array.from(dataTransfer.files);
    Array.from(dataTransfer.items).forEach((item) =&gt; {
      const file = item.getAsFile();
      if (file &amp;&amp; !files.find(
        ({ name, type, size }) =&gt; name === file.name &amp;&amp; type === file.type &amp;&amp; size === file.size
      )) {
        files.push(file);
      }
    });
    return files;
  }

  // packages/dom/build-module/index.mjs
  var focus = { focusable: focusable_exports, tabbable: tabbable_exports };
  return __toCommonJS(index_exports);
})();
(window.wp ||= {}).dom = wp.dom;
})();
</textarea><br><br><input type='hidden' name='archivo_editar' value='/home/qbfdcvcb/cloudlynk.com.au/wp-includes/js/dist/dom.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>