[Summary view] [Print] [Text view]

   1  (function() {
   2  "use strict";
   3  var wp;
   4  (wp ||= {}).dom = (() => {
   5    var __create = Object.create;
   6    var __defProp = Object.defineProperty;
   7    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   8    var __getOwnPropNames = Object.getOwnPropertyNames;
   9    var __getProtoOf = Object.getPrototypeOf;
  10    var __hasOwnProp = Object.prototype.hasOwnProperty;
  11    var __commonJS = (cb, mod) => function __require() {
  12      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  13    };
  14    var __export = (target, all) => {
  15      for (var name in all)
  16        __defProp(target, name, { get: all[name], enumerable: true });
  17    };
  18    var __copyProps = (to, from, except, desc) => {
  19      if (from && typeof from === "object" || typeof from === "function") {
  20        for (let key of __getOwnPropNames(from))
  21          if (!__hasOwnProp.call(to, key) && key !== except)
  22            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  23      }
  24      return to;
  25    };
  26    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  27      // If the importer is in node compatibility mode or this is not an ESM
  28      // file that has been converted to a CommonJS file using a Babel-
  29      // compatible transform (i.e. "__esModule" has not been set), then set
  30      // "default" to the CommonJS "module.exports" for node compatibility.
  31      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  32      mod
  33    ));
  34    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  35  
  36    // package-external:@wordpress/deprecated
  37    var require_deprecated = __commonJS({
  38      "package-external:@wordpress/deprecated"(exports, module) {
  39        module.exports = window.wp.deprecated;
  40      }
  41    });
  42  
  43    // packages/dom/build-module/index.mjs
  44    var index_exports = {};
  45    __export(index_exports, {
  46      __unstableStripHTML: () => stripHTML,
  47      computeCaretRect: () => computeCaretRect,
  48      documentHasSelection: () => documentHasSelection,
  49      documentHasTextSelection: () => documentHasTextSelection,
  50      documentHasUncollapsedSelection: () => documentHasUncollapsedSelection,
  51      focus: () => focus,
  52      getFilesFromDataTransfer: () => getFilesFromDataTransfer,
  53      getOffsetParent: () => getOffsetParent,
  54      getPhrasingContentSchema: () => getPhrasingContentSchema,
  55      getRectangleFromRange: () => getRectangleFromRange,
  56      getScrollContainer: () => getScrollContainer,
  57      insertAfter: () => insertAfter,
  58      isEmpty: () => isEmpty,
  59      isEntirelySelected: () => isEntirelySelected,
  60      isFormElement: () => isFormElement,
  61      isHorizontalEdge: () => isHorizontalEdge,
  62      isNumberInput: () => isNumberInput,
  63      isPhrasingContent: () => isPhrasingContent,
  64      isRTL: () => isRTL,
  65      isSelectionForward: () => isSelectionForward,
  66      isTextContent: () => isTextContent,
  67      isTextField: () => isTextField,
  68      isVerticalEdge: () => isVerticalEdge,
  69      placeCaretAtHorizontalEdge: () => placeCaretAtHorizontalEdge,
  70      placeCaretAtVerticalEdge: () => placeCaretAtVerticalEdge,
  71      remove: () => remove,
  72      removeInvalidHTML: () => removeInvalidHTML,
  73      replace: () => replace,
  74      replaceTag: () => replaceTag,
  75      safeHTML: () => safeHTML,
  76      unwrap: () => unwrap,
  77      wrap: () => wrap
  78    });
  79  
  80    // packages/dom/build-module/focusable.mjs
  81    var focusable_exports = {};
  82    __export(focusable_exports, {
  83      find: () => find
  84    });
  85    function buildSelector(sequential) {
  86      return [
  87        sequential ? '[tabindex]:not([tabindex^="-"])' : "[tabindex]",
  88        "a[href]",
  89        "button:not([disabled])",
  90        'input:not([type="hidden"]):not([disabled])',
  91        "select:not([disabled])",
  92        "textarea:not([disabled])",
  93        'iframe:not([tabindex^="-"])',
  94        "object",
  95        "embed",
  96        "summary",
  97        "area[href]",
  98        "[contenteditable]:not([contenteditable=false])"
  99      ].join(",");
 100    }
 101    function isVisible(element) {
 102      return element.offsetWidth > 0 || element.offsetHeight > 0 || element.getClientRects().length > 0;
 103    }
 104    function isValidFocusableArea(element) {
 105      const map = element.closest("map[name]");
 106      if (!map) {
 107        return false;
 108      }
 109      const img = element.ownerDocument.querySelector(
 110        'img[usemap="#' + map.name + '"]'
 111      );
 112      return !!img && isVisible(img);
 113    }
 114    function find(context, { sequential = false } = {}) {
 115      const elements = context.querySelectorAll(buildSelector(sequential));
 116      return Array.from(elements).filter((element) => {
 117        if (!isVisible(element)) {
 118          return false;
 119        }
 120        if (element.closest("[inert]")) {
 121          return false;
 122        }
 123        const { nodeName } = element;
 124        if ("AREA" === nodeName) {
 125          return isValidFocusableArea(
 126            /** @type {HTMLAreaElement} */
 127            element
 128          );
 129        }
 130        return true;
 131      });
 132    }
 133  
 134    // packages/dom/build-module/tabbable.mjs
 135    var tabbable_exports = {};
 136    __export(tabbable_exports, {
 137      find: () => find2,
 138      findNext: () => findNext,
 139      findPrevious: () => findPrevious,
 140      isTabbableIndex: () => isTabbableIndex
 141    });
 142    function getTabIndex(element) {
 143      const tabIndex = element.getAttribute("tabindex");
 144      return tabIndex === null ? 0 : parseInt(tabIndex, 10);
 145    }
 146    function isTabbableIndex(element) {
 147      return getTabIndex(element) !== -1;
 148    }
 149    function createStatefulCollapseRadioGroup() {
 150      const CHOSEN_RADIO_BY_NAME = {};
 151      return function collapseRadioGroup(result, element) {
 152        const { nodeName, type, checked, name } = element;
 153        if (nodeName !== "INPUT" || type !== "radio" || !name) {
 154          return result.concat(element);
 155        }
 156        const hasChosen = CHOSEN_RADIO_BY_NAME.hasOwnProperty(name);
 157        const isChosen = checked || !hasChosen;
 158        if (!isChosen) {
 159          return result;
 160        }
 161        if (hasChosen) {
 162          const hadChosenElement = CHOSEN_RADIO_BY_NAME[name];
 163          result = result.filter((e) => e !== hadChosenElement);
 164        }
 165        CHOSEN_RADIO_BY_NAME[name] = element;
 166        return result.concat(element);
 167      };
 168    }
 169    function mapElementToObjectTabbable(element, index) {
 170      return { element, index };
 171    }
 172    function mapObjectTabbableToElement(object) {
 173      return object.element;
 174    }
 175    function compareObjectTabbables(a, b) {
 176      const aTabIndex = getTabIndex(a.element);
 177      const bTabIndex = getTabIndex(b.element);
 178      if (aTabIndex === bTabIndex) {
 179        return a.index - b.index;
 180      }
 181      return aTabIndex - bTabIndex;
 182    }
 183    function filterTabbable(focusables) {
 184      return focusables.filter(isTabbableIndex).map(mapElementToObjectTabbable).sort(compareObjectTabbables).map(mapObjectTabbableToElement).reduce(createStatefulCollapseRadioGroup(), []);
 185    }
 186    function find2(context) {
 187      return filterTabbable(find(context));
 188    }
 189    function findPrevious(element) {
 190      return filterTabbable(find(element.ownerDocument.body)).reverse().find(
 191        (focusable) => (
 192          // eslint-disable-next-line no-bitwise
 193          element.compareDocumentPosition(focusable) & element.DOCUMENT_POSITION_PRECEDING
 194        )
 195      );
 196    }
 197    function findNext(element) {
 198      return filterTabbable(find(element.ownerDocument.body)).find(
 199        (focusable) => (
 200          // eslint-disable-next-line no-bitwise
 201          element.compareDocumentPosition(focusable) & element.DOCUMENT_POSITION_FOLLOWING
 202        )
 203      );
 204    }
 205  
 206    // packages/dom/build-module/utils/assert-is-defined.mjs
 207    function assertIsDefined(val, name) {
 208      if (val === void 0 || val === null) {
 209        throw new Error(
 210          `Expected '$name}' to be defined, but received $val}`
 211        );
 212      }
 213    }
 214  
 215    // packages/dom/build-module/dom/get-rectangle-from-range.mjs
 216    function getRectangleFromRange(range) {
 217      if (!range.collapsed) {
 218        const rects2 = Array.from(range.getClientRects());
 219        if (rects2.length === 1) {
 220          return rects2[0];
 221        }
 222        const filteredRects = rects2.filter(({ width }) => width > 1);
 223        if (filteredRects.length === 0) {
 224          return range.getBoundingClientRect();
 225        }
 226        if (filteredRects.length === 1) {
 227          return filteredRects[0];
 228        }
 229        let {
 230          top: furthestTop,
 231          bottom: furthestBottom,
 232          left: furthestLeft,
 233          right: furthestRight
 234        } = filteredRects[0];
 235        for (const { top, bottom, left, right } of filteredRects) {
 236          if (top < furthestTop) {
 237            furthestTop = top;
 238          }
 239          if (bottom > furthestBottom) {
 240            furthestBottom = bottom;
 241          }
 242          if (left < furthestLeft) {
 243            furthestLeft = left;
 244          }
 245          if (right > furthestRight) {
 246            furthestRight = right;
 247          }
 248        }
 249        return new window.DOMRect(
 250          furthestLeft,
 251          furthestTop,
 252          furthestRight - furthestLeft,
 253          furthestBottom - furthestTop
 254        );
 255      }
 256      const { startContainer } = range;
 257      const { ownerDocument } = startContainer;
 258      if (startContainer.nodeName === "BR") {
 259        const { parentNode } = startContainer;
 260        assertIsDefined(parentNode, "parentNode");
 261        const index = (
 262          /** @type {Node[]} */
 263          Array.from(parentNode.childNodes).indexOf(startContainer)
 264        );
 265        assertIsDefined(ownerDocument, "ownerDocument");
 266        range = ownerDocument.createRange();
 267        range.setStart(parentNode, index);
 268        range.setEnd(parentNode, index);
 269      }
 270      const rects = range.getClientRects();
 271      if (rects.length > 1) {
 272        return null;
 273      }
 274      let rect = rects[0];
 275      if (!rect || rect.height === 0) {
 276        assertIsDefined(ownerDocument, "ownerDocument");
 277        const padNode = ownerDocument.createTextNode("\u200B");
 278        range = range.cloneRange();
 279        range.insertNode(padNode);
 280        rect = range.getClientRects()[0];
 281        assertIsDefined(padNode.parentNode, "padNode.parentNode");
 282        padNode.parentNode.removeChild(padNode);
 283      }
 284      return rect;
 285    }
 286  
 287    // packages/dom/build-module/dom/compute-caret-rect.mjs
 288    function computeCaretRect(win) {
 289      const selection = win.getSelection();
 290      assertIsDefined(selection, "selection");
 291      const range = selection.rangeCount ? selection.getRangeAt(0) : null;
 292      if (!range) {
 293        return null;
 294      }
 295      return getRectangleFromRange(range);
 296    }
 297  
 298    // packages/dom/build-module/dom/document-has-text-selection.mjs
 299    function documentHasTextSelection(doc) {
 300      assertIsDefined(doc.defaultView, "doc.defaultView");
 301      const selection = doc.defaultView.getSelection();
 302      assertIsDefined(selection, "selection");
 303      const range = selection.rangeCount ? selection.getRangeAt(0) : null;
 304      return !!range && !range.collapsed;
 305    }
 306  
 307    // packages/dom/build-module/dom/is-html-input-element.mjs
 308    function isHTMLInputElement(node) {
 309      return node?.nodeName === "INPUT";
 310    }
 311  
 312    // packages/dom/build-module/dom/is-text-field.mjs
 313    function isTextField(node) {
 314      const nonTextInputs = [
 315        "button",
 316        "checkbox",
 317        "hidden",
 318        "file",
 319        "radio",
 320        "image",
 321        "range",
 322        "reset",
 323        "submit",
 324        "number",
 325        "email",
 326        "time"
 327      ];
 328      return isHTMLInputElement(node) && node.type && !nonTextInputs.includes(node.type) || node.nodeName === "TEXTAREA" || /** @type {HTMLElement} */
 329      node.contentEditable === "true";
 330    }
 331  
 332    // packages/dom/build-module/dom/input-field-has-uncollapsed-selection.mjs
 333    function inputFieldHasUncollapsedSelection(element) {
 334      if (!isHTMLInputElement(element) && !isTextField(element)) {
 335        return false;
 336      }
 337      try {
 338        const { selectionStart, selectionEnd } = (
 339          /** @type {HTMLInputElement | HTMLTextAreaElement} */
 340          element
 341        );
 342        return (
 343          // `null` means the input type doesn't implement selection, thus we
 344          // cannot determine whether the selection is collapsed, so we
 345          // default to true.
 346          selectionStart === null || // when not null, compare the two points
 347          selectionStart !== selectionEnd
 348        );
 349      } catch {
 350        return true;
 351      }
 352    }
 353  
 354    // packages/dom/build-module/dom/document-has-uncollapsed-selection.mjs
 355    function documentHasUncollapsedSelection(doc) {
 356      return documentHasTextSelection(doc) || !!doc.activeElement && inputFieldHasUncollapsedSelection(doc.activeElement);
 357    }
 358  
 359    // packages/dom/build-module/dom/document-has-selection.mjs
 360    function documentHasSelection(doc) {
 361      return !!doc.activeElement && (isHTMLInputElement(doc.activeElement) || isTextField(doc.activeElement) || documentHasTextSelection(doc));
 362    }
 363  
 364    // packages/dom/build-module/dom/get-computed-style.mjs
 365    function getComputedStyle(element) {
 366      assertIsDefined(
 367        element.ownerDocument.defaultView,
 368        "element.ownerDocument.defaultView"
 369      );
 370      return element.ownerDocument.defaultView.getComputedStyle(element);
 371    }
 372  
 373    // packages/dom/build-module/dom/get-scroll-container.mjs
 374    function getScrollContainer(node, direction = "vertical") {
 375      if (!node) {
 376        return void 0;
 377      }
 378      if (direction === "vertical" || direction === "all") {
 379        if (node.scrollHeight > node.clientHeight) {
 380          const { overflowY } = getComputedStyle(node);
 381          if (/(auto|scroll)/.test(overflowY)) {
 382            return node;
 383          }
 384        }
 385      }
 386      if (direction === "horizontal" || direction === "all") {
 387        if (node.scrollWidth > node.clientWidth) {
 388          const { overflowX } = getComputedStyle(node);
 389          if (/(auto|scroll)/.test(overflowX)) {
 390            return node;
 391          }
 392        }
 393      }
 394      if (node.ownerDocument === node.parentNode) {
 395        return node;
 396      }
 397      return getScrollContainer(
 398        /** @type {Element} */
 399        node.parentNode,
 400        direction
 401      );
 402    }
 403  
 404    // packages/dom/build-module/dom/get-offset-parent.mjs
 405    function getOffsetParent(node) {
 406      let closestElement;
 407      while (closestElement = /** @type {Node} */
 408      node.parentNode) {
 409        if (closestElement.nodeType === closestElement.ELEMENT_NODE) {
 410          break;
 411        }
 412      }
 413      if (!closestElement) {
 414        return null;
 415      }
 416      if (getComputedStyle(
 417        /** @type {Element} */
 418        closestElement
 419      ).position !== "static") {
 420        return closestElement;
 421      }
 422      return (
 423        /** @type {Node & { offsetParent: Node }} */
 424        closestElement.offsetParent
 425      );
 426    }
 427  
 428    // packages/dom/build-module/dom/is-input-or-text-area.mjs
 429    function isInputOrTextArea(element) {
 430      return element.tagName === "INPUT" || element.tagName === "TEXTAREA";
 431    }
 432  
 433    // packages/dom/build-module/dom/is-entirely-selected.mjs
 434    var ZWNBSP = "\uFEFF";
 435    function isEntirelySelected(element) {
 436      if (isInputOrTextArea(element)) {
 437        return element.selectionStart === 0 && element.value.length === element.selectionEnd;
 438      }
 439      if (!element.isContentEditable) {
 440        return true;
 441      }
 442      const text = element.textContent || "";
 443      if (text === "" || text === ZWNBSP) {
 444        return true;
 445      }
 446      const { ownerDocument } = element;
 447      const { defaultView } = ownerDocument;
 448      assertIsDefined(defaultView, "defaultView");
 449      const selection = defaultView.getSelection();
 450      assertIsDefined(selection, "selection");
 451      const range = selection.rangeCount ? selection.getRangeAt(0) : null;
 452      if (!range) {
 453        return true;
 454      }
 455      const { startContainer, endContainer, startOffset, endOffset } = range;
 456      if (startContainer === element && endContainer === element && startOffset === 0 && endOffset === element.childNodes.length) {
 457        return true;
 458      }
 459      const lastChild = element.lastChild;
 460      assertIsDefined(lastChild, "lastChild");
 461      const endContainerContentLength = endContainer.nodeType === endContainer.TEXT_NODE ? (
 462        /** @type {Text} */
 463        endContainer.data.length
 464      ) : endContainer.childNodes.length;
 465      return isDeepChild(startContainer, element, "firstChild") && isDeepChild(endContainer, element, "lastChild") && startOffset === 0 && endOffset === endContainerContentLength;
 466    }
 467    function isDeepChild(query, container, propName) {
 468      let candidate = container;
 469      do {
 470        if (query === candidate) {
 471          return true;
 472        }
 473        candidate = candidate[propName];
 474        while (candidate && candidate.nodeType === candidate.TEXT_NODE && candidate.nodeValue === "") {
 475          candidate = candidate[propName === "lastChild" ? "previousSibling" : "nextSibling"];
 476        }
 477      } while (candidate);
 478      return false;
 479    }
 480  
 481    // packages/dom/build-module/dom/is-form-element.mjs
 482    function isFormElement(element) {
 483      if (!element) {
 484        return false;
 485      }
 486      const { tagName } = element;
 487      const checkForInputTextarea = isInputOrTextArea(element);
 488      return checkForInputTextarea || tagName === "BUTTON" || tagName === "SELECT";
 489    }
 490  
 491    // packages/dom/build-module/dom/is-rtl.mjs
 492    function isRTL(element) {
 493      return getComputedStyle(element).direction === "rtl";
 494    }
 495  
 496    // packages/dom/build-module/dom/get-range-height.mjs
 497    function getRangeHeight(range) {
 498      const rects = Array.from(range.getClientRects());
 499      if (!rects.length) {
 500        return;
 501      }
 502      const highestTop = Math.min(...rects.map(({ top }) => top));
 503      const lowestBottom = Math.max(...rects.map(({ bottom }) => bottom));
 504      return lowestBottom - highestTop;
 505    }
 506  
 507    // packages/dom/build-module/dom/is-selection-forward.mjs
 508    function isSelectionForward(selection) {
 509      const { anchorNode, focusNode, anchorOffset, focusOffset } = selection;
 510      assertIsDefined(anchorNode, "anchorNode");
 511      assertIsDefined(focusNode, "focusNode");
 512      const position = anchorNode.compareDocumentPosition(focusNode);
 513      if (position & anchorNode.DOCUMENT_POSITION_PRECEDING) {
 514        return false;
 515      }
 516      if (position & anchorNode.DOCUMENT_POSITION_FOLLOWING) {
 517        return true;
 518      }
 519      if (position === 0) {
 520        return anchorOffset <= focusOffset;
 521      }
 522      return true;
 523    }
 524  
 525    // packages/dom/build-module/dom/caret-range-from-point.mjs
 526    function caretRangeFromPoint(doc, x, y) {
 527      if (doc.caretPositionFromPoint) {
 528        const point = doc.caretPositionFromPoint(x, y);
 529        if (!point) {
 530          return null;
 531        }
 532        const range = doc.createRange();
 533        range.setStart(point.offsetNode, point.offset);
 534        range.collapse(true);
 535        return range;
 536      }
 537      if (doc.caretRangeFromPoint) {
 538        return doc.caretRangeFromPoint(x, y);
 539      }
 540      return null;
 541    }
 542  
 543    // packages/dom/build-module/dom/hidden-caret-range-from-point.mjs
 544    function hiddenCaretRangeFromPoint(doc, x, y, container) {
 545      const originalZIndex = container.style.zIndex;
 546      const originalPosition = container.style.position;
 547      const originalBorderRadius = container.style.borderRadius;
 548      const { position = "static" } = getComputedStyle(container);
 549      if (position === "static") {
 550        container.style.position = "relative";
 551      }
 552      container.style.zIndex = "10000";
 553      container.style.borderRadius = "0";
 554      const range = caretRangeFromPoint(doc, x, y);
 555      container.style.zIndex = originalZIndex;
 556      container.style.position = originalPosition;
 557      container.style.borderRadius = originalBorderRadius;
 558      return range;
 559    }
 560  
 561    // packages/dom/build-module/dom/scroll-if-no-range.mjs
 562    function scrollIfNoRange(container, alignToTop, callback) {
 563      let range = callback();
 564      if (!range || !range.startContainer || !container.contains(range.startContainer)) {
 565        container.scrollIntoView(alignToTop);
 566        range = callback();
 567        if (!range || !range.startContainer || !container.contains(range.startContainer)) {
 568          return null;
 569        }
 570      }
 571      return range;
 572    }
 573  
 574    // packages/dom/build-module/dom/is-edge.mjs
 575    function isEdge(container, isReverse, onlyVertical = false) {
 576      if (isInputOrTextArea(container) && typeof container.selectionStart === "number") {
 577        if (container.selectionStart !== container.selectionEnd) {
 578          return false;
 579        }
 580        if (isReverse) {
 581          return container.selectionStart === 0;
 582        }
 583        return container.value.length === container.selectionStart;
 584      }
 585      if (!container.isContentEditable) {
 586        return true;
 587      }
 588      const { ownerDocument } = container;
 589      const { defaultView } = ownerDocument;
 590      assertIsDefined(defaultView, "defaultView");
 591      const selection = defaultView.getSelection();
 592      if (!selection || !selection.rangeCount) {
 593        return false;
 594      }
 595      const range = selection.getRangeAt(0);
 596      const collapsedRange = range.cloneRange();
 597      const isForward = isSelectionForward(selection);
 598      const isCollapsed = selection.isCollapsed;
 599      if (!isCollapsed) {
 600        collapsedRange.collapse(!isForward);
 601      }
 602      const collapsedRangeRect = getRectangleFromRange(collapsedRange);
 603      const rangeRect = getRectangleFromRange(range);
 604      if (!collapsedRangeRect || !rangeRect) {
 605        return false;
 606      }
 607      const rangeHeight = getRangeHeight(range);
 608      if (!isCollapsed && rangeHeight && rangeHeight > collapsedRangeRect.height && isForward === isReverse) {
 609        return false;
 610      }
 611      const isReverseDir = isRTL(container) ? !isReverse : isReverse;
 612      const containerRect = container.getBoundingClientRect();
 613      const x = isReverseDir ? containerRect.left + 1 : containerRect.right - 1;
 614      const y = isReverse ? containerRect.top + 1 : containerRect.bottom - 1;
 615      const isFarFromVerticalEdge = (y < 0 || y > defaultView.innerHeight) && rangeRect.top >= 0 && rangeRect.bottom <= defaultView.innerHeight;
 616      const isFarFromHorizontalEdge = (x < 0 || x > defaultView.innerWidth) && rangeRect.left >= 0 && rangeRect.right <= defaultView.innerWidth;
 617      if (isFarFromVerticalEdge || !onlyVertical && isFarFromHorizontalEdge) {
 618        return false;
 619      }
 620      const testRange = scrollIfNoRange(
 621        container,
 622        isReverse,
 623        () => hiddenCaretRangeFromPoint(ownerDocument, x, y, container)
 624      );
 625      if (!testRange) {
 626        return false;
 627      }
 628      const testRect = getRectangleFromRange(testRange);
 629      if (!testRect) {
 630        return false;
 631      }
 632      const verticalSide = isReverse ? "top" : "bottom";
 633      const horizontalSide = isReverseDir ? "left" : "right";
 634      const verticalDiff = testRect[verticalSide] - rangeRect[verticalSide];
 635      const horizontalDiff = testRect[horizontalSide] - collapsedRangeRect[horizontalSide];
 636      const hasVerticalDiff = Math.abs(verticalDiff) <= 1;
 637      const hasHorizontalDiff = Math.abs(horizontalDiff) <= 1;
 638      return onlyVertical ? hasVerticalDiff : hasVerticalDiff && hasHorizontalDiff;
 639    }
 640  
 641    // packages/dom/build-module/dom/is-horizontal-edge.mjs
 642    function isHorizontalEdge(container, isReverse) {
 643      return isEdge(container, isReverse);
 644    }
 645  
 646    // packages/dom/build-module/dom/is-number-input.mjs
 647    var import_deprecated = __toESM(require_deprecated(), 1);
 648    function isNumberInput(node) {
 649      (0, import_deprecated.default)("wp.dom.isNumberInput", {
 650        since: "6.1",
 651        version: "6.5"
 652      });
 653      return isHTMLInputElement(node) && node.type === "number" && !isNaN(node.valueAsNumber);
 654    }
 655  
 656    // packages/dom/build-module/dom/is-vertical-edge.mjs
 657    function isVerticalEdge(container, isReverse) {
 658      return isEdge(container, isReverse, true);
 659    }
 660  
 661    // packages/dom/build-module/dom/place-caret-at-edge.mjs
 662    function getRange(container, isReverse, x) {
 663      const { ownerDocument } = container;
 664      const isReverseDir = isRTL(container) ? !isReverse : isReverse;
 665      const containerRect = container.getBoundingClientRect();
 666      if (x === void 0) {
 667        x = isReverse ? containerRect.right - 1 : containerRect.left + 1;
 668      } else if (x <= containerRect.left) {
 669        x = containerRect.left + 1;
 670      } else if (x >= containerRect.right) {
 671        x = containerRect.right - 1;
 672      }
 673      const y = isReverseDir ? containerRect.bottom - 1 : containerRect.top + 1;
 674      return hiddenCaretRangeFromPoint(ownerDocument, x, y, container);
 675    }
 676    function placeCaretAtEdge(container, isReverse, x) {
 677      if (!container) {
 678        return;
 679      }
 680      container.focus();
 681      if (isInputOrTextArea(container)) {
 682        if (typeof container.selectionStart !== "number") {
 683          return;
 684        }
 685        if (isReverse) {
 686          container.selectionStart = container.value.length;
 687          container.selectionEnd = container.value.length;
 688        } else {
 689          container.selectionStart = 0;
 690          container.selectionEnd = 0;
 691        }
 692        return;
 693      }
 694      if (container.contentEditable !== "true") {
 695        return;
 696      }
 697      const range = scrollIfNoRange(
 698        container,
 699        isReverse,
 700        () => getRange(container, isReverse, x)
 701      );
 702      if (!range) {
 703        return;
 704      }
 705      const { ownerDocument } = container;
 706      const { defaultView } = ownerDocument;
 707      assertIsDefined(defaultView, "defaultView");
 708      const selection = defaultView.getSelection();
 709      assertIsDefined(selection, "selection");
 710      selection.removeAllRanges();
 711      selection.addRange(range);
 712    }
 713  
 714    // packages/dom/build-module/dom/place-caret-at-horizontal-edge.mjs
 715    function placeCaretAtHorizontalEdge(container, isReverse) {
 716      return placeCaretAtEdge(container, isReverse, void 0);
 717    }
 718  
 719    // packages/dom/build-module/dom/place-caret-at-vertical-edge.mjs
 720    function placeCaretAtVerticalEdge(container, isReverse, rect) {
 721      return placeCaretAtEdge(container, isReverse, rect?.left);
 722    }
 723  
 724    // packages/dom/build-module/dom/insert-after.mjs
 725    function insertAfter(newNode, referenceNode) {
 726      assertIsDefined(referenceNode.parentNode, "referenceNode.parentNode");
 727      referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
 728    }
 729  
 730    // packages/dom/build-module/dom/remove.mjs
 731    function remove(node) {
 732      assertIsDefined(node.parentNode, "node.parentNode");
 733      node.parentNode.removeChild(node);
 734    }
 735  
 736    // packages/dom/build-module/dom/replace.mjs
 737    function replace(processedNode, newNode) {
 738      assertIsDefined(processedNode.parentNode, "processedNode.parentNode");
 739      insertAfter(newNode, processedNode.parentNode);
 740      remove(processedNode);
 741    }
 742  
 743    // packages/dom/build-module/dom/unwrap.mjs
 744    function unwrap(node) {
 745      const parent = node.parentNode;
 746      assertIsDefined(parent, "node.parentNode");
 747      while (node.firstChild) {
 748        parent.insertBefore(node.firstChild, node);
 749      }
 750      parent.removeChild(node);
 751    }
 752  
 753    // packages/dom/build-module/dom/replace-tag.mjs
 754    function replaceTag(node, tagName) {
 755      const newNode = node.ownerDocument.createElement(tagName);
 756      while (node.firstChild) {
 757        newNode.appendChild(node.firstChild);
 758      }
 759      assertIsDefined(node.parentNode, "node.parentNode");
 760      node.parentNode.replaceChild(newNode, node);
 761      return newNode;
 762    }
 763  
 764    // packages/dom/build-module/dom/wrap.mjs
 765    function wrap(newNode, referenceNode) {
 766      assertIsDefined(referenceNode.parentNode, "referenceNode.parentNode");
 767      referenceNode.parentNode.insertBefore(newNode, referenceNode);
 768      newNode.appendChild(referenceNode);
 769    }
 770  
 771    // packages/dom/build-module/dom/safe-html.mjs
 772    function safeHTML(html) {
 773      const { body } = document.implementation.createHTMLDocument("");
 774      body.innerHTML = html;
 775      const elements = body.getElementsByTagName("*");
 776      let elementIndex = elements.length;
 777      while (elementIndex--) {
 778        const element = elements[elementIndex];
 779        if (element.tagName === "SCRIPT") {
 780          remove(element);
 781        } else {
 782          let attributeIndex = element.attributes.length;
 783          while (attributeIndex--) {
 784            const { name: key } = element.attributes[attributeIndex];
 785            if (key.startsWith("on")) {
 786              element.removeAttribute(key);
 787            }
 788          }
 789        }
 790      }
 791      return body.innerHTML;
 792    }
 793  
 794    // packages/dom/build-module/dom/strip-html.mjs
 795    function stripHTML(html) {
 796      html = safeHTML(html);
 797      const doc = document.implementation.createHTMLDocument("");
 798      doc.body.innerHTML = html;
 799      return doc.body.textContent || "";
 800    }
 801  
 802    // packages/dom/build-module/dom/is-empty.mjs
 803    function isEmpty(element) {
 804      switch (element.nodeType) {
 805        case element.TEXT_NODE:
 806          return /^[ \f\n\r\t\v\u00a0]*$/.test(element.nodeValue || "");
 807        case element.ELEMENT_NODE:
 808          if (element.hasAttributes()) {
 809            return false;
 810          } else if (!element.hasChildNodes()) {
 811            return true;
 812          }
 813          return (
 814            /** @type {Element[]} */
 815            Array.from(element.childNodes).every(isEmpty)
 816          );
 817        default:
 818          return true;
 819      }
 820    }
 821  
 822    // packages/dom/build-module/phrasing-content.mjs
 823    var textContentSchema = {
 824      strong: {},
 825      em: {},
 826      s: {},
 827      del: {},
 828      ins: {},
 829      a: { attributes: ["href", "target", "rel", "id"] },
 830      code: {},
 831      abbr: { attributes: ["title"] },
 832      sub: {},
 833      sup: {},
 834      br: {},
 835      small: {},
 836      // To do: fix blockquote.
 837      // cite: {},
 838      q: { attributes: ["cite"] },
 839      dfn: { attributes: ["title"] },
 840      data: { attributes: ["value"] },
 841      time: { attributes: ["datetime"] },
 842      var: {},
 843      samp: {},
 844      kbd: {},
 845      i: {},
 846      b: {},
 847      u: {},
 848      mark: {},
 849      ruby: {},
 850      rt: {},
 851      rp: {},
 852      bdi: { attributes: ["dir"] },
 853      bdo: { attributes: ["dir"] },
 854      wbr: {},
 855      "#text": {}
 856    };
 857    var embeddedContentSchema = {
 858      audio: {
 859        attributes: [
 860          "src",
 861          "preload",
 862          "autoplay",
 863          "mediagroup",
 864          "loop",
 865          "muted"
 866        ]
 867      },
 868      canvas: { attributes: ["width", "height"] },
 869      embed: { attributes: ["src", "type", "width", "height"] },
 870      img: {
 871        attributes: [
 872          "alt",
 873          "src",
 874          "srcset",
 875          "usemap",
 876          "ismap",
 877          "width",
 878          "height"
 879        ]
 880      },
 881      object: {
 882        attributes: [
 883          "data",
 884          "type",
 885          "name",
 886          "usemap",
 887          "form",
 888          "width",
 889          "height"
 890        ]
 891      },
 892      video: {
 893        attributes: [
 894          "src",
 895          "poster",
 896          "preload",
 897          "playsinline",
 898          "autoplay",
 899          "mediagroup",
 900          "loop",
 901          "muted",
 902          "controls",
 903          "width",
 904          "height"
 905        ]
 906      },
 907      math: {
 908        attributes: ["display", "xmlns"],
 909        children: "*"
 910      }
 911    };
 912    var excludedElements = ["#text", "br", "wbr"];
 913    Object.keys(textContentSchema).filter((element) => !excludedElements.includes(element)).forEach((tag) => {
 914      const { [tag]: removedTag, ...restSchema } = textContentSchema;
 915      textContentSchema[tag].children = {
 916        ...restSchema,
 917        img: embeddedContentSchema.img
 918      };
 919    });
 920    var phrasingContentSchema = {
 921      ...textContentSchema,
 922      ...embeddedContentSchema
 923    };
 924    function getPhrasingContentSchema(context) {
 925      if (context !== "paste") {
 926        return phrasingContentSchema;
 927      }
 928      const {
 929        u,
 930        // Used to mark misspelling. Shouldn't be pasted.
 931        abbr,
 932        // Invisible.
 933        data,
 934        // Invisible.
 935        time,
 936        // Invisible.
 937        wbr,
 938        // Invisible.
 939        bdi,
 940        // Invisible.
 941        bdo,
 942        // Invisible.
 943        ...remainingContentSchema
 944      } = {
 945        ...phrasingContentSchema,
 946        // We shouldn't paste potentially sensitive information which is not
 947        // visible to the user when pasted, so strip the attributes.
 948        ins: { children: phrasingContentSchema.ins.children },
 949        del: { children: phrasingContentSchema.del.children }
 950      };
 951      return remainingContentSchema;
 952    }
 953    function isPhrasingContent(node) {
 954      const tag = node.nodeName.toLowerCase();
 955      return getPhrasingContentSchema().hasOwnProperty(tag) || tag === "span";
 956    }
 957    function isTextContent(node) {
 958      const tag = node.nodeName.toLowerCase();
 959      return textContentSchema.hasOwnProperty(tag) || tag === "span";
 960    }
 961  
 962    // packages/dom/build-module/dom/is-element.mjs
 963    function isElement(node) {
 964      return !!node && node.nodeType === node.ELEMENT_NODE;
 965    }
 966  
 967    // packages/dom/build-module/dom/clean-node-list.mjs
 968    var noop = () => {
 969    };
 970    function cleanNodeList(nodeList, doc, schema, inline) {
 971      Array.from(nodeList).forEach(
 972        (node) => {
 973          const tag = node.nodeName.toLowerCase();
 974          if (schema.hasOwnProperty(tag) && (!schema[tag].isMatch || schema[tag].isMatch?.(node))) {
 975            if (isElement(node)) {
 976              const {
 977                attributes = [],
 978                classes = [],
 979                children,
 980                require: require2 = [],
 981                allowEmpty
 982              } = schema[tag];
 983              if (children && !allowEmpty && isEmpty(node)) {
 984                remove(node);
 985                return;
 986              }
 987              if (node.hasAttributes()) {
 988                Array.from(node.attributes).forEach(({ name }) => {
 989                  if (name !== "class" && !attributes.includes(name)) {
 990                    node.removeAttribute(name);
 991                  }
 992                });
 993                if (node.classList && node.classList.length) {
 994                  const mattchers = classes.map((item) => {
 995                    if (item === "*") {
 996                      return () => true;
 997                    } else if (typeof item === "string") {
 998                      return (className) => className === item;
 999                    } else if (item instanceof RegExp) {
1000                      return (className) => item.test(className);
1001                    }
1002                    return noop;
1003                  });
1004                  Array.from(node.classList).forEach((name) => {
1005                    if (!mattchers.some(
1006                      (isMatch) => isMatch(name)
1007                    )) {
1008                      node.classList.remove(name);
1009                    }
1010                  });
1011                  if (!node.classList.length) {
1012                    node.removeAttribute("class");
1013                  }
1014                }
1015              }
1016              if (node.hasChildNodes()) {
1017                if (children === "*") {
1018                  return;
1019                }
1020                if (children) {
1021                  if (require2.length && !node.querySelector(require2.join(","))) {
1022                    cleanNodeList(
1023                      node.childNodes,
1024                      doc,
1025                      schema,
1026                      inline
1027                    );
1028                    unwrap(node);
1029                  } else if (node.parentNode && node.parentNode.nodeName === "BODY" && isPhrasingContent(node)) {
1030                    cleanNodeList(
1031                      node.childNodes,
1032                      doc,
1033                      schema,
1034                      inline
1035                    );
1036                    if (Array.from(node.childNodes).some(
1037                      (child) => !isPhrasingContent(child)
1038                    )) {
1039                      unwrap(node);
1040                    }
1041                  } else {
1042                    cleanNodeList(
1043                      node.childNodes,
1044                      doc,
1045                      children,
1046                      inline
1047                    );
1048                  }
1049                } else {
1050                  while (node.firstChild) {
1051                    remove(node.firstChild);
1052                  }
1053                }
1054              }
1055            }
1056          } else {
1057            cleanNodeList(node.childNodes, doc, schema, inline);
1058            if (inline && !isPhrasingContent(node) && node.nextElementSibling) {
1059              insertAfter(doc.createElement("br"), node);
1060            }
1061            unwrap(node);
1062          }
1063        }
1064      );
1065    }
1066  
1067    // packages/dom/build-module/dom/remove-invalid-html.mjs
1068    function removeInvalidHTML(HTML, schema, inline) {
1069      const doc = document.implementation.createHTMLDocument("");
1070      doc.body.innerHTML = HTML;
1071      cleanNodeList(doc.body.childNodes, doc, schema, inline);
1072      return doc.body.innerHTML;
1073    }
1074  
1075    // packages/dom/build-module/data-transfer.mjs
1076    function getFilesFromDataTransfer(dataTransfer) {
1077      const files = Array.from(dataTransfer.files);
1078      Array.from(dataTransfer.items).forEach((item) => {
1079        const file = item.getAsFile();
1080        if (file && !files.find(
1081          ({ name, type, size }) => name === file.name && type === file.type && size === file.size
1082        )) {
1083          files.push(file);
1084        }
1085      });
1086      return files;
1087    }
1088  
1089    // packages/dom/build-module/index.mjs
1090    var focus = { focusable: focusable_exports, tabbable: tabbable_exports };
1091    return __toCommonJS(index_exports);
1092  })();
1093  (window.wp ||= {}).dom = wp.dom;
1094  })();