@out-of-order/cli 0.1.0

package/dist/inject-overlay.global.js

@@ -0,0 +1,3686 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __typeError = (msg) => {
+    throw TypeError(msg);
+  };
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+  var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+  // ../../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-description.mjs
+  function _typeof2(o) {
+    "@babel/helpers - typeof";
+    return _typeof2 = "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;
+    }, _typeof2(o);
+  }
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function(r2) {
+        return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+        _defineProperty2(e, r2, t[r2]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+        Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+      });
+    }
+    return e;
+  }
+  function _defineProperty2(obj, key, value) {
+    key = _toPropertyKey2(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _toPropertyKey2(t) {
+    var i = _toPrimitive2(t, "string");
+    return "symbol" == _typeof2(i) ? i : i + "";
+  }
+  function _toPrimitive2(t, r) {
+    if ("object" != _typeof2(t) || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != _typeof2(i)) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  function computeAccessibleDescription(root) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var description = queryIdRefs(root, "aria-describedby").map(function(element) {
+      return computeTextAlternative(element, _objectSpread(_objectSpread({}, options), {}, {
+        compute: "description"
+      }));
+    }).join(" ");
+    if (description === "") {
+      var ariaDescription = root.getAttribute("aria-description");
+      description = ariaDescription === null ? "" : ariaDescription;
+    }
+    if (description === "") {
+      var title = root.getAttribute("title");
+      description = title === null ? "" : title;
+    }
+    return description;
+  }
+
+  // ../../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");
+  }
+
+  // ../trace/src/styles.ts
+  var RING_CSS = `
+.ooo-ring { outline: 1px dashed rgba(47, 106, 71, 0.5); outline-offset: 2px; }
+.ooo-ring--warn { outline: 1.5px dashed rgba(154, 125, 26, 0.8); outline-offset: 2px; }
+.ooo-ring--bad { outline: 1.5px solid rgba(160, 31, 23, 0.74); outline-offset: 2px; }
+.ooo-ring:focus-visible, .ooo-ring--warn:focus-visible, .ooo-ring--bad:focus-visible { outline: revert; }
+`;
+  var OVERLAY_CSS = `
+/* The overlay's own palette + mono voice, defined once on the root layer so every
+   badge/panel/tooltip inside inherits it. Kept local (not the demo's vars) because
+   the overlay mounts on arbitrary pages whose :root it can't reach. */
+.ooo-layer { position: fixed; inset: 0; pointer-events: none; z-index: 2147483646;
+  --ooo-mono: "IBM Plex Mono", ui-monospace, SFMono-Regular, Menlo, monospace;
+  --ooo-ink: #18191c; --ooo-ink-2: #34352d; --ooo-muted: #74756d; --ooo-muted-2: #8a8b80;
+  --ooo-line: #dcd9cd; --ooo-line-2: #c6c2b4; --ooo-surface: #fffefb; --ooo-btn: #ecebe4;
+  --ooo-accent: #1f4e79; --ooo-ok: #2f6a47; --ooo-ok-strong: #1f7a44;
+  --ooo-warn: #9a7d1a; --ooo-bad: #a01f17; }
+.ooo-svg { position: absolute; top: 0; left: 0; overflow: visible; }
+.ooo-seg { fill: none; stroke: var(--ooo-ok); stroke-width: 2; opacity: 0.92;
+  stroke-linecap: round; stroke-linejoin: round; stroke-dasharray: 7 6; }
+.ooo-seg--back { stroke: var(--ooo-bad); stroke-width: 2.25; }
+.ooo-hit { fill: none; stroke: transparent; stroke-width: 18; pointer-events: none; cursor: help; }
+/* Only backward (red) hops are hoverable; forward (green) hops stay click-through. */
+.ooo-hit--back { pointer-events: stroke; }
+${RING_CSS}
+/* Badges read hollow by default (white fill, coloured outline and number), then
+   fill in solid while their element is keyboard-focused, so the badge doubles as
+   a "you are here" cursor that moves as you Tab. */
+/* Every badge is hoverable (auto) so its tooltip opens on hover (the layer itself
+   is pointer-events:none). The badge is a small disc at the element's centre, so
+   it only intercepts clicks dead-centre. */
+.ooo-badge { pointer-events: auto; cursor: help; color: var(--ooo-ok); }
+/* "Peek": turn the overlay click-through (badges + backward hit-lines stop
+   intercepting) and fade the drawing back, so the page beneath stays usable. Scoped
+   to .ooo-svg so the control panel, which reports the state, stays legible. */
+.ooo-layer[data-ooo-peek="on"] .ooo-svg { opacity: 0.25; }
+.ooo-layer[data-ooo-peek="on"] .ooo-badge,
+.ooo-layer[data-ooo-peek="on"] .ooo-hit--back { pointer-events: none; }
+
+/* "Overlay" off hides the drawing + hit-lines but leaves the panel (the way back)
+   in place; the renderer hides the on-page rings separately. */
+.ooo-layer.ooo-hidden .ooo-svg { display: none; }
+
+/* Control panel: a fixed-width card pinned to a corner, styled to match the demo
+   chrome. It holds two identical on/off switches (overlay + click-through). Palette
+   inlined: the overlay mounts on arbitrary pages and can't reach the demo's vars. */
+.ooo-panel, .ooo-panel * { box-sizing: border-box; }
+.ooo-panel { position: fixed; left: 12px; bottom: 12px; z-index: 1;
+  width: 188px; pointer-events: auto; margin: 0; padding: 10px;
+  display: flex; flex-direction: column; gap: 9px;
+  background: #f5f4ef; border: 1px solid var(--ooo-line-2); border-radius: 3px;
+  box-shadow: 0 10px 30px -12px rgba(24, 25, 28, 0.32), 0 1px 2px rgba(24, 25, 28, 0.08);
+  font: 500 12px/1 var(--ooo-mono); }
+/* Title doubles as the collapse toggle: full-width button, +/- sign on the right
+   tells which way it folds. Reset the UA button look back to the card's type. */
+.ooo-panel-title { display: flex; align-items: center; width: 100%; margin: 0;
+  padding: 0 0 9px; border: 0; border-bottom: 1px solid var(--ooo-line); background: none;
+  font: 600 13px/1 inherit; color: var(--ooo-ink); letter-spacing: 0.01em;
+  text-align: left; cursor: pointer; }
+.ooo-panel-title::after { content: "\\2212"; margin-left: auto; padding-left: 12px;
+  color: var(--ooo-muted); font-size: 14px; }
+.ooo-panel-title:hover { color: #000; }
+.ooo-panel-title:hover::after { color: var(--ooo-ink); }
+.ooo-panel-body { display: flex; flex-direction: column; gap: 9px; }
+/* Collapsed: fold the body away, leave the bare title bar (no divider, +/- flips). */
+.ooo-panel[data-open="0"] .ooo-panel-title { padding-bottom: 0; border-bottom: 0; }
+.ooo-panel[data-open="0"] .ooo-panel-title::after { content: "+"; }
+.ooo-panel[data-open="0"] .ooo-panel-body { display: none; }
+.ooo-row { display: flex; align-items: center; justify-content: space-between; gap: 10px; }
+.ooo-row-label { color: var(--ooo-ink-2); }
+/* Toggle switch: a pill track with a sliding knob; accent track + knob right when on. */
+.ooo-switch { flex: none; position: relative; width: 32px; height: 18px; margin: 0; padding: 0;
+  border: 1px solid var(--ooo-line-2); border-radius: 999px; background: #e7e4da; cursor: pointer;
+  transition: background 0.14s ease, border-color 0.14s ease; }
+.ooo-switch-knob { position: absolute; top: 1px; left: 1px; width: 14px; height: 14px;
+  border-radius: 50%; background: var(--ooo-surface); box-shadow: 0 1px 2px rgba(24, 25, 28, 0.3);
+  transition: transform 0.14s ease; }
+.ooo-switch--on { background: var(--ooo-accent); border-color: var(--ooo-accent); }
+.ooo-switch--on .ooo-switch-knob { transform: translateX(14px); }
+.ooo-switch:disabled { cursor: default; opacity: 0.4; }
+.ooo-panel-hint { margin: 1px 0 0; color: var(--ooo-muted); font-size: 10.5px; letter-spacing: 0.01em; }
+/* Copy findings: a split button. The main face copies in the current format; the
+   caret to its right opens a menu to switch it, GitHub-merge-button style. */
+.ooo-copy-split { position: relative; display: flex; }
+.ooo-copy { flex: 1 1 auto; min-width: 0; margin: 0; padding: 6px 8px;
+  border: 1px solid var(--ooo-line-2); border-radius: 3px 0 0 3px; background: var(--ooo-btn); color: var(--ooo-ink-2);
+  font: 600 11px/1 var(--ooo-mono);
+  letter-spacing: 0.02em; cursor: pointer;
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  transition: background 0.14s ease, border-color 0.14s ease, color 0.14s ease; }
+.ooo-copy-caret { flex: none; width: 26px; margin-left: -1px; padding: 0;
+  border: 1px solid var(--ooo-line-2); border-radius: 0 3px 3px 0; background: var(--ooo-btn); color: var(--ooo-ink-2);
+  font: 600 11px/1 var(--ooo-mono); cursor: pointer;
+  transition: background 0.14s ease, border-color 0.14s ease, color 0.14s ease; }
+/* Raise whichever half is hovered so its border draws over the shared seam. */
+.ooo-copy:hover, .ooo-copy-caret:hover { position: relative; z-index: 1;
+  background: #e2e0d6; border-color: #b7b3a4; color: var(--ooo-ink); }
+.ooo-copy-menu { position: absolute; left: 0; right: 0; bottom: 100%; margin-bottom: 5px;
+  display: flex; flex-direction: column; padding: 3px; z-index: 2;
+  background: var(--ooo-surface); border: 1px solid var(--ooo-line-2); border-radius: 3px;
+  box-shadow: 0 10px 30px -12px rgba(24, 25, 28, 0.4), 0 1px 2px rgba(24, 25, 28, 0.08); }
+.ooo-copy-menu[hidden] { display: none; }
+.ooo-copy-item { display: flex; align-items: center; width: 100%; margin: 0;
+  padding: 5px 7px; border: 0; border-radius: 2px; background: none; color: var(--ooo-ink-2);
+  letter-spacing: 0.02em; text-align: left; cursor: pointer;
+  font: 500 11px/1 var(--ooo-mono); }
+.ooo-copy-item:hover { background: var(--ooo-btn); color: var(--ooo-ink); }
+.ooo-copy-item::before { content: "\\2713"; width: 13px; color: var(--ooo-accent); visibility: hidden; }
+.ooo-copy-item--on { color: var(--ooo-ink); }
+.ooo-copy-item--on::before { visibility: visible; }
+.ooo-badge circle { fill: var(--ooo-surface); stroke: currentColor; stroke-width: 1.5;
+  transform-box: fill-box; transform-origin: center; }
+.ooo-badge text { fill: currentColor;
+  font: 500 11px var(--ooo-mono); }
+.ooo-badge--warn { color: var(--ooo-warn); }
+.ooo-badge--bad { color: var(--ooo-bad); }
+.ooo-badge--off text { font-size: 12px; }
+.ooo-badge--on circle { fill: currentColor; }
+.ooo-badge--on text { fill: var(--ooo-surface); }
+
+/* Autofocus indicator */
+.ooo-af circle { fill: var(--ooo-accent); stroke: var(--ooo-surface); stroke-width: 1.5; }
+.ooo-af path { fill: var(--ooo-surface); }
+
+.ooo-tip-cursor { position: fixed; top: 0; left: 0; width: 0; height: 0; pointer-events: none; anchor-name: --ooo-tip-anchor; }
+
+
+.ooo-tip { position: fixed; position-anchor: --ooo-tip-anchor;
+  inset: auto; top: anchor(center); left: anchor(center); margin: 19px 0 0 -11px;
+  position-try-fallbacks: flip-block, flip-inline, flip-block flip-inline;
+  pointer-events: auto; 
+  background-color: var(--ooo-surface);
+  background-image: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' width='140' height='140'><filter id='g'><feTurbulence type='fractalNoise' baseFrequency='0.85' numOctaves='2' stitchTiles='stitch'/><feColorMatrix type='matrix' values='0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.03 0'/></filter><rect width='100%25' height='100%25' filter='url(%23g)'/></svg>");
+  color: var(--ooo-ink); border: 1px solid var(--ooo-line-2); border-radius: 2px;
+  font: 13px/1.55 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  box-shadow: 0 18px 48px -14px rgba(24,25,28,0.34), 0 2px 5px rgba(24,25,28,0.08); }
+
+.ooo-tip-head { display: flex; align-items: center; gap: 10px; padding: 9px 12px; }
+.ooo-tip-idx { flex: none; align-self: stretch; display: flex; align-items: center;
+  padding-right: 10px; border-right: 1px solid var(--ooo-line);
+  font: 500 14px/1 var(--ooo-mono);
+  letter-spacing: -0.01em; color: var(--ooo-accent); }
+.ooo-tip-idx--off { color: var(--ooo-warn); font-size: 15px; }
+.ooo-tip-sel { min-width: 0; font: 12px/1.45 var(--ooo-mono);
+  color: var(--ooo-ink-2); word-break: break-word; }
+
+.ooo-tip-fields { margin: 0; padding: 8px 12px; border-top: 1px solid var(--ooo-line);
+  display: grid; grid-template-columns: auto 1fr; gap: 4px 14px; align-items: baseline; }
+.ooo-tip-fields dt { margin: 0;
+  font: 600 9.5px/1.5 var(--ooo-mono);
+  letter-spacing: 0.07em; text-transform: uppercase; color: var(--ooo-muted-2); }
+.ooo-tip-fields dd { margin: 0; min-width: 0; color: var(--ooo-ink-2); font-size: 12.5px; word-break: break-word; }
+.ooo-tip-mono { font-family: var(--ooo-mono);
+  font-size: 11.5px; color: var(--ooo-ink); }
+.ooo-tip-dim { color: #b0b1a6; }
+
+.ooo-tip-body { padding: 9px 12px; border-top: 1px solid var(--ooo-line); }
+.ooo-tip-list { margin: 0; padding: 0; list-style: none; display: flex; flex-direction: column; gap: 9px; }
+.ooo-tip-item { display: block; }
+.ooo-tip-rule { display: flex; align-items: center; gap: 5px; width: fit-content; margin-bottom: 3px;
+  font: 600 10px/1.4 var(--ooo-mono);
+  letter-spacing: 0.06em; text-transform: uppercase; color: var(--ooo-bad); text-decoration: none; }
+.ooo-tip-rule--warn { color: var(--ooo-warn); }
+a.ooo-tip-rule:hover > span { text-decoration: underline; text-underline-offset: 2px; }
+.ooo-tip-rule-ic { flex: none; opacity: 0.55; }
+a.ooo-tip-rule:hover .ooo-tip-rule-ic { opacity: 1; }
+.ooo-tip-msg { display: block; margin: 0; color: var(--ooo-ink-2); font-size: 12.5px; }
+.ooo-tip-ok { margin: 0; color: var(--ooo-ok-strong); font-size: 12.5px; }
+.ooo-tip-item--ignored { opacity: 0.7; }
+.ooo-tip-item--ignored .ooo-tip-rule { color: var(--ooo-muted-2); }
+.ooo-tip-ignored { display: block; margin-top: 4px; color: var(--ooo-muted); font-size: 11.5px; }
+.ooo-tip-ignored code { font-family: var(--ooo-mono);
+  font-size: 11px; }
+
+/* hop tooltips reuse the frame without the index column */
+.ooo-tip-flag { flex: none;
+  font: 600 10px/1.4 var(--ooo-mono);
+  letter-spacing: 0.06em; text-transform: uppercase; color: var(--ooo-ok-strong); }
+.ooo-tip-flag--back { color: var(--ooo-bad); }
+.ooo-tip-hop { font: 500 13px/1 var(--ooo-mono);
+  color: var(--ooo-ink); }
+
+
+/* Advance by exactly one dash period (7 + 6 = 13) per cycle so the marching dashes
+   loop seamlessly. Must stay in sync with .ooo-seg's stroke-dasharray. */
+@keyframes ooo-flow { to { stroke-dashoffset: -13; } }
+@keyframes ooo-cast {
+  0% { transform: scale(1); }
+  35% { transform: scale(1.18); }
+  100% { transform: scale(1); }
+}
+.ooo-layer[data-ooo-motion="play"] .ooo-seg { animation: ooo-flow 1.1s linear infinite; marker-mid: none; }
+.ooo-layer[data-ooo-motion="play"] .ooo-seg--back { animation-duration: 0.8s; }
+.ooo-layer[data-ooo-motion="play"] .ooo-badge--on circle { animation: ooo-cast 0.4s ease-out; }
+`;
+  var overlaySheet = new CSSStyleSheet();
+  overlaySheet.replaceSync(OVERLAY_CSS);
+  var ringSheet = new CSSStyleSheet();
+  ringSheet.replaceSync(RING_CSS);
+  function adopt(root, sheet) {
+    if (root.adoptedStyleSheets.includes(sheet)) {
+      return;
+    }
+    root.adoptedStyleSheets = [...root.adoptedStyleSheets, sheet];
+  }
+  function ensureStyles() {
+    adopt(document, overlaySheet);
+  }
+  function ensureRingStyles(root) {
+    adopt(root, ringSheet);
+  }
+
+  // ../trace/src/tooltip.ts
+  function resolver(tip) {
+    let html = null;
+    return () => html ?? (html = tip());
+  }
+  var _Tooltip = class _Tooltip {
+    constructor(parent) {
+      this.hideTimer = null;
+      this.cursor = document.createElement("div");
+      this.cursor.className = "ooo-tip-cursor";
+      parent.appendChild(this.cursor);
+      this.element = document.createElement("div");
+      this.element.className = "ooo-tip";
+      this.element.setAttribute("popover", "manual");
+      parent.appendChild(this.element);
+      this.element.addEventListener("mouseenter", () => this.cancelHide());
+      this.element.addEventListener("mouseleave", () => this.scheduleHide());
+    }
+    /** Wire a hover target (badge or hop line) so its tooltip pops where the pointer
+        meets it. Badges sit right under the pointer and a long backward hop's
+        endpoints can sit far from where you hover, so the pointer suits both. */
+    wire(target, tip) {
+      const html = resolver(tip);
+      target.addEventListener("mouseenter", (event) => this.show(html(), event));
+      target.addEventListener("mouseleave", () => this.scheduleHide());
+    }
+    show(html, event) {
+      this.cancelHide();
+      this.cursor.style.left = `${event.clientX}px`;
+      this.cursor.style.top = `${event.clientY}px`;
+      this.element.innerHTML = html;
+      if (!this.element.matches(":popover-open")) {
+        this.element.showPopover();
+      }
+    }
+    scheduleHide() {
+      this.cancelHide();
+      this.hideTimer = setTimeout(() => this.hide(), _Tooltip.HIDE_DELAY);
+    }
+    cancelHide() {
+      if (this.hideTimer !== null) {
+        clearTimeout(this.hideTimer);
+        this.hideTimer = null;
+      }
+    }
+    hide() {
+      this.cancelHide();
+      if (this.element.matches(":popover-open")) {
+        this.element.hidePopover();
+      }
+    }
+    destroy() {
+      this.hide();
+      this.element.remove();
+      this.cursor.remove();
+    }
+  };
+  // Grace period for the cursor to travel from the target into the tooltip.
+  _Tooltip.HIDE_DELAY = 150;
+  var Tooltip = _Tooltip;
+
+  // ../trace/src/render.ts
+  var RING_CLASS = `${OVERLAY_CLASS_PREFIX}ring`;
+  var RING_BAD_CLASS = `${RING_CLASS}--bad`;
+  var RING_WARN_CLASS = `${RING_CLASS}--warn`;
+  var RING_CLASSES = [RING_CLASS, RING_WARN_CLASS, RING_BAD_CLASS];
+  var SVG_NS = "http://www.w3.org/2000/svg";
+  var RADIUS = 11;
+  var SEG_PAD = RADIUS + 5;
+  var SMALL_SIZE = 30;
+  function svgEl(tag, attrs = {}, ...kids) {
+    const node = document.createElementNS(SVG_NS, tag);
+    for (const attrName in attrs) {
+      node.setAttribute(attrName, String(attrs[attrName]));
+    }
+    node.append(...kids);
+    return node;
+  }
+  var Renderer = class {
+    constructor(layer, tooltip) {
+      this.layer = layer;
+      this.tooltip = tooltip;
+      this.svg = null;
+      this.markers = [];
+      this.segments = [];
+      this.byEl = /* @__PURE__ */ new Map();
+      // Elements we've ringed, with the class applied, kept so we can untag them on
+      // rebuild/destroy and toggle them when the overlay is hidden.
+      this.ringEls = [];
+      // The rings live on the page, not in the hideable layer, so their visibility is
+      // tracked here and applied by class — otherwise "Hide overlay" leaves them behind.
+      this.ringsVisible = true;
+      // The badge of the currently keyboard-focused element, filled in as a cursor.
+      this.focused = null;
+      // Last SVG size written; reset in clear() since each draw makes a fresh svg.
+      this.sizeW = 0;
+      this.sizeH = 0;
+    }
+    draw(stops, segs, offStops) {
+      this.clear();
+      const svg = svgEl("svg", { class: "ooo-svg" }, buildDefs());
+      const segLayer = svgEl("g");
+      svg.appendChild(segLayer);
+      this.svg = svg;
+      stops.forEach((stop) => this.addMarker(stop));
+      for (let idx = 0; idx < this.markers.length - 1; idx++) {
+        const from = this.markers[idx];
+        const toMarker = this.markers[idx + 1];
+        const { back, tip } = segs[idx];
+        const hit = svgEl("line", {
+          class: back ? "ooo-hit ooo-hit--back" : "ooo-hit"
+        });
+        const line = svgEl("polyline", {
+          class: back ? "ooo-seg ooo-seg--back" : "ooo-seg",
+          "marker-mid": back ? "url(#ooo-arrow-back)" : "url(#ooo-arrow)"
+        });
+        segLayer.append(hit, line);
+        this.segments.push({ from, toMarker, line, hit, back });
+        if (back) {
+          this.tooltip.wire(hit, tip);
+        }
+      }
+      offStops.forEach((stop) => this.addMarker(stop));
+      this.layer.appendChild(svg);
+    }
+    /** One getBoundingClientRect pass to set geometry (initial + scroll frames).
+        All rect reads run before any SVG writes, so a scroll frame triggers a
+        single layout flush instead of one reflow per marker (read→write→read…). */
+    seed() {
+      const rects = this.markers.map((marker) => marker.element.getBoundingClientRect());
+      this.syncSize();
+      this.markers.forEach((marker, idx) => this.applyRect(marker, rects[idx]));
+      this.updateSegments();
+    }
+    applyMoved(moved) {
+      this.syncSize();
+      for (const { target, rect } of moved) {
+        const marker = this.byEl.get(target);
+        if (!marker) {
+          continue;
+        }
+        this.applyRect(marker, rect);
+      }
+      this.updateSegments();
+    }
+    setFocused(element) {
+      const marker = element ? this.byEl.get(element) ?? null : null;
+      if (this.focused === marker) {
+        return;
+      }
+      this.focused?.group.classList.remove("ooo-badge--on");
+      this.focused = marker;
+      this.focused?.group.classList.add("ooo-badge--on");
+    }
+    elementsToObserve() {
+      return this.markers.map((marker) => marker.element);
+    }
+    /** Toggle the page-element rings with the overlay's visibility. They sit on the
+        page rather than inside the hideable layer, so hiding the layer alone leaves
+        them; this drives them by class and survives a rebuild (see markRing). */
+    setRingsVisible(visible) {
+      if (this.ringsVisible === visible) {
+        return;
+      }
+      this.ringsVisible = visible;
+      for (const { element, cls } of this.ringEls) {
+        element.classList.toggle(cls, visible);
+      }
+    }
+    clear() {
+      this.svg?.remove();
+      this.svg = null;
+      this.markers = [];
+      this.segments = [];
+      this.byEl.clear();
+      this.focused = null;
+      this.sizeW = 0;
+      this.sizeH = 0;
+      for (const { element } of this.ringEls) {
+        element.classList.remove(...RING_CLASSES);
+      }
+      this.ringEls = [];
+    }
+    addMarker(spec) {
+      this.markRing(spec.element, spec.severity);
+      let cls = "ooo-badge";
+      if (spec.severity) {
+        cls += spec.severity === "error" ? " ooo-badge--bad" : " ooo-badge--warn";
+      }
+      if (!spec.inSeq) {
+        cls += " ooo-badge--off";
+      }
+      const circle = svgEl("circle", { r: RADIUS });
+      const text = svgEl("text", { "text-anchor": "middle", y: 4 });
+      text.textContent = spec.label;
+      const group = svgEl("g", { class: cls }, circle, text);
+      if (spec.autofocus) {
+        group.appendChild(
+          svgEl(
+            "g",
+            { class: "ooo-af", transform: `translate(${RADIUS}, ${-RADIUS})` },
+            svgEl("circle", { r: 7 }),
+            svgEl("path", { d: "M-3,-2 L3,-2 L0,2.5 Z" })
+          )
+        );
+      }
+      this.svg.appendChild(group);
+      const marker = {
+        element: spec.element,
+        group,
+        centerX: 0,
+        centerY: 0
+      };
+      this.markers.push(marker);
+      this.byEl.set(spec.element, marker);
+      this.tooltip.wire(group, spec.tip);
+    }
+    markRing(element, severity) {
+      const ringClass = severity === "error" ? RING_BAD_CLASS : severity === "warning" ? RING_WARN_CLASS : RING_CLASS;
+      if (this.ringsVisible) {
+        element.classList.add(ringClass);
+      }
+      this.ringEls.push({ element, cls: ringClass });
+      const root = element.getRootNode();
+      if (root instanceof ShadowRoot) {
+        ensureRingStyles(root);
+      }
+    }
+    applyRect(marker, rect) {
+      if (rect.width < SMALL_SIZE && rect.height < SMALL_SIZE) {
+        marker.centerX = rect.right + RADIUS;
+        marker.centerY = rect.top - RADIUS;
+      } else {
+        marker.centerX = rect.left + rect.width / 2;
+        marker.centerY = rect.top + rect.height / 2;
+      }
+      marker.group.setAttribute("transform", `translate(${marker.centerX}, ${marker.centerY})`);
+    }
+    /** Redraw every hop: shorten it to the badge edges and drop the arrow at the
+        midpoint. Colour (green forward / red backward) is fixed at analyze time
+        (see Segment.back) and not recomputed here, so it can't drift from the ring. */
+    updateSegments() {
+      for (const seg of this.segments) {
+        const deltaX = seg.toMarker.centerX - seg.from.centerX;
+        const deltaY = seg.toMarker.centerY - seg.from.centerY;
+        const len = Math.hypot(deltaX, deltaY) || 1;
+        const unitX = deltaX / len;
+        const unitY = deltaY / len;
+        let startX = seg.from.centerX;
+        let startY = seg.from.centerY;
+        let endX = seg.toMarker.centerX;
+        let endY = seg.toMarker.centerY;
+        if (len > 2 * SEG_PAD + 6) {
+          startX = seg.from.centerX + unitX * SEG_PAD;
+          startY = seg.from.centerY + unitY * SEG_PAD;
+          endX = seg.toMarker.centerX - unitX * SEG_PAD;
+          endY = seg.toMarker.centerY - unitY * SEG_PAD;
+        }
+        const midX = (startX + endX) / 2;
+        const midY = (startY + endY) / 2;
+        seg.hit.setAttribute("x1", String(startX));
+        seg.hit.setAttribute("y1", String(startY));
+        seg.hit.setAttribute("x2", String(endX));
+        seg.hit.setAttribute("y2", String(endY));
+        seg.line.setAttribute("points", `${startX},${startY} ${midX},${midY} ${endX},${endY}`);
+      }
+    }
+    syncSize() {
+      if (!this.svg) {
+        return;
+      }
+      const width = document.documentElement.clientWidth;
+      const height = document.documentElement.clientHeight;
+      if (width === this.sizeW && height === this.sizeH) {
+        return;
+      }
+      this.sizeW = width;
+      this.sizeH = height;
+      this.svg.setAttribute("width", String(width));
+      this.svg.setAttribute("height", String(height));
+    }
+  };
+  function buildDefs() {
+    const defs = svgEl("defs");
+    for (const [markerId, fill] of [
+      ["ooo-arrow", "#2f6a47"],
+      ["ooo-arrow-back", "#b3261e"]
+    ]) {
+      const path = svgEl("path", { d: "M3,2.5 L14,8 L3,13.5 L6.5,8 Z", fill });
+      const marker = svgEl(
+        "marker",
+        {
+          id: markerId,
+          markerWidth: 16,
+          markerHeight: 16,
+          refX: 8,
+          refY: 8,
+          orient: "auto",
+          markerUnits: "userSpaceOnUse"
+        },
+        path
+      );
+      defs.appendChild(marker);
+    }
+    return defs;
+  }
+
+  // ../../node_modules/.pnpm/position-observer@1.0.3/node_modules/position-observer/dist/index.js
+  var Rect = class {
+    /**
+     * Intersects two DOMRects.
+     *
+     * @param rect1 - The first DOMRect.
+     * @param rect2 - The second DOMRect.
+     * @returns The intersection of the two DOMRects.
+     */
+    static intersect(rect1, rect2) {
+      const left = Math.max(rect1.left, rect2.left);
+      const right = Math.min(rect1.right, rect2.right);
+      const top = Math.max(rect1.top, rect2.top);
+      const bottom = Math.min(rect1.bottom, rect2.bottom);
+      const width = Math.max(0, right - left);
+      const height = Math.max(0, bottom - top);
+      return new DOMRect(left, top, width, height);
+    }
+    /**
+     * Clips a DOMRect to a given rectangle.
+     *
+     * @param rect - The DOMRect to clip.
+     * @param clip - The rectangle to clip the DOMRect to.
+     * @returns The clipped DOMRect.
+     */
+    static clip(rect, clip) {
+      const updatedRect = {
+        ...rect.toJSON(),
+        top: rect.top + clip.top,
+        left: rect.left + clip.left,
+        bottom: rect.bottom - clip.bottom,
+        right: rect.right - clip.right
+      };
+      updatedRect.width = updatedRect.right - updatedRect.left;
+      updatedRect.height = updatedRect.bottom - updatedRect.top;
+      return new DOMRect(
+        updatedRect.left,
+        updatedRect.top,
+        updatedRect.width,
+        updatedRect.height
+      );
+    }
+    /**
+     * Calculates the offsets of a clipped DOMRect.
+     *
+     * @param rect - The DOMRect to calculate the offsets for.
+     * @param clippedRect - The clipped DOMRect.
+     * @returns The offsets of the clipped DOMRect.
+     */
+    static clipOffsets(rect, clippedRect) {
+      return {
+        top: clippedRect.top - rect.top,
+        left: clippedRect.left - rect.left,
+        bottom: rect.bottom - clippedRect.bottom,
+        right: rect.right - clippedRect.right
+      };
+    }
+    /**
+     * Checks if two DOMRects are equal.
+     *
+     * @param rect1 - The first DOMRect.
+     * @param rect2 - The second DOMRect.
+     * @returns True if the DOMRects are equal, false otherwise.
+     */
+    static equals(rect1, rect2) {
+      if (rect1 == null || rect2 == null) return rect1 === rect2;
+      return rect1.x === rect2.x && rect1.y === rect2.y && rect1.width === rect2.width && rect1.height === rect2.height;
+    }
+    static sizeEqual(rect1, rect2) {
+      return Math.round(rect1.width) === Math.round(rect2.width) && Math.round(rect1.height) === Math.round(rect2.height);
+    }
+  };
+  var INSET = -1;
+  var MIN_SIZE = 1 - INSET * 2;
+  function rootMargin(rect, rootBounds) {
+    const width = Math.max(rect.width, MIN_SIZE);
+    const height = Math.max(rect.height, MIN_SIZE);
+    const top = rect.top - rootBounds.top - INSET;
+    const left = rect.left - rootBounds.left - INSET;
+    const right = rootBounds.right - rect.left - width - INSET;
+    const bottom = rootBounds.bottom - rect.top - height - INSET;
+    return `${-Math.round(top)}px ${-Math.round(right)}px ${-Math.round(bottom)}px ${-Math.round(left)}px`;
+  }
+  var threshold = [
+    ...Array.from({ length: 1e3 }, (_, i) => i / 1e3),
+    1
+  ];
+  var _callback, _observer, _options, _clientRect, _previousIntersectionRatio, _PositionIntersectionObserver_instances, observe_fn, _onIntersection, _a;
+  var PositionIntersectionObserver = (_a = class {
+    constructor(element, callback, options) {
+      __privateAdd(this, _PositionIntersectionObserver_instances);
+      __privateAdd(this, _callback);
+      __privateAdd(this, _observer);
+      __privateAdd(this, _options);
+      __privateAdd(this, _clientRect);
+      __privateAdd(this, _previousIntersectionRatio);
+      /**
+       * The callback function for the intersection observer.
+       */
+      __privateAdd(this, _onIntersection, (entries) => {
+        if (!__privateGet(this, _observer)) return;
+        const entry = entries[entries.length - 1];
+        if (entry) {
+          const { intersectionRatio, boundingClientRect } = entry;
+          const previousClientRect = __privateGet(this, _clientRect);
+          __privateSet(this, _clientRect, boundingClientRect);
+          const previousIntersectionRatio = __privateGet(this, _previousIntersectionRatio);
+          const clientRectChanged = !Rect.equals(
+            boundingClientRect,
+            previousClientRect
+          );
+          if (intersectionRatio !== __privateGet(this, _previousIntersectionRatio) || clientRectChanged) {
+            const rootBounds = __privateGet(this, _options).rootBounds;
+            const rootIntersection = Rect.intersect(boundingClientRect, rootBounds);
+            const isIntersecting = rootIntersection.width > 0 && rootIntersection.height > 0;
+            if (!isIntersecting) {
+              return;
+            }
+            __privateSet(this, _previousIntersectionRatio, intersectionRatio);
+            if (previousIntersectionRatio != null || clientRectChanged) {
+              __privateGet(this, _callback).call(this, new PositionIntersectionObserverEntry(
+                entry.target,
+                boundingClientRect,
+                entry.intersectionRect,
+                isIntersecting,
+                rootBounds
+              ), this);
+              __privateMethod(this, _PositionIntersectionObserver_instances, observe_fn).call(this, entry.target);
+            }
+          }
+        }
+      });
+      __privateSet(this, _callback, callback);
+      __privateSet(this, _options, options);
+      __privateSet(this, _clientRect, options.clientRect);
+      __privateMethod(this, _PositionIntersectionObserver_instances, observe_fn).call(this, element);
+    }
+    /**
+     * The visible rectangle of the element within the root.
+     *
+     * @returns The visible rectangle of the element within the root.
+     */
+    get visibleRect() {
+      const clip = __privateGet(this, _options).clip;
+      return clip ? Rect.clip(__privateGet(this, _clientRect), clip) : __privateGet(this, _clientRect);
+    }
+    /**
+     * Whether the element is intersecting with the root.
+     *
+     * @returns Whether the element is intersecting with the root.
+     */
+    get isIntersecting() {
+      const { width, height } = this.visibleRect;
+      return width > 0 && height > 0;
+    }
+    /**
+     * Disconnects the position intersection observer.
+     */
+    disconnect() {
+      __privateGet(this, _observer)?.disconnect();
+    }
+  }, _callback = new WeakMap(), _observer = new WeakMap(), _options = new WeakMap(), _clientRect = new WeakMap(), _previousIntersectionRatio = new WeakMap(), _PositionIntersectionObserver_instances = new WeakSet(), /**
+   * Observes the element.
+   */
+  observe_fn = function(element) {
+    const { root, rootBounds } = __privateGet(this, _options);
+    const { visibleRect } = this;
+    __privateGet(this, _observer)?.disconnect();
+    __privateSet(this, _observer, new IntersectionObserver(__privateGet(this, _onIntersection), {
+      root,
+      rootMargin: rootMargin(visibleRect, rootBounds),
+      threshold
+    }));
+    __privateGet(this, _observer).observe(element);
+  }, _onIntersection = new WeakMap(), _a);
+  var PositionIntersectionObserverEntry = class {
+    constructor(target, boundingClientRect, intersectionRect, isIntersecting, rootBounds) {
+      this.target = target;
+      this.boundingClientRect = boundingClientRect;
+      this.intersectionRect = intersectionRect;
+      this.isIntersecting = isIntersecting;
+      this.rootBounds = rootBounds;
+    }
+  };
+  var _resizeObserver, _controller, _a2;
+  var RootBoundsObserver = (_a2 = class {
+    /**
+     * Creates a new root bounds observer.
+     *
+     * @param root - The root element to observe.
+     * @param callback - The callback function to call when the root bounds change.
+     */
+    constructor(target, callback) {
+      /**
+       * The resize observer if the root is an element.
+       */
+      __privateAdd(this, _resizeObserver);
+      /**
+       * The controller to disconnect the root bounds resize and scroll listeners.
+       */
+      __privateAdd(this, _controller, new AbortController());
+      /**
+       * The bounds of the root element.
+       */
+      __publicField(this, "rootBounds");
+      const root = getRoot(target);
+      if (isElement2(root)) {
+        const ownerDocument = root.ownerDocument ?? document;
+        this.rootBounds = root.getBoundingClientRect();
+        __privateSet(this, _resizeObserver, new ResizeObserver((entries) => {
+          for (const entry of entries) {
+            const [{ inlineSize: width, blockSize: height }] = entry.borderBoxSize;
+            if (Rect.sizeEqual(this.rootBounds, { width, height })) {
+              continue;
+            }
+            const rect = entry.target.getBoundingClientRect();
+            this.rootBounds = rect;
+            callback(rect, this);
+          }
+        }));
+        __privateGet(this, _resizeObserver).observe(root);
+        ownerDocument.addEventListener(
+          "scroll",
+          (event) => {
+            if (event.target && event.target !== root && isNode(event.target) && event.target.contains(root)) {
+              this.rootBounds = root.getBoundingClientRect();
+              callback(this.rootBounds, this);
+            }
+          },
+          { capture: true, passive: true, signal: __privateGet(this, _controller).signal }
+        );
+      } else {
+        const viewport = root.visualViewport ?? root;
+        this.rootBounds = getWindowRect(root);
+        const handleResize = () => {
+          const rect = getWindowRect(root);
+          if (Rect.equals(this.rootBounds, rect)) return;
+          this.rootBounds = rect;
+          callback(rect, this);
+        };
+        viewport.addEventListener("resize", handleResize, {
+          signal: __privateGet(this, _controller).signal
+        });
+      }
+    }
+    /**
+     * Disconnects the root bounds observer.
+     */
+    disconnect() {
+      __privateGet(this, _resizeObserver)?.disconnect();
+      __privateGet(this, _controller).abort();
+    }
+  }, _resizeObserver = new WeakMap(), _controller = new WeakMap(), _a2);
+  function getWindowRect(window2) {
+    const width = window2.visualViewport?.width ?? window2.innerWidth;
+    const height = window2.visualViewport?.height ?? window2.innerHeight;
+    return new DOMRect(0, 0, width, height);
+  }
+  function isNode(target) {
+    return "nodeType" in target;
+  }
+  function isElement2(target) {
+    return isNode(target) && target.nodeType === Node.ELEMENT_NODE;
+  }
+  function isDocument(root) {
+    return root.nodeType === Node.DOCUMENT_NODE;
+  }
+  function getRoot(target) {
+    return !target || isDocument(target) ? target?.defaultView ?? window : target;
+  }
+  var _callback2, _observers, _options2, _a3;
+  var VisibilityObserver = (_a3 = class {
+    constructor(callback, options) {
+      /**
+       * The callback function to be invoked when the intersection entries change.
+       */
+      __privateAdd(this, _callback2);
+      /**
+       * The visibility observer for each document.
+       */
+      __privateAdd(this, _observers, /* @__PURE__ */ new Map());
+      /**
+       * The options for the visibility observer.
+       */
+      __privateAdd(this, _options2);
+      /**
+       * The latest intersection entries for the observed elements.
+       */
+      __publicField(this, "intersections", /* @__PURE__ */ new WeakMap());
+      __privateSet(this, _options2, options);
+      __privateSet(this, _callback2, (entries) => {
+        const changedEntries = [];
+        for (const entry of entries) {
+          const previousIntersection = this.intersections.get(entry.target);
+          this.intersections.set(entry.target, entry);
+          if (previousIntersection?.isIntersecting !== entry.isIntersecting || !Rect.equals(
+            previousIntersection?.intersectionRect,
+            entry.intersectionRect
+          )) {
+            changedEntries.push(entry);
+          }
+        }
+        if (changedEntries.length > 0) {
+          callback(changedEntries, this);
+        }
+      });
+    }
+    /**
+     * Observes an element.
+     *
+     * @param element - The element to observe.
+     */
+    observe(element) {
+      const document2 = element.ownerDocument;
+      if (!document2) return;
+      let observer = __privateGet(this, _observers).get(document2);
+      if (!observer) {
+        observer = new IntersectionObserver(__privateGet(this, _callback2), {
+          ...__privateGet(this, _options2),
+          threshold
+        });
+        __privateGet(this, _observers).set(document2, observer);
+      }
+      observer.observe(element);
+    }
+    /**
+     * Unobserves an element.
+     *
+     * @param element - The element to unobserve.
+     */
+    unobserve(element) {
+      const document2 = element.ownerDocument;
+      if (!document2) return;
+      const observer = __privateGet(this, _observers).get(document2);
+      if (!observer) return;
+      observer.unobserve(element);
+      this.intersections.delete(element);
+    }
+    /**
+     * Disconnects the visibility observer.
+     */
+    disconnect() {
+      for (const observer of __privateGet(this, _observers).values()) {
+        observer.disconnect();
+      }
+      __privateGet(this, _observers).clear();
+    }
+  }, _callback2 = new WeakMap(), _observers = new WeakMap(), _options2 = new WeakMap(), _a3);
+  var _callback3, _options3, _positionObservers, _resizeObserver2, _positions, _rootBoundsObserver, _visibilityObserver, _PositionObserver_instances, notify_fn, _onRootBoundsChange, observePosition_fn, _onVisibilityChange, _onPositionChange, _onResize, _a4;
+  var PositionObserver = (_a4 = class {
+    constructor(callback, options) {
+      __privateAdd(this, _PositionObserver_instances);
+      /**
+       * The callback function to be invoked when the position changes.
+       */
+      __privateAdd(this, _callback3);
+      /**
+       * The options for the position observer.
+       */
+      __privateAdd(this, _options3);
+      /**
+       * The position observers for the observed elements.
+       */
+      __privateAdd(this, _positionObservers, /* @__PURE__ */ new Map());
+      /**
+       * The resize observer for the observed elements.
+       */
+      __privateAdd(this, _resizeObserver2);
+      /**
+       * The positions of the observed elements.
+       */
+      __privateAdd(this, _positions, /* @__PURE__ */ new WeakMap());
+      /**
+       * The root bounds observer for the observed elements.
+       */
+      __privateAdd(this, _rootBoundsObserver);
+      /**
+       * The visibility observer for the observed elements.
+       */
+      __privateAdd(this, _visibilityObserver);
+      /**
+       * The callback function to be invoked when the root bounds change.
+       */
+      __privateAdd(this, _onRootBoundsChange, (rootBounds) => {
+        const entries = [];
+        for (const [element] of __privateGet(this, _positionObservers)) {
+          const boundingClientRect = element.getBoundingClientRect();
+          const observer = __privateMethod(this, _PositionObserver_instances, observePosition_fn).call(this, element, boundingClientRect);
+          entries.push(
+            new PositionObserverEntry(
+              element,
+              boundingClientRect,
+              observer.visibleRect,
+              observer.isIntersecting,
+              rootBounds
+            )
+          );
+        }
+        __privateMethod(this, _PositionObserver_instances, notify_fn).call(this, entries);
+      });
+      /**
+       * The callback function to be invoked when the visibility changes.
+       */
+      __privateAdd(this, _onVisibilityChange, (entries) => {
+        const records = [];
+        for (const entry of entries) {
+          const { target, isIntersecting, boundingClientRect } = entry;
+          if (isIntersecting) {
+            __privateMethod(this, _PositionObserver_instances, observePosition_fn).call(this, target, boundingClientRect);
+            __privateGet(this, _resizeObserver2).observe(target);
+          } else {
+            __privateGet(this, _positionObservers).get(target)?.disconnect();
+            __privateGet(this, _positionObservers).delete(target);
+            __privateGet(this, _resizeObserver2).unobserve(target);
+          }
+          const observer = __privateGet(this, _positionObservers).get(target);
+          records.push(
+            new PositionObserverEntry(
+              target,
+              boundingClientRect,
+              observer?.visibleRect ?? entry.intersectionRect,
+              isIntersecting,
+              __privateGet(this, _rootBoundsObserver).rootBounds
+            )
+          );
+        }
+        __privateMethod(this, _PositionObserver_instances, notify_fn).call(this, records);
+      });
+      /**
+       * The callback function to be invoked when the position changes.
+       */
+      __privateAdd(this, _onPositionChange, (entry, observer) => {
+        __privateMethod(this, _PositionObserver_instances, notify_fn).call(this, [
+          new PositionObserverEntry(
+            entry.target,
+            entry.boundingClientRect,
+            observer.visibleRect,
+            entry.isIntersecting,
+            __privateGet(this, _rootBoundsObserver).rootBounds
+          )
+        ]);
+      });
+      /**
+       * The callback function to be invoked when the resize observer entries change.
+       */
+      __privateAdd(this, _onResize, (entries) => {
+        const records = [];
+        for (const entry of entries) {
+          const { target, borderBoxSize } = entry;
+          const previous = __privateGet(this, _positions).get(target);
+          if (previous) {
+            const [{ inlineSize: width, blockSize: height }] = borderBoxSize;
+            if (Rect.sizeEqual(previous.boundingClientRect, { width, height })) {
+              continue;
+            }
+          }
+          const boundingClientRect = target.getBoundingClientRect();
+          const observer = __privateMethod(this, _PositionObserver_instances, observePosition_fn).call(this, target, boundingClientRect);
+          records.push(
+            new PositionObserverEntry(
+              target,
+              boundingClientRect,
+              observer.visibleRect,
+              __privateGet(this, _visibilityObserver).intersections.get(target)?.isIntersecting ?? false,
+              __privateGet(this, _rootBoundsObserver).rootBounds
+            )
+          );
+        }
+        __privateMethod(this, _PositionObserver_instances, notify_fn).call(this, records);
+      });
+      __privateSet(this, _callback3, callback);
+      __privateSet(this, _options3, options);
+      __privateSet(this, _rootBoundsObserver, new RootBoundsObserver(
+        options?.root,
+        __privateGet(this, _onRootBoundsChange)
+      ));
+      __privateSet(this, _visibilityObserver, new VisibilityObserver(
+        __privateGet(this, _onVisibilityChange),
+        options
+      ));
+      __privateSet(this, _resizeObserver2, new ResizeObserver(__privateGet(this, _onResize)));
+    }
+    /**
+     * Observes an element.
+     *
+     * @param element - The element to observe.
+     */
+    observe(element) {
+      __privateGet(this, _visibilityObserver).observe(element);
+    }
+    /**
+     * Unobserves an element.
+     *
+     * @param element - The element to unobserve. If not provided, the position observer is disconnected.
+     */
+    unobserve(element) {
+      if (element) {
+        __privateGet(this, _positionObservers).get(element)?.disconnect();
+        __privateGet(this, _visibilityObserver).unobserve(element);
+        __privateGet(this, _positions).delete(element);
+      } else {
+        this.disconnect();
+      }
+    }
+    /**
+     * Disconnects the observer.
+     */
+    disconnect() {
+      for (const positionObserver of __privateGet(this, _positionObservers).values()) {
+        positionObserver.disconnect();
+      }
+      __privateGet(this, _positionObservers).clear();
+      __privateGet(this, _resizeObserver2).disconnect();
+      __privateGet(this, _rootBoundsObserver).disconnect();
+      __privateGet(this, _visibilityObserver).disconnect();
+    }
+  }, _callback3 = new WeakMap(), _options3 = new WeakMap(), _positionObservers = new WeakMap(), _resizeObserver2 = new WeakMap(), _positions = new WeakMap(), _rootBoundsObserver = new WeakMap(), _visibilityObserver = new WeakMap(), _PositionObserver_instances = new WeakSet(), /**
+   * Notifies the position observer of the changes.
+   *
+   * @param entries - The entries to notify.
+   */
+  notify_fn = function(entries) {
+    const records = [];
+    for (const entry of entries) {
+      const { target } = entry;
+      const previousEntry = __privateGet(this, _positions).get(target);
+      if (isEntryEqual(entry, previousEntry)) continue;
+      __privateGet(this, _positions).set(target, entry);
+      records.push(entry);
+    }
+    if (records.length > 0) {
+      __privateGet(this, _callback3).call(this, records);
+    }
+  }, _onRootBoundsChange = new WeakMap(), /**
+   * Observes the position of an element.
+   *
+   * @param element - The element to observe.
+   * @param clientRect - The client rect of the element.
+   */
+  observePosition_fn = function(element, clientRect) {
+    const visibilityObserver = __privateGet(this, _visibilityObserver);
+    __privateGet(this, _positionObservers).get(element)?.disconnect();
+    const positionObserver = new PositionIntersectionObserver(
+      element,
+      __privateGet(this, _onPositionChange),
+      {
+        clientRect,
+        root: __privateGet(this, _options3)?.root,
+        rootBounds: __privateGet(this, _rootBoundsObserver).rootBounds,
+        get clip() {
+          const intersection = visibilityObserver.intersections.get(element);
+          if (!intersection) return;
+          const { intersectionRect, boundingClientRect } = intersection;
+          return Rect.clipOffsets(boundingClientRect, intersectionRect);
+        }
+      }
+    );
+    __privateGet(this, _positionObservers).set(element, positionObserver);
+    return positionObserver;
+  }, _onVisibilityChange = new WeakMap(), _onPositionChange = new WeakMap(), _onResize = new WeakMap(), _a4);
+  var PositionObserverEntry = class {
+    constructor(target, boundingClientRect, intersectionRect, isIntersecting, rootBounds) {
+      this.target = target;
+      this.boundingClientRect = boundingClientRect;
+      this.intersectionRect = intersectionRect;
+      this.isIntersecting = isIntersecting;
+      this.rootBounds = rootBounds;
+    }
+  };
+  function isEntryEqual(first, second) {
+    if (second == null) return false;
+    return first.target === second.target && first.isIntersecting === second.isIntersecting && Rect.equals(first.boundingClientRect, second.boundingClientRect) && Rect.equals(first.intersectionRect, second.intersectionRect);
+  }
+
+  // ../trace/src/track.ts
+  var Tracker = class {
+    constructor(callbacks) {
+      this.callbacks = callbacks;
+      this.buildRaf = 0;
+      this.posRaf = 0;
+      this.scheduleResize = () => {
+        if (this.buildRaf) {
+          return;
+        }
+        this.buildRaf = requestAnimationFrame(() => {
+          this.buildRaf = 0;
+          this.callbacks.onResize();
+        });
+      };
+      this.scheduleScroll = () => {
+        if (this.posRaf) {
+          return;
+        }
+        this.posRaf = requestAnimationFrame(() => {
+          this.posRaf = 0;
+          this.callbacks.onScroll();
+        });
+      };
+      this.onFocusIn = (event) => {
+        const target = event.target;
+        this.callbacks.onFocus(target instanceof Element ? target : null);
+      };
+      this.onFocusOut = () => {
+        this.callbacks.onFocus(null);
+      };
+      this.positionObserver = new PositionObserver(
+        (entries) => callbacks.onMoved(
+          entries.map((entry) => ({ target: entry.target, rect: entry.boundingClientRect }))
+        )
+      );
+    }
+    /** Wire the global listeners. Call once, after the first draw. */
+    listen() {
+      window.addEventListener("resize", this.scheduleResize);
+      window.addEventListener("scroll", this.scheduleScroll, {
+        capture: true,
+        passive: true
+      });
+      document.addEventListener("focusin", this.onFocusIn);
+      document.addEventListener("focusout", this.onFocusOut);
+    }
+    /** Point the position observer at a fresh element set (after a rebuild). */
+    observe(elements) {
+      this.positionObserver.disconnect();
+      for (const element of elements) {
+        this.positionObserver.observe(element);
+      }
+    }
+    destroy() {
+      if (this.buildRaf) {
+        cancelAnimationFrame(this.buildRaf);
+      }
+      if (this.posRaf) {
+        cancelAnimationFrame(this.posRaf);
+      }
+      this.positionObserver.disconnect();
+      window.removeEventListener("resize", this.scheduleResize);
+      window.removeEventListener("scroll", this.scheduleScroll, true);
+      document.removeEventListener("focusin", this.onFocusIn);
+      document.removeEventListener("focusout", this.onFocusOut);
+    }
+  };
+
+  // ../trace/src/mutations.ts
+  var WATCHED_ATTRS = [
+    "tabindex",
+    "role",
+    "disabled",
+    "hidden",
+    "inert",
+    "contenteditable",
+    "style",
+    "class",
+    "aria-hidden",
+    "aria-disabled",
+    "aria-label",
+    "aria-labelledby",
+    "title",
+    "alt",
+    "href",
+    "type",
+    "open"
+    // <details> toggling shows/hides its (focusable) contents
+  ];
+  var Mutations = class {
+    constructor(ignore, onMutated) {
+      this.ignore = ignore;
+      this.onMutated = onMutated;
+      this.raf = 0;
+      this.observer = new MutationObserver((records) => {
+        if (records.every((record) => this.ignore.contains(record.target))) {
+          return;
+        }
+        this.schedule();
+      });
+    }
+    observe(root) {
+      const target = root.nodeType === 9 ? root.documentElement : root;
+      this.observer.observe(target, {
+        subtree: true,
+        childList: true,
+        attributes: true,
+        attributeFilter: WATCHED_ATTRS,
+        characterData: true
+        // text changes affect accessible name
+      });
+    }
+    destroy() {
+      if (this.raf) {
+        cancelAnimationFrame(this.raf);
+      }
+      this.observer.disconnect();
+    }
+    schedule() {
+      if (this.raf) {
+        return;
+      }
+      this.raf = requestAnimationFrame(() => {
+        this.raf = 0;
+        this.observer.takeRecords();
+        this.onMutated();
+      });
+    }
+  };
+
+  // ../trace/src/tip-content.ts
+  function badgeTip(data) {
+    const { num, selector, tabIndex, issues, name, role, description, autofocus, srOnly } = data;
+    const idx = num !== null ? `<span class="ooo-tip-idx">${num}</span>` : `<span class="ooo-tip-idx ooo-tip-idx--off">\u2298</span>`;
+    const fields = field("name", name ? escapeHtml(name) : null) + field("role", role ? mono(escapeHtml(role)) : null) + (description ? field("description", escapeHtml(description)) : "") + (tabIndex && tabIndex !== 0 ? field("tabindex", mono(String(tabIndex))) : "") + (autofocus ? field("autofocus", mono("yes")) : "") + (srOnly ? field("sr-only", mono("yes")) : "");
+    const body = issues.length ? `<ul class="ooo-tip-list">${issues.map(issueItem).join("")}</ul>` : `<p class="ooo-tip-ok">No issues found.</p>`;
+    return `<div class="ooo-tip-head">${idx}<code class="ooo-tip-sel">${escapeHtml(selector)}</code></div><dl class="ooo-tip-fields">${fields}</dl><div class="ooo-tip-body">${body}</div>`;
+  }
+  function issueItem(issue) {
+    const cls = issue.ignored ? "ooo-tip-item ooo-tip-item--ignored" : "ooo-tip-item";
+    const note = issue.ignored ? `<span class="ooo-tip-ignored">Ignored via <code>data-ooo-ignore</code></span>` : "";
+    return `<li class="${cls}">${ruleLabel(issue)}<span class="ooo-tip-msg">${escapeHtml(stripSelectorPrefix(issue.message))}</span>${note}</li>`;
+  }
+  function segTip(back, from, toStop) {
+    const flag = back ? `<span class="ooo-tip-flag ooo-tip-flag--back">\u21A9 reverse</span>` : `<span class="ooo-tip-flag">\u2192 forward</span>`;
+    const message = back ? "Focus moves against the reading order \u2014 up, or right-to-left." : "Forward in reading order.";
+    return `<div class="ooo-tip-head">${flag}<span class="ooo-tip-hop">#${from} \u2192 #${toStop}</span></div><div class="ooo-tip-body"><p class="ooo-tip-msg">${message}</p></div>`;
+  }
+  function field(key, value) {
+    return `<dt>${key}</dt><dd>${value ?? `<span class="ooo-tip-dim">\u2014</span>`}</dd>`;
+  }
+  function mono(html) {
+    return `<span class="ooo-tip-mono">${html}</span>`;
+  }
+  var EXTERNAL_ICON = `<svg class="ooo-tip-rule-ic" viewBox="0 0 24 24" width="11" height="11" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M18 13v5a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V7a1 1 0 0 1 1-1h5"/><path d="M15 4h5v5"/><path d="M20 4l-9 9"/></svg>`;
+  function ruleLabel(issue) {
+    const cls = issue.severity === "warning" ? "ooo-tip-rule ooo-tip-rule--warn" : "ooo-tip-rule";
+    if (!issue.docs) {
+      return `<span class="${cls}">${issue.rule}</span>`;
+    }
+    return `<a class="${cls}" href="${escapeHtml(issue.docs)}" target="_blank" rel="noreferrer" tabindex="-1"><span>${issue.rule}</span>${EXTERNAL_ICON}</a>`;
+  }
+  function stripSelectorPrefix(message) {
+    return message.replace(/^"[^"]*"\s*/, "");
+  }
+  var HTML_ESCAPES = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;"
+  };
+  function escapeHtml(str) {
+    return str.replace(/[&<>"]/g, (char) => HTML_ESCAPES[char] ?? char);
+  }
+
+  // ../trace/src/controls.ts
+  var COPY_FORMATS = [
+    { value: "by-element", label: "By element" },
+    { value: "text", label: "Text" }
+  ];
+  var PEEK_KEY_LABEL = {
+    Alt: "Alt",
+    Control: "Ctrl",
+    Shift: "Shift",
+    Meta: "Meta"
+  };
+  var PANEL_STATE_KEY = "ooo:trace";
+  function loadPanelState() {
+    try {
+      return JSON.parse(sessionStorage.getItem(PANEL_STATE_KEY) ?? "{}");
+    } catch {
+      return {};
+    }
+  }
+  function patchPanelState(patch) {
+    try {
+      sessionStorage.setItem(PANEL_STATE_KEY, JSON.stringify({ ...loadPanelState(), ...patch }));
+    } catch {
+    }
+  }
+  function setupControls(layer, opts) {
+    const { peekKey, open, copyFormat, onToggleVisible, onTogglePeek, onToggleOpen, getReport } = opts;
+    const abort = new AbortController();
+    const signal = abort.signal;
+    const panel = document.createElement("div");
+    panel.className = "ooo-panel";
+    panel.dataset.open = open ? "1" : "0";
+    const title = buildTitle(panel, signal, onToggleOpen);
+    const { body, visSwitch, peekSwitch } = buildBody(
+      peekKey,
+      signal,
+      onToggleVisible,
+      onTogglePeek,
+      getReport,
+      copyFormat
+    );
+    panel.append(title, body);
+    layer.appendChild(panel);
+    listenForPeekKey(peekKey, signal, onTogglePeek);
+    return {
+      syncVisible: (shown) => {
+        setSwitch(visSwitch, shown);
+        peekSwitch.disabled = !shown;
+      },
+      syncPeek: (on) => setSwitch(peekSwitch, on),
+      teardown: () => {
+        abort.abort();
+        panel.remove();
+      }
+    };
+  }
+  function buildTitle(panel, signal, onToggleOpen) {
+    const title = document.createElement("button");
+    title.type = "button";
+    title.tabIndex = -1;
+    title.className = "ooo-panel-title";
+    title.textContent = "Out of Order";
+    title.addEventListener("mousedown", (event) => event.preventDefault(), {
+      signal
+    });
+    title.addEventListener(
+      "click",
+      () => {
+        const next = panel.dataset.open !== "1";
+        panel.dataset.open = next ? "1" : "0";
+        onToggleOpen(next);
+      },
+      { signal }
+    );
+    return title;
+  }
+  function buildBody(peekKey, signal, onToggleVisible, onTogglePeek, getReport, copyFormat) {
+    const body = document.createElement("div");
+    body.className = "ooo-panel-body";
+    const visSwitch = addSwitch(body, "vis", "Overlay", onToggleVisible, signal);
+    const peekSwitch = addSwitch(body, "peek", "Peek", onTogglePeek, signal);
+    setSwitch(visSwitch, true);
+    setSwitch(peekSwitch, false);
+    const hint = document.createElement("p");
+    hint.className = "ooo-panel-hint";
+    hint.textContent = `tap ${PEEK_KEY_LABEL[peekKey]} to peek`;
+    body.appendChild(hint);
+    addCopyButton(body, getReport, copyFormat, signal);
+    return { body, visSwitch, peekSwitch };
+  }
+  function addCopyButton(parent, getReport, copyFormat, signal) {
+    let current = copyFormat;
+    const wrap = document.createElement("div");
+    wrap.className = "ooo-copy-split";
+    const main = document.createElement("button");
+    main.type = "button";
+    main.tabIndex = -1;
+    main.className = "ooo-copy";
+    const caret = document.createElement("button");
+    caret.type = "button";
+    caret.tabIndex = -1;
+    caret.className = "ooo-copy-caret";
+    caret.textContent = "\u25BE";
+    caret.setAttribute("aria-haspopup", "menu");
+    caret.setAttribute("aria-expanded", "false");
+    caret.setAttribute("aria-label", "Choose copy format");
+    const menu = document.createElement("div");
+    menu.className = "ooo-copy-menu";
+    menu.setAttribute("role", "menu");
+    menu.hidden = true;
+    const labelFor = (value) => COPY_FORMATS.find((format) => format.value === value)?.label ?? value;
+    const mainLabel = () => `Copy ${labelFor(current).toLowerCase()}`;
+    let revert;
+    const flash = (text) => {
+      main.textContent = text;
+      clearTimeout(revert);
+      revert = setTimeout(() => main.textContent = mainLabel(), 1200);
+    };
+    signal.addEventListener("abort", () => clearTimeout(revert));
+    const copy = () => {
+      void navigator.clipboard.writeText(getReport(current)).then(
+        () => flash("Copied"),
+        () => flash("Copy failed")
+      );
+    };
+    const closeMenu = () => {
+      menu.hidden = true;
+      caret.setAttribute("aria-expanded", "false");
+    };
+    const items = /* @__PURE__ */ new Map();
+    const syncSelection = () => {
+      main.textContent = mainLabel();
+      for (const [value, el] of items) {
+        el.classList.toggle("ooo-copy-item--on", value === current);
+        el.setAttribute("aria-checked", String(value === current));
+      }
+    };
+    for (const format of COPY_FORMATS) {
+      const item = document.createElement("button");
+      item.type = "button";
+      item.tabIndex = -1;
+      item.className = "ooo-copy-item";
+      item.setAttribute("role", "menuitemradio");
+      item.textContent = format.label;
+      item.addEventListener("mousedown", (event) => event.preventDefault(), {
+        signal
+      });
+      item.addEventListener(
+        "click",
+        () => {
+          current = format.value;
+          syncSelection();
+          patchPanelState({ copyFormat: current });
+          closeMenu();
+        },
+        { signal }
+      );
+      items.set(format.value, item);
+      menu.appendChild(item);
+    }
+    syncSelection();
+    for (const btn of [main, caret]) {
+      btn.addEventListener("mousedown", (event) => event.preventDefault(), {
+        signal
+      });
+    }
+    main.addEventListener("click", copy, { signal });
+    caret.addEventListener(
+      "click",
+      () => {
+        const open = menu.hidden;
+        menu.hidden = !open;
+        caret.setAttribute("aria-expanded", String(open));
+      },
+      { signal }
+    );
+    document.addEventListener(
+      "pointerdown",
+      (event) => {
+        if (!wrap.contains(event.target)) {
+          closeMenu();
+        }
+      },
+      { signal }
+    );
+    wrap.append(main, caret, menu);
+    parent.appendChild(wrap);
+  }
+  function addSwitch(parent, name, text, onToggle, signal) {
+    const row = document.createElement("div");
+    row.className = "ooo-row";
+    const lbl = document.createElement("span");
+    lbl.className = "ooo-row-label";
+    lbl.textContent = text;
+    const sw = document.createElement("button");
+    sw.type = "button";
+    sw.tabIndex = -1;
+    sw.className = `ooo-switch ooo-switch--${name}`;
+    sw.setAttribute("role", "switch");
+    sw.innerHTML = `<span class="ooo-switch-knob"></span>`;
+    sw.addEventListener("mousedown", (event) => event.preventDefault(), {
+      signal
+    });
+    sw.addEventListener("click", onToggle, { signal });
+    row.append(lbl, sw);
+    parent.appendChild(row);
+    return sw;
+  }
+  function setSwitch(sw, on) {
+    sw.setAttribute("aria-checked", String(on));
+    sw.classList.toggle("ooo-switch--on", on);
+  }
+  function listenForPeekKey(peekKey, signal, onTap) {
+    let armed = false;
+    window.addEventListener(
+      "keydown",
+      (event) => {
+        if (event.key !== peekKey) {
+          armed = false;
+        } else if (!event.repeat) {
+          armed = true;
+        }
+      },
+      { signal }
+    );
+    window.addEventListener(
+      "keyup",
+      (event) => {
+        if (event.key !== peekKey || !armed) {
+          return;
+        }
+        armed = false;
+        onTap();
+      },
+      { signal }
+    );
+    window.addEventListener("pointerdown", () => armed = false, { signal });
+    window.addEventListener("blur", () => armed = false, { signal });
+  }
+
+  // ../trace/src/index.ts
+  function trace(options = {}) {
+    ensureStyles();
+    const layer = document.createElement("div");
+    layer.className = "ooo-layer";
+    layer.dataset.oooPeek = "off";
+    layer.setAttribute("data-ooo-overlay", "");
+    document.body.appendChild(layer);
+    const motion = options.motion ?? "auto";
+    const reduceQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
+    const applyMotion = () => {
+      const animate = motion === "on" || motion === "auto" && !reduceQuery.matches;
+      layer.dataset.oooMotion = animate ? "play" : "still";
+    };
+    applyMotion();
+    if (motion === "auto") {
+      reduceQuery.addEventListener("change", applyMotion);
+    }
+    const tooltip = new Tooltip(layer);
+    const renderer = new Renderer(layer, tooltip);
+    const tracker = new Tracker({
+      onMoved: (moved) => renderer.applyMoved(moved),
+      onScroll: () => renderer.seed(),
+      onResize: () => build(),
+      onFocus: (element) => renderer.setFocused(element)
+    });
+    const mutations = new Mutations(layer, () => build());
+    let lastSig = null;
+    const saved = loadPanelState();
+    let visible = true;
+    let peeking = false;
+    const setVisible = (next) => {
+      visible = next;
+      layer.classList.toggle("ooo-hidden", !next);
+      renderer.setRingsVisible(next);
+      if (!next) {
+        tooltip.hide();
+      }
+      controls.syncVisible(next);
+      patchPanelState({ visible: next });
+    };
+    const setPeek = (next) => {
+      peeking = next;
+      layer.dataset.oooPeek = next ? "on" : "off";
+      if (next) {
+        tooltip.hide();
+      }
+      controls.syncPeek(next);
+      patchPanelState({ peek: next });
+    };
+    const controls = setupControls(layer, {
+      peekKey: options.peekKey ?? "Alt",
+      open: saved.open ?? true,
+      copyFormat: saved.copyFormat ?? "text",
+      onToggleVisible: () => setVisible(!visible),
+      // Peek does nothing with the overlay hidden, so ignore the toggle then.
+      onTogglePeek: () => visible && setPeek(!peeking),
+      onToggleOpen: (open) => patchPanelState({ open }),
+      getReport: (format) => {
+        const violations = audit(options.root ?? document, {
+          ...options.audit,
+          format
+        }).violations;
+        return typeof violations === "string" ? violations : JSON.stringify(violations, null, 2);
+      }
+    });
+    if (saved.visible === false) {
+      setVisible(false);
+    }
+    if (saved.peek === true && visible) {
+      setPeek(true);
+    }
+    const handle = {
+      result: null,
+      get visible() {
+        return visible;
+      },
+      setVisible,
+      toggle: () => setVisible(!visible),
+      destroy: () => {
+        if (motion === "auto") {
+          reduceQuery.removeEventListener("change", applyMotion);
+        }
+        controls.teardown();
+        tracker.destroy();
+        mutations.destroy();
+        tooltip.destroy();
+        renderer.clear();
+        layer.remove();
+      }
+    };
+    function build() {
+      const result = audit(options.root ?? document, options.audit, options.rules);
+      handle.result = result;
+      const sig = resultSignature(result);
+      if (sig === lastSig) {
+        return;
+      }
+      lastSig = sig;
+      const sequence = result.sequence;
+      const inSeq = new Set(sequence.map((entry) => entry.element));
+      const issuesByElement = /* @__PURE__ */ new Map();
+      const indexBy = (element, issue) => {
+        const list = issuesByElement.get(element) ?? [];
+        list.push(issue);
+        issuesByElement.set(element, list);
+      };
+      for (const violation of result.violations) {
+        for (const issue of violation.issues) {
+          indexBy(violation.element, issue);
+          for (const related2 of issue.relatedElements ?? []) {
+            indexBy(related2, issue);
+          }
+        }
+      }
+      const stops = sequence.map(
+        (entry, idx) => makeStop(
+          entry.element,
+          idx + 1,
+          entry.selector,
+          entry.tabIndex,
+          issuesByElement.get(entry.element) ?? [],
+          true
+        )
+      );
+      const segs = [];
+      for (let idx = 0; idx < sequence.length - 1; idx++) {
+        const back = (issuesByElement.get(sequence[idx + 1].element) ?? []).some(
+          (issue) => issue.rule === "visual-order-mismatch" && !issue.ignored
+        );
+        segs.push({ back, tip: () => segTip(back, idx + 1, idx + 2) });
+      }
+      const offStops = [];
+      for (const [element, issues] of issuesByElement) {
+        if (inSeq.has(element)) {
+          continue;
+        }
+        offStops.push(makeStop(element, null, selectorFor(element), null, issues, false));
+      }
+      renderer.draw(stops, segs, offStops);
+      renderer.seed();
+      tracker.observe(renderer.elementsToObserve());
+      renderer.setFocused(document.activeElement);
+    }
+    build();
+    tracker.listen();
+    mutations.observe(options.root ?? document);
+    return handle;
+  }
+  var elementIds = /* @__PURE__ */ new WeakMap();
+  var nextElementId = 1;
+  function elementId(element) {
+    let id = elementIds.get(element);
+    if (id === void 0) {
+      id = nextElementId++;
+      elementIds.set(element, id);
+    }
+    return id;
+  }
+  function resultSignature(result) {
+    const order = result.sequence.map((entry) => elementId(entry.element)).join(">");
+    const vios = result.violations.flatMap(
+      (violation) => violation.issues.map(
+        (issue) => `${elementId(violation.element)}:${issue.rule}${issue.ignored ? "!" : ""}`
+      )
+    ).sort().join("|");
+    return `${order}#${vios}`;
+  }
+  function makeStop(element, num, selector, tabIndex, issues, inSeq) {
+    const label = num !== null ? String(num) : "\u2298";
+    const autofocus = inSeq && element.hasAttribute("autofocus");
+    return {
+      element,
+      label,
+      severity: worstSeverity(issues),
+      inSeq,
+      autofocus,
+      tip: () => badgeTip({
+        num,
+        selector,
+        tabIndex,
+        issues,
+        name: computeAccessibleName(element).trim(),
+        role: getRole(element) ?? "",
+        description: computeAccessibleDescription(element).trim(),
+        autofocus,
+        srOnly: isScreenReaderOnly(element)
+      })
+    };
+  }
+  function worstSeverity(issues) {
+    const live = issues.filter((issue) => !issue.ignored);
+    if (live.some((issue) => issue.severity === "error")) {
+      return "error";
+    }
+    return live.length ? "warning" : null;
+  }
+
+  // src/inject-overlay.ts
+  var mount = () => void trace();
+  if (document.readyState === "complete") {
+    mount();
+  } else {
+    window.addEventListener("load", mount, { once: true });
+  }
+})();
+/*! Bundled license information:
+
+tabbable/dist/index.esm.js:
+  (*!
+  * tabbable 6.5.0
+  * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
+  *)
+*/