@out-of-order/cli 0.1.0

package/dist/inject.global.js

@@ -0,0 +1,1891 @@
+"use strict";
+(() => {
+  // ../../node_modules/.pnpm/tabbable@6.5.0/node_modules/tabbable/dist/index.esm.js
+  var candidateSelectors = ["input:not([inert]):not([inert] *)", "select:not([inert]):not([inert] *)", "textarea:not([inert]):not([inert] *)", "a[href]:not([inert]):not([inert] *)", "area[href]:not([inert]):not([inert] *)", "button:not([inert]):not([inert] *)", "[tabindex]:not(slot):not([inert]):not([inert] *)", "audio[controls]:not([inert]):not([inert] *)", "video[controls]:not([inert]):not([inert] *)", '[contenteditable]:not([contenteditable="false"]):not([inert]):not([inert] *)', "details>summary:first-of-type:not([inert]):not([inert] *)", "details:not([inert]):not([inert] *)"];
+  var candidateSelector = /* @__PURE__ */ candidateSelectors.join(",");
+  var NoElement = typeof Element === "undefined";
+  var matches = NoElement ? function() {
+  } : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+  var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
+    var _element$getRootNode;
+    return element === null || element === void 0 ? void 0 : (_element$getRootNode = element.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element);
+  } : function(element) {
+    return element === null || element === void 0 ? void 0 : element.ownerDocument;
+  };
+  var _isInert = function isInert(node, lookUp) {
+    var _node$getAttribute;
+    if (lookUp === void 0) {
+      lookUp = true;
+    }
+    var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
+    var inert = inertAtt === "" || inertAtt === "true";
+    var result = inert || lookUp && node && // closest does not exist on shadow roots, so we fall back to a manual
+    // lookup upward, in case it is not defined.
+    (typeof node.closest === "function" ? node.closest("[inert]") : _isInert(node.parentNode));
+    return result;
+  };
+  var isContentEditable = function isContentEditable2(node) {
+    var _node$getAttribute2;
+    var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
+    return attValue === "" || attValue === "true";
+  };
+  var getCandidates = function getCandidates2(el, includeContainer, filter) {
+    if (_isInert(el)) {
+      return [];
+    }
+    var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
+    if (includeContainer && matches.call(el, candidateSelector)) {
+      candidates.unshift(el);
+    }
+    candidates = candidates.filter(filter);
+    return candidates;
+  };
+  var _getCandidatesIteratively = function getCandidatesIteratively(elements, includeContainer, options) {
+    var candidates = [];
+    var elementsToCheck = Array.from(elements);
+    while (elementsToCheck.length) {
+      var element = elementsToCheck.shift();
+      if (_isInert(element, false)) {
+        continue;
+      }
+      if (element.tagName === "SLOT") {
+        var assigned = element.assignedElements();
+        var content = assigned.length ? assigned : element.children;
+        var nestedCandidates = _getCandidatesIteratively(content, true, options);
+        if (options.flatten) {
+          candidates.push.apply(candidates, nestedCandidates);
+        } else {
+          candidates.push({
+            scopeParent: element,
+            candidates: nestedCandidates
+          });
+        }
+      } else {
+        var validCandidate = matches.call(element, candidateSelector);
+        if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {
+          candidates.push(element);
+        }
+        var shadowRoot = element.shadowRoot || // check for an undisclosed shadow
+        typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
+        var validShadowRoot = !_isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element));
+        if (shadowRoot && validShadowRoot) {
+          var _nestedCandidates = _getCandidatesIteratively(shadowRoot === true ? element.children : shadowRoot.children, true, options);
+          if (options.flatten) {
+            candidates.push.apply(candidates, _nestedCandidates);
+          } else {
+            candidates.push({
+              scopeParent: element,
+              candidates: _nestedCandidates
+            });
+          }
+        } else {
+          elementsToCheck.unshift.apply(elementsToCheck, element.children);
+        }
+      }
+    }
+    return candidates;
+  };
+  var hasTabIndex = function hasTabIndex2(node) {
+    return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
+  };
+  var getTabIndex = function getTabIndex2(node) {
+    if (!node) {
+      throw new Error("No node provided");
+    }
+    if (node.tabIndex < 0) {
+      if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable(node)) && !hasTabIndex(node)) {
+        return 0;
+      }
+    }
+    return node.tabIndex;
+  };
+  var getSortOrderTabIndex = function getSortOrderTabIndex2(node, isScope) {
+    var tabIndex = getTabIndex(node);
+    if (tabIndex < 0 && isScope && !hasTabIndex(node)) {
+      return 0;
+    }
+    return tabIndex;
+  };
+  var sortOrderedTabbables = function sortOrderedTabbables2(a, b) {
+    return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
+  };
+  var isInput = function isInput2(node) {
+    return node.tagName === "INPUT";
+  };
+  var isHiddenInput = function isHiddenInput2(node) {
+    return isInput(node) && node.type === "hidden";
+  };
+  var isDetailsWithSummary = function isDetailsWithSummary2(node) {
+    var r = node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
+      return child.tagName === "SUMMARY";
+    });
+    return r;
+  };
+  var getCheckedRadio = function getCheckedRadio2(nodes, form) {
+    for (var i = 0; i < nodes.length; i++) {
+      if (nodes[i].checked && nodes[i].form === form) {
+        return nodes[i];
+      }
+    }
+  };
+  var isTabbableRadio = function isTabbableRadio2(node) {
+    if (!node.name) {
+      return true;
+    }
+    var radioScope = node.form || getRootNode(node);
+    var queryRadios = function queryRadios2(name) {
+      return radioScope.querySelectorAll('input[type="radio"][name="' + name + '"]');
+    };
+    var radioSet;
+    if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") {
+      radioSet = queryRadios(window.CSS.escape(node.name));
+    } else {
+      try {
+        radioSet = queryRadios(node.name);
+      } catch (err) {
+        console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
+        return false;
+      }
+    }
+    var checked = getCheckedRadio(radioSet, node.form);
+    return !checked || checked === node;
+  };
+  var isRadio = function isRadio2(node) {
+    return isInput(node) && node.type === "radio";
+  };
+  var isNonTabbableRadio = function isNonTabbableRadio2(node) {
+    return isRadio(node) && !isTabbableRadio(node);
+  };
+  var isNodeAttached = function isNodeAttached2(node) {
+    var _nodeRoot;
+    var nodeRoot = node && getRootNode(node);
+    var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
+    var attached = false;
+    if (nodeRoot && nodeRoot !== node) {
+      var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
+      attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
+      while (!attached && nodeRootHost) {
+        var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
+        nodeRoot = getRootNode(nodeRootHost);
+        nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
+        attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
+      }
+    }
+    return attached;
+  };
+  var isZeroArea = function isZeroArea2(node) {
+    var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
+    return width === 0 && height === 0;
+  };
+  var isHidden = function isHidden2(node, _ref) {
+    var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
+    if (displayCheck === "full-native") {
+      if ("checkVisibility" in node) {
+        var visible = node.checkVisibility({
+          // Checking opacity might be desirable for some use cases, but natively,
+          // opacity zero elements _are_ focusable and tabbable.
+          checkOpacity: false,
+          opacityProperty: false,
+          contentVisibilityAuto: true,
+          visibilityProperty: true,
+          // This is an alias for `visibilityProperty`. Contemporary browsers
+          // support both. However, this alias has wider browser support (Chrome
+          // >= 105 and Firefox >= 106, vs. Chrome >= 121 and Firefox >= 122), so
+          // we include it anyway.
+          checkVisibilityCSS: true
+        });
+        return !visible;
+      }
+    }
+    var _getComputedStyle = getComputedStyle(node), visibility = _getComputedStyle.visibility;
+    if (visibility === "hidden" || visibility === "collapse") {
+      return true;
+    }
+    var isDirectSummary = matches.call(node, "details>summary:first-of-type");
+    var nodeUnderDetails = isDirectSummary ? node.parentElement : node;
+    if (matches.call(nodeUnderDetails, "details:not([open]) *")) {
+      return true;
+    }
+    if (!displayCheck || displayCheck === "full" || // full-native can run this branch when it falls through in case
+    // Element#checkVisibility is unsupported
+    displayCheck === "full-native" || displayCheck === "legacy-full") {
+      if (typeof getShadowRoot === "function") {
+        var originalNode = node;
+        while (node) {
+          var parentElement = node.parentElement;
+          var rootNode = getRootNode(node);
+          if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) {
+            return isZeroArea(node);
+          } else if (node.assignedSlot) {
+            node = node.assignedSlot;
+          } else if (!parentElement && rootNode !== node.ownerDocument) {
+            node = rootNode.host;
+          } else {
+            node = parentElement;
+          }
+        }
+        node = originalNode;
+      }
+      if (isNodeAttached(node)) {
+        return !node.getClientRects().length;
+      }
+      if (displayCheck !== "legacy-full") {
+        return true;
+      }
+    } else if (displayCheck === "non-zero-area") {
+      return isZeroArea(node);
+    }
+    return false;
+  };
+  var isDisabledFromFieldset = function isDisabledFromFieldset2(node) {
+    if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
+      var parentNode = node.parentElement;
+      while (parentNode) {
+        if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
+          for (var i = 0; i < parentNode.children.length; i++) {
+            var child = parentNode.children.item(i);
+            if (child.tagName === "LEGEND") {
+              return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
+            }
+          }
+          return true;
+        }
+        parentNode = parentNode.parentElement;
+      }
+    }
+    return false;
+  };
+  var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable2(options, node) {
+    if (node.disabled || isHiddenInput(node) || isHidden(node, options) || // For a details element with a summary, the summary element gets the focus
+    isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
+      return false;
+    }
+    return true;
+  };
+  var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable2(options, node) {
+    if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {
+      return false;
+    }
+    return true;
+  };
+  var isShadowRootTabbable = function isShadowRootTabbable2(shadowHostNode) {
+    var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
+    if (isNaN(tabIndex) || tabIndex >= 0) {
+      return true;
+    }
+    return false;
+  };
+  var _sortByOrder = function sortByOrder(candidates) {
+    var regularTabbables = [];
+    var orderedTabbables = [];
+    candidates.forEach(function(item, i) {
+      var isScope = !!item.scopeParent;
+      var element = isScope ? item.scopeParent : item;
+      var candidateTabindex = getSortOrderTabIndex(element, isScope);
+      var elements = isScope ? _sortByOrder(item.candidates) : element;
+      if (candidateTabindex === 0) {
+        isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
+      } else {
+        orderedTabbables.push({
+          documentOrder: i,
+          tabIndex: candidateTabindex,
+          item,
+          isScope,
+          content: elements
+        });
+      }
+    });
+    return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
+      sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
+      return acc;
+    }, []).concat(regularTabbables);
+  };
+  var tabbable = function tabbable2(container, options) {
+    options = options || {};
+    var candidates;
+    if (options.getShadowRoot) {
+      candidates = _getCandidatesIteratively([container], options.includeContainer, {
+        filter: isNodeMatchingSelectorTabbable.bind(null, options),
+        flatten: false,
+        getShadowRoot: options.getShadowRoot,
+        shadowRootFilter: isShadowRootTabbable
+      });
+    } else {
+      candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
+    }
+    return _sortByOrder(candidates);
+  };
+  var focusableCandidateSelector = /* @__PURE__ */ candidateSelectors.concat("iframe:not([inert]):not([inert] *)").join(",");
+  var isFocusable = function isFocusable2(node, options) {
+    options = options || {};
+    if (!node) {
+      throw new Error("No node provided");
+    }
+    if (matches.call(node, focusableCandidateSelector) === false) {
+      return false;
+    }
+    return isNodeMatchingSelectorFocusable(options, node);
+  };
+
+  // ../core/src/overlay-classes.ts
+  var OVERLAY_CLASS_PREFIX = "ooo-";
+
+  // ../core/src/dom.ts
+  function closestAncestor(start, test) {
+    for (let node = start; node; node = node.parentElement) {
+      if (test(node)) {
+        return node;
+      }
+    }
+    return null;
+  }
+  function selectorFor(element) {
+    const parts = [];
+    let node = element;
+    let depth = 0;
+    while (node && depth < 4) {
+      let part = node.tagName.toLowerCase();
+      if (node.id) {
+        part += `#${node.id}`;
+        parts.unshift(part);
+        break;
+      }
+      const cls = (node.getAttribute("class") || "").trim().split(/\s+/).filter((c) => c && !c.startsWith(OVERLAY_CLASS_PREFIX));
+      if (cls.length) {
+        part += `.${cls[0]}`;
+      }
+      parts.unshift(part);
+      node = node.parentElement;
+      depth++;
+    }
+    return parts.join(" > ");
+  }
+  var NATIVE_FOR_ROLE = {
+    button: "<button>",
+    link: "<a href>",
+    checkbox: '<input type="checkbox">',
+    radio: '<input type="radio">',
+    switch: '<input type="checkbox" role="switch">',
+    slider: '<input type="range">',
+    spinbutton: '<input type="number">',
+    searchbox: '<input type="search">',
+    textbox: "<input> or <textarea>",
+    combobox: "<select>",
+    option: "<option>"
+  };
+  var COMPOSITE_ROLES_NO_NATIVE = [
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "tab",
+    "treeitem"
+  ];
+  var INTERACTIVE_ROLES = [...Object.keys(NATIVE_FOR_ROLE), ...COMPOSITE_ROLES_NO_NATIVE];
+  function isInteractive(element) {
+    const tag = element.tagName.toLowerCase();
+    if (tag === "a" && element.hasAttribute("href")) {
+      return true;
+    }
+    if (["button", "select", "textarea", "summary"].includes(tag)) {
+      return true;
+    }
+    if (tag === "input") {
+      const type = (element.getAttribute("type") || "text").toLowerCase();
+      return type !== "hidden";
+    }
+    const role = element.getAttribute("role");
+    return !!role && INTERACTIVE_ROLES.includes(role);
+  }
+  function hasExplicitName(element) {
+    return (element.getAttribute("aria-label") || "").trim() !== "" || (element.getAttribute("title") || "").trim() !== "";
+  }
+  function inAriaHidden(element) {
+    return element.closest('[aria-hidden="true"]') !== null;
+  }
+  function isInert2(element) {
+    return element.closest("[inert]") !== null;
+  }
+  var IGNORE_ATTRIBUTE = "data-ooo-ignore";
+  function isRuleIgnored(element, ruleId) {
+    const value = element.getAttribute(IGNORE_ATTRIBUTE);
+    if (value === null) {
+      return false;
+    }
+    const ids = value.trim().split(/\s+/).filter(Boolean);
+    return ids.length === 0 || ids.includes(ruleId);
+  }
+  function isTransparent(element) {
+    const check = element.checkVisibility;
+    if (typeof check === "function") {
+      return !check.call(element, { opacityProperty: true });
+    }
+    return closestAncestor(element, (node) => parseFloat(getComputedStyle(node).opacity || "1") === 0) !== null;
+  }
+  function isScreenReaderOnly(element, rect = element.getBoundingClientRect()) {
+    if (rect.width > 2 || rect.height > 2) {
+      return false;
+    }
+    const style = getComputedStyle(element);
+    return style.clip !== "" && style.clip !== "auto" || style.clipPath !== "" && style.clipPath !== "none" || style.overflow === "hidden";
+  }
+  function isClipped(element, rect) {
+    for (let node = element.parentElement; node; node = node.parentElement) {
+      const containerRect = node.getBoundingClientRect();
+      if (containerRect.width === 0 && containerRect.height === 0) {
+        continue;
+      }
+      const style = getComputedStyle(node);
+      const outX = rect.right <= containerRect.left || rect.left >= containerRect.right;
+      const outY = rect.bottom <= containerRect.top || rect.top >= containerRect.bottom;
+      const clipX = style.overflowX === "clip";
+      const clipY = style.overflowY === "clip";
+      if (outX && clipX || outY && clipY) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function isOffPage(element, rect) {
+    const win = element.ownerDocument?.defaultView;
+    if (!win) {
+      return false;
+    }
+    const pageRight = rect.right + win.scrollX;
+    const pageBottom = rect.bottom + win.scrollY;
+    return pageRight <= 0 || pageBottom <= 0;
+  }
+  function staticHiddenReason(element, rect) {
+    if (isScreenReaderOnly(element, rect)) {
+      return null;
+    }
+    if (element.tagName.toLowerCase() === "area") {
+      return null;
+    }
+    if (isTransparent(element)) {
+      return "opacity:0, invisible but still tabbable";
+    }
+    if (rect.width < 1 || rect.height < 1) {
+      return "zero size, no visible target";
+    }
+    if (isOffPage(element, rect)) {
+      return "positioned off-screen (e.g. left:-9999px), invisible but still tabbable";
+    }
+    if (isClipped(element, rect)) {
+      return "clipped by an overflow:clip ancestor";
+    }
+    return null;
+  }
+  var REVEALING_PROPS = [
+    "opacity",
+    "visibility",
+    "display",
+    "position",
+    "left",
+    "right",
+    "top",
+    "bottom",
+    "inset",
+    "clip",
+    "clip-path",
+    "transform",
+    "translate",
+    "scale",
+    "width",
+    "height",
+    "max-width",
+    "max-height",
+    "overflow"
+  ];
+  function revealSelectors(rules) {
+    return Array.from(rules).flatMap((rule) => {
+      if (rule instanceof CSSStyleRule) {
+        if (!/:focus/i.test(rule.selectorText) || !REVEALING_PROPS.some((p) => rule.style.getPropertyValue(p) !== "")) {
+          return [];
+        }
+        const resting = rule.selectorText.replace(/:focus(?:-visible|-within)?/gi, "").trim();
+        return resting ? [resting] : [];
+      }
+      return "cssRules" in rule ? revealSelectors(rule.cssRules) : [];
+    });
+  }
+  function focusRevealSelectors(doc) {
+    const sheets = [...Array.from(doc.styleSheets), ...doc.adoptedStyleSheets ?? []];
+    return sheets.flatMap((sheet) => {
+      try {
+        return revealSelectors(sheet.cssRules);
+      } catch {
+        return [];
+      }
+    });
+  }
+  function hiddenReason(element, rect, revealOnFocus = []) {
+    const reason = staticHiddenReason(element, rect);
+    if (!reason) {
+      return null;
+    }
+    const revealed = revealOnFocus.some((selector) => {
+      try {
+        return element.matches(selector);
+      } catch {
+        return false;
+      }
+    });
+    return revealed ? null : reason;
+  }
+  var NATIVE_INTERACTIVE_TAGS = ["a", "button", "input", "select", "textarea", "summary", "option"];
+  function looksClickable(element) {
+    const tag = element.tagName.toLowerCase();
+    if (NATIVE_INTERACTIVE_TAGS.includes(tag)) {
+      return false;
+    }
+    const role = element.getAttribute("role");
+    if (role && INTERACTIVE_ROLES.includes(role)) {
+      return true;
+    }
+    return element.hasAttribute("onclick");
+  }
+  function nativeReplacement(element) {
+    if (NATIVE_INTERACTIVE_TAGS.includes(element.tagName.toLowerCase())) {
+      return null;
+    }
+    const role = element.getAttribute("role");
+    if (!role) {
+      return null;
+    }
+    return NATIVE_FOR_ROLE[role] ?? null;
+  }
+  function isNativelyFocusable(element) {
+    const tag = element.tagName.toLowerCase();
+    if (tag === "a" || tag === "area") {
+      return element.hasAttribute("href");
+    }
+    if (["button", "select", "textarea", "iframe"].includes(tag)) {
+      return true;
+    }
+    if (tag === "input") {
+      return (element.getAttribute("type") || "text").toLowerCase() !== "hidden";
+    }
+    if (tag === "audio" || tag === "video") {
+      return element.hasAttribute("controls");
+    }
+    if (tag === "summary") {
+      const parent = element.parentElement;
+      return parent?.tagName.toLowerCase() === "details" && parent.querySelector("summary") === element;
+    }
+    return false;
+  }
+  var COMPOSITE_ROLES = [
+    "toolbar",
+    "tablist",
+    "menu",
+    "menubar",
+    "radiogroup",
+    "listbox",
+    "tree",
+    "grid"
+  ];
+  function compositeAncestor(element) {
+    return closestAncestor(element.parentElement, (node) => {
+      const role = node.getAttribute("role");
+      return !!role && COMPOSITE_ROLES.includes(role);
+    });
+  }
+  function isFocusManaged(element) {
+    const tabindex = element.getAttribute("tabindex");
+    if (tabindex !== null && Number(tabindex) < 0) {
+      return true;
+    }
+    if (compositeAncestor(element)) {
+      return true;
+    }
+    return element.closest("[aria-activedescendant]") !== null;
+  }
+  function floatingAncestor(element) {
+    return closestAncestor(element, (node) => {
+      const pos = getComputedStyle(node).position;
+      return pos === "fixed" || pos === "sticky";
+    });
+  }
+  function isScrollContainer(element) {
+    const scrollable = (value) => value === "auto" || value === "scroll" || value === "overlay";
+    const style = getComputedStyle(element);
+    return scrollable(style.overflowX) || scrollable(style.overflowY);
+  }
+  function scrollAncestor(element) {
+    return closestAncestor(element.parentElement, isScrollContainer);
+  }
+  function isDisplayed(element) {
+    const check = element.checkVisibility;
+    if (typeof check === "function") {
+      return check.call(element, { visibilityProperty: true });
+    }
+    return closestAncestor(element, (node) => getComputedStyle(node).display === "none") === null;
+  }
+  function openModal(root) {
+    for (const element of root.querySelectorAll('dialog:modal, [aria-modal="true"]')) {
+      if (isDisplayed(element)) {
+        return element;
+      }
+    }
+    return null;
+  }
+
+  // ../../node_modules/.pnpm/dom-accessibility-api@0.7.1/node_modules/dom-accessibility-api/dist/polyfills/array.from.mjs
+  var toStr = Object.prototype.toString;
+  function isCallable(fn) {
+    return typeof fn === "function" || toStr.call(fn) === "[object Function]";
+  }
+  function toInteger(value) {
+    var number = Number(value);
+    if (isNaN(number)) {
+      return 0;
+    }
+    if (number === 0 || !isFinite(number)) {
+      return number;
+    }
+    return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
+  }
+  var maxSafeInteger = Math.pow(2, 53) - 1;
+  function toLength(value) {
+    var len = toInteger(value);
+    return Math.min(Math.max(len, 0), maxSafeInteger);
+  }
+  function arrayFrom(arrayLike, mapFn) {
+    var C = Array;
+    var items = Object(arrayLike);
+    if (arrayLike == null) {
+      throw new TypeError("Array.from requires an array-like object - not null or undefined");
+    }
+    if (typeof mapFn !== "undefined") {
+      if (!isCallable(mapFn)) {
+        throw new TypeError("Array.from: when provided, the second argument must be a function");
+      }
+    }
+    var len = toLength(items.length);
+    var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+    var k = 0;
+    var kValue;
+    while (k < len) {
+      kValue = items[k];
+      if (mapFn) {
+        A[k] = mapFn(kValue, k);
+      } else {
+        A[k] = kValue;
+      }
+      k += 1;
+    }
+    A.length = len;
+    return A;
+  }
+
+  // ../../node_modules/.pnpm/dom-accessibility-api@0.7.1/node_modules/dom-accessibility-api/dist/polyfills/SetLike.mjs
+  function _typeof(o) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+      return typeof o2;
+    } : function(o2) {
+      return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+    }, _typeof(o);
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", { writable: false });
+    return Constructor;
+  }
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == _typeof(i) ? i : i + "";
+  }
+  function _toPrimitive(t, r) {
+    if ("object" != _typeof(t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != _typeof(i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  var SetLike = /* @__PURE__ */ (function() {
+    function SetLike2() {
+      var items = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+      _classCallCheck(this, SetLike2);
+      _defineProperty(this, "items", void 0);
+      this.items = items;
+    }
+    return _createClass(SetLike2, [{
+      key: "add",
+      value: function add(value) {
+        if (this.has(value) === false) {
+          this.items.push(value);
+        }
+        return this;
+      }
+    }, {
+      key: "clear",
+      value: function clear() {
+        this.items = [];
+      }
+    }, {
+      key: "delete",
+      value: function _delete(value) {
+        var previousLength = this.items.length;
+        this.items = this.items.filter(function(item) {
+          return item !== value;
+        });
+        return previousLength !== this.items.length;
+      }
+    }, {
+      key: "forEach",
+      value: function forEach(callbackfn) {
+        var _this = this;
+        this.items.forEach(function(item) {
+          callbackfn(item, item, _this);
+        });
+      }
+    }, {
+      key: "has",
+      value: function has(value) {
+        return this.items.indexOf(value) !== -1;
+      }
+    }, {
+      key: "size",
+      get: function get() {
+        return this.items.length;
+      }
+    }]);
+  })();
+  var SetLike_default = typeof Set === "undefined" ? Set : SetLike;
+
+  // ../../node_modules/.pnpm/dom-accessibility-api@0.7.1/node_modules/dom-accessibility-api/dist/getRole.mjs
+  function getLocalName(element) {
+    var _element$localName;
+    return (
+      // eslint-disable-next-line no-restricted-properties -- actual guard for environments without localName
+      (_element$localName = element.localName) !== null && _element$localName !== void 0 ? _element$localName : (
+        // eslint-disable-next-line no-restricted-properties -- required for the fallback
+        element.tagName.toLowerCase()
+      )
+    );
+  }
+  var localNameToRoleMappings = {
+    article: "article",
+    aside: "complementary",
+    button: "button",
+    datalist: "listbox",
+    dd: "definition",
+    details: "group",
+    dialog: "dialog",
+    dt: "term",
+    fieldset: "group",
+    figure: "figure",
+    // WARNING: Only with an accessible name
+    form: "form",
+    footer: "contentinfo",
+    h1: "heading",
+    h2: "heading",
+    h3: "heading",
+    h4: "heading",
+    h5: "heading",
+    h6: "heading",
+    header: "banner",
+    hr: "separator",
+    html: "document",
+    legend: "legend",
+    li: "listitem",
+    math: "math",
+    main: "main",
+    menu: "list",
+    nav: "navigation",
+    ol: "list",
+    optgroup: "group",
+    // WARNING: Only in certain context
+    option: "option",
+    output: "status",
+    progress: "progressbar",
+    // WARNING: Only with an accessible name
+    section: "region",
+    summary: "button",
+    table: "table",
+    tbody: "rowgroup",
+    textarea: "textbox",
+    tfoot: "rowgroup",
+    // WARNING: Only in certain context
+    td: "cell",
+    th: "columnheader",
+    thead: "rowgroup",
+    tr: "row",
+    ul: "list"
+  };
+  var prohibitedAttributes = {
+    caption: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    code: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    deletion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    emphasis: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    generic: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby", "aria-roledescription"]),
+    insertion: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    none: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    paragraph: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    presentation: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    strong: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    subscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"]),
+    superscript: /* @__PURE__ */ new Set(["aria-label", "aria-labelledby"])
+  };
+  function hasGlobalAriaAttributes(element, role) {
+    return [
+      "aria-atomic",
+      "aria-busy",
+      "aria-controls",
+      "aria-current",
+      "aria-description",
+      "aria-describedby",
+      "aria-details",
+      // "disabled",
+      "aria-dropeffect",
+      // "errormessage",
+      "aria-flowto",
+      "aria-grabbed",
+      // "haspopup",
+      "aria-hidden",
+      // "invalid",
+      "aria-keyshortcuts",
+      "aria-label",
+      "aria-labelledby",
+      "aria-live",
+      "aria-owns",
+      "aria-relevant",
+      "aria-roledescription"
+    ].some(function(attributeName) {
+      var _prohibitedAttributes;
+      return element.hasAttribute(attributeName) && !((_prohibitedAttributes = prohibitedAttributes[role]) !== null && _prohibitedAttributes !== void 0 && _prohibitedAttributes.has(attributeName));
+    });
+  }
+  function ignorePresentationalRole(element, implicitRole) {
+    return hasGlobalAriaAttributes(element, implicitRole);
+  }
+  function getRole(element) {
+    var explicitRole = getExplicitRole(element);
+    if (explicitRole === null || presentationRoles.indexOf(explicitRole) !== -1) {
+      var implicitRole = getImplicitRole(element);
+      if (presentationRoles.indexOf(explicitRole || "") === -1 || ignorePresentationalRole(element, implicitRole || "")) {
+        return implicitRole;
+      }
+    }
+    return explicitRole;
+  }
+  function getImplicitRole(element) {
+    var mappedByTag = localNameToRoleMappings[getLocalName(element)];
+    if (mappedByTag !== void 0) {
+      return mappedByTag;
+    }
+    switch (getLocalName(element)) {
+      case "a":
+      case "area":
+      case "link":
+        if (element.hasAttribute("href")) {
+          return "link";
+        }
+        break;
+      case "img":
+        if (element.getAttribute("alt") === "" && !ignorePresentationalRole(element, "img")) {
+          return "presentation";
+        }
+        return "img";
+      case "input": {
+        var _ref = element, type = _ref.type;
+        switch (type) {
+          case "button":
+          case "image":
+          case "reset":
+          case "submit":
+            return "button";
+          case "checkbox":
+          case "radio":
+            return type;
+          case "range":
+            return "slider";
+          case "email":
+          case "tel":
+          case "text":
+          case "url":
+            if (element.hasAttribute("list")) {
+              return "combobox";
+            }
+            return "textbox";
+          case "search":
+            if (element.hasAttribute("list")) {
+              return "combobox";
+            }
+            return "searchbox";
+          case "number":
+            return "spinbutton";
+          default:
+            return null;
+        }
+      }
+      case "select":
+        if (element.hasAttribute("multiple") || element.size > 1) {
+          return "listbox";
+        }
+        return "combobox";
+    }
+    return null;
+  }
+  function getExplicitRole(element) {
+    var role = element.getAttribute("role");
+    if (role !== null) {
+      var explicitRole = role.trim().split(" ")[0];
+      if (explicitRole.length > 0) {
+        return explicitRole;
+      }
+    }
+    return null;
+  }
+
+  // ../../node_modules/.pnpm/dom-accessibility-api@0.7.1/node_modules/dom-accessibility-api/dist/util.mjs
+  var presentationRoles = ["presentation", "none"];
+  function isElement(node) {
+    return node !== null && node.nodeType === node.ELEMENT_NODE;
+  }
+  function isHTMLTableCaptionElement(node) {
+    return isElement(node) && getLocalName(node) === "caption";
+  }
+  function isHTMLInputElement(node) {
+    return isElement(node) && getLocalName(node) === "input";
+  }
+  function isHTMLOptGroupElement(node) {
+    return isElement(node) && getLocalName(node) === "optgroup";
+  }
+  function isHTMLSelectElement(node) {
+    return isElement(node) && getLocalName(node) === "select";
+  }
+  function isHTMLTableElement(node) {
+    return isElement(node) && getLocalName(node) === "table";
+  }
+  function isHTMLTextAreaElement(node) {
+    return isElement(node) && getLocalName(node) === "textarea";
+  }
+  function safeWindow(node) {
+    var _ref = node.ownerDocument === null ? node : node.ownerDocument, defaultView = _ref.defaultView;
+    if (defaultView === null) {
+      throw new TypeError("no window available");
+    }
+    return defaultView;
+  }
+  function isHTMLFieldSetElement(node) {
+    return isElement(node) && getLocalName(node) === "fieldset";
+  }
+  function isHTMLLegendElement(node) {
+    return isElement(node) && getLocalName(node) === "legend";
+  }
+  function isHTMLSlotElement(node) {
+    return isElement(node) && getLocalName(node) === "slot";
+  }
+  function isSVGElement(node) {
+    return isElement(node) && node.ownerSVGElement !== void 0;
+  }
+  function isSVGSVGElement(node) {
+    return isElement(node) && getLocalName(node) === "svg";
+  }
+  function isSVGTitleElement(node) {
+    return isSVGElement(node) && getLocalName(node) === "title";
+  }
+  function queryIdRefs(node, attributeName) {
+    if (isElement(node) && node.hasAttribute(attributeName)) {
+      var ids = node.getAttribute(attributeName).split(" ");
+      var root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
+      return ids.map(function(id) {
+        return root.getElementById(id);
+      }).filter(
+        function(element) {
+          return element !== null;
+        }
+        // TODO: why does this not narrow?
+      );
+    }
+    return [];
+  }
+  function hasAnyConcreteRoles(node, roles) {
+    if (isElement(node)) {
+      return roles.indexOf(getRole(node)) !== -1;
+    }
+    return false;
+  }
+
+  // ../../node_modules/.pnpm/dom-accessibility-api@0.7.1/node_modules/dom-accessibility-api/dist/accessible-name-and-description.mjs
+  function asFlatString(s) {
+    return s.trim().replace(/\s\s+/g, " ");
+  }
+  function isHidden3(node, getComputedStyleImplementation) {
+    if (!isElement(node)) {
+      return false;
+    }
+    if (node.hasAttribute("hidden") || node.getAttribute("aria-hidden") === "true") {
+      return true;
+    }
+    var style = getComputedStyleImplementation(node);
+    return style.getPropertyValue("display") === "none" || style.getPropertyValue("visibility") === "hidden";
+  }
+  function isControl(node) {
+    return hasAnyConcreteRoles(node, ["button", "combobox", "listbox", "textbox"]) || hasAbstractRole(node, "range");
+  }
+  function hasAbstractRole(node, role) {
+    if (!isElement(node)) {
+      return false;
+    }
+    switch (role) {
+      case "range":
+        return hasAnyConcreteRoles(node, ["meter", "progressbar", "scrollbar", "slider", "spinbutton"]);
+      default:
+        throw new TypeError("No knowledge about abstract role '".concat(role, "'. This is likely a bug :("));
+    }
+  }
+  function querySelectorAllSubtree(element, selectors) {
+    var elements = arrayFrom(element.querySelectorAll(selectors));
+    queryIdRefs(element, "aria-owns").forEach(function(root) {
+      elements.push.apply(elements, arrayFrom(root.querySelectorAll(selectors)));
+    });
+    return elements;
+  }
+  function querySelectedOptions(listbox) {
+    if (isHTMLSelectElement(listbox)) {
+      return listbox.selectedOptions || querySelectorAllSubtree(listbox, "[selected]");
+    }
+    return querySelectorAllSubtree(listbox, '[aria-selected="true"]');
+  }
+  function isMarkedPresentational(node) {
+    return hasAnyConcreteRoles(node, presentationRoles);
+  }
+  function isNativeHostLanguageTextAlternativeElement(node) {
+    return isHTMLTableCaptionElement(node);
+  }
+  function allowsNameFromContent(node) {
+    return hasAnyConcreteRoles(node, ["button", "cell", "checkbox", "columnheader", "gridcell", "heading", "label", "legend", "link", "menuitem", "menuitemcheckbox", "menuitemradio", "option", "radio", "row", "rowheader", "switch", "tab", "tooltip", "treeitem"]);
+  }
+  function isDescendantOfNativeHostLanguageTextAlternativeElement(node) {
+    return false;
+  }
+  function getValueOfTextbox(element) {
+    if (isHTMLInputElement(element) || isHTMLTextAreaElement(element)) {
+      return element.value;
+    }
+    return element.textContent || "";
+  }
+  function getTextualContent(declaration) {
+    var content = declaration.getPropertyValue("content");
+    if (/^["'].*["']$/.test(content)) {
+      return content.slice(1, -1);
+    }
+    return "";
+  }
+  function isLabelableElement(element) {
+    var localName = getLocalName(element);
+    return localName === "button" || localName === "input" && element.getAttribute("type") !== "hidden" || localName === "meter" || localName === "output" || localName === "progress" || localName === "select" || localName === "textarea";
+  }
+  function findLabelableElement(element) {
+    if (isLabelableElement(element)) {
+      return element;
+    }
+    var labelableElement = null;
+    element.childNodes.forEach(function(childNode) {
+      if (labelableElement === null && isElement(childNode)) {
+        var descendantLabelableElement = findLabelableElement(childNode);
+        if (descendantLabelableElement !== null) {
+          labelableElement = descendantLabelableElement;
+        }
+      }
+    });
+    return labelableElement;
+  }
+  function getControlOfLabel(label) {
+    if (label.control !== void 0) {
+      return label.control;
+    }
+    var htmlFor = label.getAttribute("for");
+    if (htmlFor !== null) {
+      return label.ownerDocument.getElementById(htmlFor);
+    }
+    return findLabelableElement(label);
+  }
+  function getLabels(element) {
+    var labelsProperty = element.labels;
+    if (labelsProperty === null) {
+      return labelsProperty;
+    }
+    if (labelsProperty !== void 0) {
+      return arrayFrom(labelsProperty);
+    }
+    if (!isLabelableElement(element)) {
+      return null;
+    }
+    var document2 = element.ownerDocument;
+    return arrayFrom(document2.querySelectorAll("label")).filter(function(label) {
+      return getControlOfLabel(label) === element;
+    });
+  }
+  function getSlotContents(slot) {
+    var assignedNodes = slot.assignedNodes();
+    if (assignedNodes.length === 0) {
+      return arrayFrom(slot.childNodes);
+    }
+    return assignedNodes;
+  }
+  function computeTextAlternative(root) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var consultedNodes = new SetLike_default();
+    var computedStyles = typeof Map === "undefined" ? void 0 : /* @__PURE__ */ new Map();
+    var window2 = safeWindow(root);
+    var _options$compute = options.compute, compute = _options$compute === void 0 ? "name" : _options$compute, _options$computedStyl = options.computedStyleSupportsPseudoElements, computedStyleSupportsPseudoElements = _options$computedStyl === void 0 ? options.getComputedStyle !== void 0 : _options$computedStyl, _options$getComputedS = options.getComputedStyle, uncachedGetComputedStyle = _options$getComputedS === void 0 ? window2.getComputedStyle.bind(window2) : _options$getComputedS, _options$hidden = options.hidden, hidden = _options$hidden === void 0 ? false : _options$hidden;
+    var getComputedStyle2 = function getComputedStyle3(el, pseudoElement) {
+      if (pseudoElement !== void 0) {
+        throw new Error("use uncachedGetComputedStyle directly for pseudo elements");
+      }
+      if (computedStyles === void 0) {
+        return uncachedGetComputedStyle(el);
+      }
+      var cachedStyles = computedStyles.get(el);
+      if (cachedStyles) {
+        return cachedStyles;
+      }
+      var style = uncachedGetComputedStyle(el, pseudoElement);
+      computedStyles.set(el, style);
+      return style;
+    };
+    function computeMiscTextAlternative(node, context) {
+      var accumulatedText = "";
+      if (isElement(node) && computedStyleSupportsPseudoElements) {
+        var pseudoBefore = uncachedGetComputedStyle(node, "::before");
+        var beforeContent = getTextualContent(pseudoBefore);
+        accumulatedText = "".concat(beforeContent, " ").concat(accumulatedText);
+      }
+      var childNodes = isHTMLSlotElement(node) ? getSlotContents(node) : arrayFrom(node.childNodes).concat(queryIdRefs(node, "aria-owns"));
+      childNodes.forEach(function(child) {
+        var result = computeTextAlternative2(child, {
+          isEmbeddedInLabel: context.isEmbeddedInLabel,
+          isReferenced: false,
+          recursion: true
+        });
+        var display = isElement(child) ? getComputedStyle2(child).getPropertyValue("display") : "inline";
+        var separator = display !== "inline" ? " " : "";
+        accumulatedText += "".concat(separator).concat(result).concat(separator);
+      });
+      if (isElement(node) && computedStyleSupportsPseudoElements) {
+        var pseudoAfter = uncachedGetComputedStyle(node, "::after");
+        var afterContent = getTextualContent(pseudoAfter);
+        accumulatedText = "".concat(accumulatedText, " ").concat(afterContent);
+      }
+      return accumulatedText.trim();
+    }
+    function useAttribute(element, attributeName) {
+      var attribute = element.getAttributeNode(attributeName);
+      if (attribute !== null && !consultedNodes.has(attribute) && attribute.value.trim() !== "") {
+        consultedNodes.add(attribute);
+        return attribute.value;
+      }
+      return null;
+    }
+    function computeTooltipAttributeValue(node) {
+      if (!isElement(node)) {
+        return null;
+      }
+      return useAttribute(node, "title");
+    }
+    function computeElementTextAlternative(node) {
+      if (!isElement(node)) {
+        return null;
+      }
+      if (isHTMLFieldSetElement(node)) {
+        consultedNodes.add(node);
+        var children = arrayFrom(node.childNodes);
+        for (var i = 0; i < children.length; i += 1) {
+          var child = children[i];
+          if (isHTMLLegendElement(child)) {
+            return computeTextAlternative2(child, {
+              isEmbeddedInLabel: false,
+              isReferenced: false,
+              recursion: false
+            });
+          }
+        }
+      } else if (isHTMLTableElement(node)) {
+        consultedNodes.add(node);
+        var _children = arrayFrom(node.childNodes);
+        for (var _i = 0; _i < _children.length; _i += 1) {
+          var _child = _children[_i];
+          if (isHTMLTableCaptionElement(_child)) {
+            return computeTextAlternative2(_child, {
+              isEmbeddedInLabel: false,
+              isReferenced: false,
+              recursion: false
+            });
+          }
+        }
+      } else if (isSVGSVGElement(node)) {
+        consultedNodes.add(node);
+        var _children2 = arrayFrom(node.childNodes);
+        for (var _i2 = 0; _i2 < _children2.length; _i2 += 1) {
+          var _child2 = _children2[_i2];
+          if (isSVGTitleElement(_child2)) {
+            return _child2.textContent;
+          }
+        }
+        return null;
+      } else if (getLocalName(node) === "img" || getLocalName(node) === "area") {
+        var nameFromAlt = useAttribute(node, "alt");
+        if (nameFromAlt !== null) {
+          return nameFromAlt;
+        }
+      } else if (isHTMLOptGroupElement(node)) {
+        var nameFromLabel = useAttribute(node, "label");
+        if (nameFromLabel !== null) {
+          return nameFromLabel;
+        }
+      }
+      if (isHTMLInputElement(node) && (node.type === "button" || node.type === "submit" || node.type === "reset")) {
+        var nameFromValue = useAttribute(node, "value");
+        if (nameFromValue !== null) {
+          return nameFromValue;
+        }
+        if (node.type === "submit") {
+          return "Submit";
+        }
+        if (node.type === "reset") {
+          return "Reset";
+        }
+      }
+      var labels = getLabels(node);
+      if (labels !== null && labels.length !== 0) {
+        consultedNodes.add(node);
+        return arrayFrom(labels).map(function(element) {
+          return computeTextAlternative2(element, {
+            isEmbeddedInLabel: true,
+            isReferenced: false,
+            recursion: true
+          });
+        }).filter(function(label) {
+          return label.length > 0;
+        }).join(" ");
+      }
+      if (isHTMLInputElement(node) && node.type === "image") {
+        var _nameFromAlt = useAttribute(node, "alt");
+        if (_nameFromAlt !== null) {
+          return _nameFromAlt;
+        }
+        var nameFromTitle = useAttribute(node, "title");
+        if (nameFromTitle !== null) {
+          return nameFromTitle;
+        }
+        return "Submit Query";
+      }
+      if (hasAnyConcreteRoles(node, ["button"])) {
+        var nameFromSubTree = computeMiscTextAlternative(node, {
+          isEmbeddedInLabel: false,
+          isReferenced: false
+        });
+        if (nameFromSubTree !== "") {
+          return nameFromSubTree;
+        }
+      }
+      return null;
+    }
+    function computeTextAlternative2(current, context) {
+      if (consultedNodes.has(current)) {
+        return "";
+      }
+      if (!hidden && isHidden3(current, getComputedStyle2) && !context.isReferenced) {
+        consultedNodes.add(current);
+        return "";
+      }
+      var labelAttributeNode = isElement(current) ? current.getAttributeNode("aria-labelledby") : null;
+      var labelElements = labelAttributeNode !== null && !consultedNodes.has(labelAttributeNode) ? queryIdRefs(current, "aria-labelledby") : [];
+      if (compute === "name" && !context.isReferenced && labelElements.length > 0) {
+        consultedNodes.add(labelAttributeNode);
+        return labelElements.map(function(element) {
+          return computeTextAlternative2(element, {
+            isEmbeddedInLabel: context.isEmbeddedInLabel,
+            isReferenced: true,
+            // this isn't recursion as specified, otherwise we would skip
+            // `aria-label` in
+            // <input id="myself" aria-label="foo" aria-labelledby="myself"
+            recursion: false
+          });
+        }).join(" ");
+      }
+      var skipToStep2E = context.recursion && isControl(current) && compute === "name";
+      if (!skipToStep2E) {
+        var ariaLabel = (isElement(current) && current.getAttribute("aria-label") || "").trim();
+        if (ariaLabel !== "" && compute === "name") {
+          consultedNodes.add(current);
+          return ariaLabel;
+        }
+        if (!isMarkedPresentational(current)) {
+          var elementTextAlternative = computeElementTextAlternative(current);
+          if (elementTextAlternative !== null) {
+            consultedNodes.add(current);
+            return elementTextAlternative;
+          }
+        }
+      }
+      if (hasAnyConcreteRoles(current, ["menu"])) {
+        consultedNodes.add(current);
+        return "";
+      }
+      if (skipToStep2E || context.isEmbeddedInLabel || context.isReferenced) {
+        if (hasAnyConcreteRoles(current, ["combobox", "listbox"])) {
+          consultedNodes.add(current);
+          var selectedOptions = querySelectedOptions(current);
+          if (selectedOptions.length === 0) {
+            return isHTMLInputElement(current) ? current.value : "";
+          }
+          return arrayFrom(selectedOptions).map(function(selectedOption) {
+            return computeTextAlternative2(selectedOption, {
+              isEmbeddedInLabel: context.isEmbeddedInLabel,
+              isReferenced: false,
+              recursion: true
+            });
+          }).join(" ");
+        }
+        if (hasAbstractRole(current, "range")) {
+          consultedNodes.add(current);
+          if (current.hasAttribute("aria-valuetext")) {
+            return current.getAttribute("aria-valuetext");
+          }
+          if (current.hasAttribute("aria-valuenow")) {
+            return current.getAttribute("aria-valuenow");
+          }
+          return current.getAttribute("value") || "";
+        }
+        if (hasAnyConcreteRoles(current, ["textbox"])) {
+          consultedNodes.add(current);
+          return getValueOfTextbox(current);
+        }
+      }
+      if (allowsNameFromContent(current) || isElement(current) && context.isReferenced || isNativeHostLanguageTextAlternativeElement(current) || isDescendantOfNativeHostLanguageTextAlternativeElement(current)) {
+        var accumulatedText2F = computeMiscTextAlternative(current, {
+          isEmbeddedInLabel: context.isEmbeddedInLabel,
+          isReferenced: false
+        });
+        if (accumulatedText2F !== "") {
+          consultedNodes.add(current);
+          return accumulatedText2F;
+        }
+      }
+      if (current.nodeType === current.TEXT_NODE) {
+        consultedNodes.add(current);
+        return current.textContent || "";
+      }
+      if (context.recursion) {
+        consultedNodes.add(current);
+        return computeMiscTextAlternative(current, {
+          isEmbeddedInLabel: context.isEmbeddedInLabel,
+          isReferenced: false
+        });
+      }
+      var tooltipAttributeValue = computeTooltipAttributeValue(current);
+      if (tooltipAttributeValue !== null) {
+        consultedNodes.add(current);
+        return tooltipAttributeValue;
+      }
+      consultedNodes.add(current);
+      return "";
+    }
+    return asFlatString(computeTextAlternative2(root, {
+      isEmbeddedInLabel: false,
+      // by spec computeAccessibleDescription starts with the referenced elements as roots
+      isReferenced: compute === "description",
+      recursion: false
+    }));
+  }
+
+  // ../../node_modules/.pnpm/dom-accessibility-api@0.7.1/node_modules/dom-accessibility-api/dist/accessible-name.mjs
+  function prohibitsNaming(node) {
+    return hasAnyConcreteRoles(node, ["caption", "code", "deletion", "emphasis", "generic", "insertion", "none", "paragraph", "presentation", "strong", "subscript", "superscript"]);
+  }
+  function computeAccessibleName(root) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    if (prohibitsNaming(root)) {
+      return "";
+    }
+    return computeTextAlternative(root, options);
+  }
+
+  // ../core/src/rules.ts
+  var ROW_TOLERANCE_PX = 8;
+  var flagEntries = (sequence, message) => sequence.flatMap((entry) => {
+    const msg = message(entry);
+    return msg ? [{ message: msg, target: entry }] : [];
+  });
+  var noPositiveTabIndex = (sequence) => flagEntries(
+    sequence,
+    (entry) => entry.tabIndex > 0 ? `Element has tabindex="${entry.tabIndex}". Positive tabindex overrides the natural DOM order and is fragile; use 0 or restructure the DOM.` : null
+  );
+  var visualOrderMismatch = (sequence) => {
+    const floats = sequence.map((entry) => floatingAncestor(entry.element));
+    const scrollers = sequence.map((entry) => scrollAncestor(entry.element));
+    const out = [];
+    for (let idx = 1; idx < sequence.length; idx++) {
+      const prev = sequence[idx - 1];
+      const cur = sequence[idx];
+      if (floats[idx - 1] !== floats[idx] || scrollers[idx - 1] !== scrollers[idx]) {
+        continue;
+      }
+      const prevX = prev.rect.left + prev.rect.width / 2;
+      const curX = cur.rect.left + cur.rect.width / 2;
+      const nextColumn = cur.rect.left >= prev.rect.right;
+      const earlierRow = cur.rect.bottom <= prev.rect.top + ROW_TOLERANCE_PX;
+      const sameRow = !earlierRow && cur.rect.top < prev.rect.bottom - ROW_TOLERANCE_PX;
+      const backwardHop = !nextColumn && (earlierRow || sameRow && curX < prevX - 1);
+      if (!backwardHop) {
+        continue;
+      }
+      out.push({
+        message: `"${cur.selector}" comes after "${prev.selector}" in the tab order, but sits visually before it (reading order is top\u2192bottom, left\u2192right). Tab makes a backward hop here.`,
+        target: cur
+      });
+    }
+    return out;
+  };
+  var missingAccessibleName = (sequence) => flagEntries(sequence, (entry) => {
+    if (!isInteractive(entry.element)) {
+      return null;
+    }
+    if (hasExplicitName(entry.element)) {
+      return null;
+    }
+    if (computeAccessibleName(entry.element).trim() !== "") {
+      return null;
+    }
+    return `Focusable element "${entry.selector}" has no accessible name (no text, aria-label, aria-labelledby, associated label, alt, or title).`;
+  });
+  var ariaHiddenFocusable = (sequence) => flagEntries(
+    sequence,
+    (entry) => inAriaHidden(entry.element) ? `"${entry.selector}" is tabbable but inside aria-hidden="true", so a screen-reader user lands on a control the SR won't announce. Add tabindex="-1"/inert, or remove aria-hidden.` : null
+  );
+  var hiddenWhileFocusable = (sequence, { container }) => {
+    const revealOnFocus = focusRevealSelectors(container.ownerDocument);
+    return flagEntries(sequence, (entry) => {
+      const reason = hiddenReason(entry.element, entry.rect, revealOnFocus);
+      return reason ? `"${entry.selector}" is tabbable but ${reason}. Hide it from the tab order too (display:none, the hidden attribute, or tabindex="-1").` : null;
+    });
+  };
+  var clickableNotFocusable = (_sequence, { container, inSequence }) => {
+    const wrapsFocusable = /* @__PURE__ */ new Set();
+    for (const stop of inSequence) {
+      for (let node = stop; node; node = node.parentElement) {
+        if (wrapsFocusable.has(node)) {
+          break;
+        }
+        wrapsFocusable.add(node);
+      }
+    }
+    const out = [];
+    for (const element of container.querySelectorAll("*")) {
+      if (inSequence.has(element)) {
+        continue;
+      }
+      if (wrapsFocusable.has(element)) {
+        continue;
+      }
+      if (!looksClickable(element)) {
+        continue;
+      }
+      if (isFocusManaged(element)) {
+        continue;
+      }
+      if (isInert2(element)) {
+        continue;
+      }
+      const rect = element.getBoundingClientRect();
+      if (rect.width < 1 || rect.height < 1) {
+        continue;
+      }
+      const selector = selectorFor(element);
+      out.push({
+        message: `"${selector}" looks interactive (role or onclick) but is not in the tab order, so keyboard users can't reach it. Use a <button>/<a>, or add tabindex="0" plus Enter/Space handlers.`,
+        target: element
+      });
+    }
+    return out;
+  };
+  var compositeRovingTabindex = (sequence) => {
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of sequence) {
+      const container = compositeAncestor(entry.element);
+      if (!container) {
+        continue;
+      }
+      const list = groups.get(container) ?? [];
+      list.push(entry);
+      groups.set(container, list);
+    }
+    const out = [];
+    for (const [container, members] of groups) {
+      if (members.length < 2) {
+        continue;
+      }
+      const role = container.getAttribute("role");
+      for (const member of members) {
+        out.push({
+          message: `${members.length} items inside role="${role}" are separate tab stops. A ${role} should expose one tab stop and move between items with the arrow keys (roving tabindex).`,
+          target: member
+        });
+      }
+    }
+    return out;
+  };
+  var focusEscapesModal = (sequence, { container }) => {
+    const modal = openModal(container);
+    if (!modal) {
+      return [];
+    }
+    const leaked = sequence.filter(
+      (entry) => !modal.contains(entry.element) && !isInert2(entry.element)
+    );
+    if (leaked.length === 0) {
+      return [];
+    }
+    const first = leaked[0];
+    const subject = leaked.length === 1 ? `"${first.selector}" outside it is still tabbable` : `${leaked.length} controls outside it are still tabbable (e.g. "${first.selector}")`;
+    return [
+      {
+        message: `A modal dialog is open, but ${subject}, so focus can leak behind the dialog. Mark background content inert (or aria-hidden + remove it from the tab order).`,
+        target: first,
+        // One finding, anchored on the first leaked control, but every other leaked
+        // control shares the root cause (background not inert) and is ringed too.
+        relatedElements: leaked.slice(1).map((entry) => entry.element)
+      }
+    ];
+  };
+  var tabindexOnNoninteractive = (sequence) => flagEntries(sequence, (entry) => {
+    if (entry.tabIndex !== 0) {
+      return null;
+    }
+    if (entry.element.getAttribute("tabindex") === null) {
+      return null;
+    }
+    const element = entry.element;
+    if (isNativelyFocusable(element)) {
+      return null;
+    }
+    if (isInteractive(element)) {
+      return null;
+    }
+    if (element.isContentEditable) {
+      return null;
+    }
+    const role = element.getAttribute("role");
+    if (role && role !== "presentation" && role !== "none") {
+      return null;
+    }
+    if (isScrollContainer(element)) {
+      return null;
+    }
+    return `"${entry.selector}" has tabindex="0" but is non-interactive (no role, not a control). If it's decorative, remove the tabindex, since it adds a dead stop to the tab order; if it's meant to be a control, give it a real role (or use a <button>).`;
+  });
+  var preferNativeElement = (sequence) => flagEntries(sequence, (entry) => {
+    const native = nativeReplacement(entry.element);
+    if (!native) {
+      return null;
+    }
+    const tag = entry.element.tagName.toLowerCase();
+    const role = entry.element.getAttribute("role");
+    return `"${entry.selector}" is a <${tag}> with role="${role}". Prefer a native ${native}: focus, keyboard activation (Enter/Space), and screen-reader semantics come for free, instead of being reimplemented with ARIA + JS.`;
+  });
+  var duplicateAutofocus = (_sequence, { container }) => {
+    const focusableAutofocus = Array.from(container.querySelectorAll("[autofocus]")).filter(
+      (element) => isFocusable(element, { getShadowRoot: true })
+    );
+    if (focusableAutofocus.length < 2) {
+      return [];
+    }
+    return focusableAutofocus.slice(1).map((element) => {
+      const selector = selectorFor(element);
+      return {
+        message: `"${selector}" also has autofocus, but a page can autofocus only one element; the first focusable one in document order wins, so this one is silently ignored. Remove the extra autofocus.`,
+        target: element
+      };
+    });
+  };
+  var autofocusNotFocusable = (_sequence, { container }) => {
+    const out = [];
+    for (const element of container.querySelectorAll("[autofocus]")) {
+      if (isFocusable(element, { getShadowRoot: true })) {
+        continue;
+      }
+      const selector = selectorFor(element);
+      out.push({
+        message: `"${selector}" has autofocus but isn't focusable (no tabindex, not a form control), so it's ignored on load. Remove the autofocus, or make the element focusable (e.g. tabindex="-1").`,
+        target: element
+      });
+    }
+    return out;
+  };
+  var nestedInteractive = (sequence, { container, inSequence }) => {
+    const stop = container.parentElement;
+    const out = [];
+    for (const entry of sequence) {
+      for (let node = entry.element.parentElement; node && node !== stop; node = node.parentElement) {
+        if (!inSequence.has(node) && !isInteractive(node)) {
+          continue;
+        }
+        out.push({
+          message: `"${entry.selector}" is focusable but nested inside another focusable element ("${selectorFor(node)}"). Nesting interactive controls stacks two tab stops in one place and can hide the inner control's role/name from screen readers; don't put a focusable element inside another.`,
+          target: entry
+        });
+        break;
+      }
+    }
+    return out;
+  };
+  var redundantTabindex = (sequence) => flagEntries(sequence, (entry) => {
+    if (entry.tabIndex !== 0) {
+      return null;
+    }
+    if (entry.element.getAttribute("tabindex") === null) {
+      return null;
+    }
+    if (!isNativelyFocusable(entry.element)) {
+      return null;
+    }
+    return `"${entry.selector}" is already focusable, so its tabindex="0" is redundant. Remove the attribute; the element stays in the tab order on its own.`;
+  });
+  var ALL_RULES = {
+    "no-positive-tabindex": {
+      docs: "https://www.w3.org/WAI/WCAG22/Understanding/focus-order.html",
+      defaultSeverity: "error",
+      run: noPositiveTabIndex
+    },
+    "visual-order-mismatch": {
+      docs: "https://www.w3.org/WAI/WCAG22/Understanding/focus-order.html",
+      defaultSeverity: "warning",
+      run: visualOrderMismatch
+    },
+    "missing-accessible-name": {
+      docs: "https://www.w3.org/WAI/WCAG22/Understanding/name-role-value.html",
+      defaultSeverity: "error",
+      run: missingAccessibleName
+    },
+    "aria-hidden-focusable": {
+      docs: "https://www.w3.org/TR/wai-aria-1.2/#aria-hidden",
+      defaultSeverity: "error",
+      run: ariaHiddenFocusable
+    },
+    "hidden-while-focusable": {
+      docs: "https://www.w3.org/WAI/WCAG22/Understanding/focus-visible.html",
+      defaultSeverity: "error",
+      run: hiddenWhileFocusable
+    },
+    "clickable-not-focusable": {
+      docs: "https://www.w3.org/WAI/WCAG22/Understanding/keyboard.html",
+      defaultSeverity: "error",
+      run: clickableNotFocusable
+    },
+    "composite-roving-tabindex": {
+      docs: "https://www.w3.org/WAI/ARIA/apg/patterns/toolbar/",
+      defaultSeverity: "warning",
+      run: compositeRovingTabindex
+    },
+    "focus-escapes-modal": {
+      docs: "https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/",
+      defaultSeverity: "error",
+      run: focusEscapesModal
+    },
+    "tabindex-on-noninteractive": {
+      docs: "https://www.w3.org/WAI/ARIA/apg/practices/keyboard-interface/",
+      defaultSeverity: "error",
+      run: tabindexOnNoninteractive
+    },
+    "prefer-native-element": {
+      docs: "https://www.w3.org/TR/using-aria/#firstrule",
+      defaultSeverity: "warning",
+      run: preferNativeElement
+    },
+    "duplicate-autofocus": {
+      docs: "https://html.spec.whatwg.org/multipage/interaction.html#the-autofocus-attribute",
+      defaultSeverity: "warning",
+      run: duplicateAutofocus
+    },
+    "autofocus-not-focusable": {
+      docs: "https://html.spec.whatwg.org/multipage/interaction.html#the-autofocus-attribute",
+      defaultSeverity: "warning",
+      run: autofocusNotFocusable
+    },
+    "nested-interactive": {
+      docs: "https://www.w3.org/WAI/WCAG22/Understanding/name-role-value.html",
+      defaultSeverity: "error",
+      run: nestedInteractive
+    },
+    "redundant-tabindex": {
+      docs: "https://html.spec.whatwg.org/multipage/interaction.html#attr-tabindex",
+      defaultSeverity: "warning",
+      run: redundantTabindex
+    }
+  };
+  var DEFAULT_SEVERITY = Object.fromEntries(
+    Object.entries(ALL_RULES).map(([id, rule]) => [id, rule.defaultSeverity])
+  );
+
+  // ../core/src/audit.ts
+  function resolveRule(options, rule) {
+    const setting = options.rules?.[rule.id];
+    if (setting === void 0) {
+      return { enabled: true, severity: rule.defaultSeverity };
+    }
+    if (setting === "off") {
+      return { enabled: false, severity: rule.defaultSeverity };
+    }
+    return { enabled: true, severity: setting };
+  }
+  function toIssue(finding, rule, severity) {
+    return {
+      rule: rule.id,
+      severity,
+      message: finding.message,
+      docs: rule.docs,
+      relatedElements: finding.relatedElements
+    };
+  }
+  function locate(finding) {
+    const { target } = finding;
+    return "orderIndex" in target ? {
+      element: target.element,
+      selector: target.selector,
+      orderIndex: target.orderIndex
+    } : { element: target, selector: selectorFor(target) };
+  }
+  function audit(root = document, options = {}, customRules = []) {
+    const container = root.nodeType === 9 ? root.documentElement : root;
+    if (!container) {
+      return finalize({ valid: true, sequence: [], violations: [] }, options.format);
+    }
+    const elements = tabbable(container, {
+      getShadowRoot: true
+    });
+    const sequence = elements.map((element, orderIndex) => ({
+      element,
+      orderIndex,
+      selector: selectorFor(element),
+      tabIndex: getTabIndex(element),
+      rect: element.getBoundingClientRect()
+    }));
+    const ctx = {
+      container,
+      inSequence: new Set(sequence.map((entry) => entry.element))
+    };
+    const builtins = Object.entries(ALL_RULES).map(([id, def]) => ({
+      id,
+      ...def
+    }));
+    const byElement2 = /* @__PURE__ */ new Map();
+    for (const rule of [...builtins, ...customRules]) {
+      const { enabled, severity } = resolveRule(options, rule);
+      if (!enabled) {
+        continue;
+      }
+      for (const finding of rule.run(sequence, ctx)) {
+        const { element, selector, orderIndex } = locate(finding);
+        let violation = byElement2.get(element);
+        if (!violation) {
+          violation = { element, selector, orderIndex, issues: [] };
+          byElement2.set(element, violation);
+        }
+        const issue = toIssue(finding, rule, severity);
+        if (isRuleIgnored(element, rule.id)) {
+          issue.ignored = true;
+        }
+        violation.issues.push(issue);
+      }
+    }
+    const violations = [...byElement2.values()].sort(
+      (a, b) => (a.orderIndex ?? Infinity) - (b.orderIndex ?? Infinity)
+    );
+    for (const violation of violations) {
+      violation.issues.sort(
+        (a, b) => a.severity === b.severity ? 0 : a.severity === "error" ? -1 : 1
+      );
+    }
+    const hasErrors = violations.some(
+      (violation) => violation.issues.some((issue) => issue.severity === "error" && !issue.ignored)
+    );
+    return finalize({ valid: !hasErrors, sequence, violations }, options.format);
+  }
+  function finalize(result, format) {
+    if (!format) {
+      return result;
+    }
+    return { ...result, violations: reshape(result.violations, format) };
+  }
+  function reshape(violations, format) {
+    switch (format) {
+      case "text":
+        return renderText(violations);
+      case "by-element":
+        return byElement(violations);
+    }
+  }
+  var related = (issue) => issue.relatedElements?.map(selectorFor);
+  function byElement(violations) {
+    return violations.map((violation) => ({
+      selector: violation.selector,
+      orderIndex: violation.orderIndex,
+      issueCount: violation.issues.length,
+      issues: violation.issues.map((issue) => ({
+        rule: issue.rule,
+        severity: issue.severity,
+        message: issue.message,
+        docs: issue.docs,
+        related: related(issue),
+        ignored: issue.ignored
+      }))
+    }));
+  }
+  function renderText(violations) {
+    if (!violations.length) {
+      return "No tab-order issues.";
+    }
+    return violations.map((violation) => {
+      const pos = violation.orderIndex !== void 0 ? `#${violation.orderIndex + 1} ` : "";
+      const issues = violation.issues.map((issue) => {
+        const rel = related(issue);
+        return `  - ${issue.severity.toUpperCase()} [${issue.rule}] ${issue.message}` + (rel?.length ? ` (related: ${rel.join(", ")})` : "") + (issue.ignored ? " (ignored via data-ooo-ignore)" : "");
+      }).join("\n");
+      return `${pos}${violation.selector}
+${issues}`;
+    }).join("\n\n");
+  }
+
+  // src/inject.ts
+  globalThis.__ooo = { audit };
+})();
+/*! Bundled license information:
+
+tabbable/dist/index.esm.js:
+  (*!
+  * tabbable 6.5.0
+  * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+  *)
+*/