@a11y-pulse/tab-orchestrator 0.1.0

package/dist/index.js

@@ -0,0 +1,1312 @@
+// src/audit-scaffold.ts
+var DEFAULT_ELEMENT_LIMIT = 1024;
+var DEFAULT_SCREENSHOT_SETTLE_DELAY = 33;
+var DEFAULT_FAILED_ELEMENT_LIMIT = 0;
+var DEFAULT_TIMEOUT = 0;
+function createAuditSelfDisconnect() {
+  let timer;
+  let disconnectedSelf = false;
+  const clear = () => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const disconnect = (session) => {
+    disconnectedSelf = true;
+    clear();
+    session.disconnect();
+  };
+  return {
+    get disconnectedSelf() {
+      return disconnectedSelf;
+    },
+    armTimeout(timeout, session, onTimeout) {
+      if (timeout > 0) {
+        timer = setTimeout(() => {
+          timer = void 0;
+          onTimeout();
+          disconnect(session);
+        }, timeout);
+      }
+    },
+    disconnect,
+    clear
+  };
+}
+
+// src/browser-scripts.ts
+function baselineScript(props, markerAttr, limit) {
+  const truncateValue = (value) => {
+    const MAX_STYLE_VALUE_LENGTH = 512;
+    if (value.length <= MAX_STYLE_VALUE_LENGTH) {
+      return value;
+    }
+    let hash = 5381;
+    for (let i = 0; i < value.length; i++) {
+      hash = (hash * 33 ^ value.charCodeAt(i)) >>> 0;
+    }
+    return `${value.slice(0, MAX_STYLE_VALUE_LENGTH)}#len=${value.length}#h=${hash.toString(36)}`;
+  };
+  const snapshot = (el) => {
+    const read = (pseudo) => {
+      const cs = getComputedStyle(el, pseudo);
+      const out = {};
+      for (const prop of props) {
+        out[prop] = truncateValue(cs.getPropertyValue(prop));
+      }
+      if (pseudo) {
+        out.content = truncateValue(cs.getPropertyValue("content"));
+      }
+      return out;
+    };
+    return {
+      element: read(void 0),
+      before: read("::before"),
+      after: read("::after")
+    };
+  };
+  const candidates = [];
+  const focusableSelector = [
+    "a[href]",
+    "button",
+    "input",
+    "select",
+    "textarea",
+    "[tabindex]",
+    '[contenteditable=""]',
+    '[contenteditable="true"]'
+  ].join(", ");
+  const collect = (root) => {
+    for (const el of Array.from(root.querySelectorAll("*"))) {
+      if (el.matches(focusableSelector)) {
+        candidates.push(el);
+      }
+      if (el.shadowRoot) {
+        collect(el.shadowRoot);
+      }
+    }
+  };
+  collect(document);
+  const styles = [];
+  const styleIndexByKey = /* @__PURE__ */ new Map();
+  const entries = [];
+  let idx = 0;
+  for (const el of candidates) {
+    if (idx >= limit) {
+      break;
+    }
+    if (el.hasAttribute("disabled")) {
+      continue;
+    }
+    if (el.tabIndex < 0) {
+      continue;
+    }
+    const visibilityCheck = el;
+    if (typeof visibilityCheck.checkVisibility === "function") {
+      if (!visibilityCheck.checkVisibility({ checkVisibilityCSS: true })) {
+        continue;
+      }
+    } else {
+      const cs = getComputedStyle(el);
+      if (cs.display === "none" || cs.visibility === "hidden") {
+        continue;
+      }
+    }
+    el.setAttribute(markerAttr, String(idx));
+    const rect = el.getBoundingClientRect();
+    const snap = snapshot(el);
+    const key = JSON.stringify(snap);
+    let styleIndex = styleIndexByKey.get(key);
+    if (styleIndex === void 0) {
+      styleIndex = styles.length;
+      styles.push(snap);
+      styleIndexByKey.set(key, styleIndex);
+    }
+    entries.push({
+      index: idx,
+      styleIndex,
+      rect: {
+        x: rect.left + window.scrollX,
+        y: rect.top + window.scrollY,
+        width: rect.width,
+        height: rect.height
+      }
+    });
+    idx++;
+  }
+  return { styles, entries };
+}
+function probeActiveElementScript(props, markerAttr) {
+  let el = document.activeElement;
+  while (el?.shadowRoot?.activeElement) {
+    el = el.shadowRoot.activeElement;
+  }
+  if (!el || el === document.body) {
+    return {
+      index: null,
+      isBody: true,
+      isIframe: false,
+      html: "",
+      styles: { element: {}, before: {}, after: {} },
+      rect: { x: 0, y: 0, width: 0, height: 0 }
+    };
+  }
+  const truncateValue = (value) => {
+    const MAX_STYLE_VALUE_LENGTH = 512;
+    if (value.length <= MAX_STYLE_VALUE_LENGTH) {
+      return value;
+    }
+    let hash = 5381;
+    for (let i = 0; i < value.length; i++) {
+      hash = (hash * 33 ^ value.charCodeAt(i)) >>> 0;
+    }
+    return `${value.slice(0, MAX_STYLE_VALUE_LENGTH)}#len=${value.length}#h=${hash.toString(36)}`;
+  };
+  const read = (pseudo) => {
+    const cs = getComputedStyle(el, pseudo);
+    const out = {};
+    for (const prop of props) {
+      out[prop] = truncateValue(cs.getPropertyValue(prop));
+    }
+    if (pseudo) {
+      out.content = truncateValue(cs.getPropertyValue("content"));
+    }
+    return out;
+  };
+  const idxAttr = el.getAttribute(markerAttr);
+  const rect = el.getBoundingClientRect();
+  const openingTag = el.cloneNode(false);
+  openingTag.removeAttribute(markerAttr);
+  return {
+    index: idxAttr === null ? null : Number(idxAttr),
+    isBody: false,
+    isIframe: el.tagName === "IFRAME",
+    html: openingTag.outerHTML,
+    styles: {
+      element: read(void 0),
+      before: read("::before"),
+      after: read("::after")
+    },
+    rect: {
+      x: rect.left + window.scrollX,
+      y: rect.top + window.scrollY,
+      width: rect.width,
+      height: rect.height
+    }
+  };
+}
+function activeElementHandleScript() {
+  let el = document.activeElement;
+  while (el?.shadowRoot?.activeElement) {
+    el = el.shadowRoot.activeElement;
+  }
+  return el;
+}
+function pageDimensionsScript() {
+  return {
+    width: document.documentElement.scrollWidth,
+    height: document.documentElement.scrollHeight
+  };
+}
+function elementRectScript(el) {
+  if (!el) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  const rect = el.getBoundingClientRect();
+  return {
+    x: rect.left + window.scrollX,
+    y: rect.top + window.scrollY,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isCenterObscuredScript(el) {
+  if (!el) {
+    return false;
+  }
+  const rect = el.getBoundingClientRect();
+  const x = Math.min(
+    Math.max(rect.left + rect.width / 2, 0),
+    window.innerWidth - 1
+  );
+  const y = Math.min(
+    Math.max(rect.top + rect.height / 2, 0),
+    window.innerHeight - 1
+  );
+  let hit = document.elementFromPoint(x, y);
+  while (hit?.shadowRoot) {
+    const inner = hit.shadowRoot.elementFromPoint(x, y);
+    if (!inner || inner === hit) {
+      break;
+    }
+    hit = inner;
+  }
+  if (!hit) {
+    return false;
+  }
+  return hit !== el && !el.contains(hit) && !hit.contains(el);
+}
+function scrollToCenterScript(el) {
+  el?.scrollIntoView({
+    block: "center",
+    inline: "nearest",
+    behavior: "instant"
+  });
+}
+function blurScript(el) {
+  el?.blur();
+}
+function focusScript(el) {
+  el?.focus({ preventScroll: true });
+}
+function elementStylesScript(el, props) {
+  if (!el) {
+    return { element: {}, before: {}, after: {} };
+  }
+  const truncateValue = (value) => {
+    const MAX_STYLE_VALUE_LENGTH = 512;
+    if (value.length <= MAX_STYLE_VALUE_LENGTH) {
+      return value;
+    }
+    let hash = 5381;
+    for (let i = 0; i < value.length; i++) {
+      hash = (hash * 33 ^ value.charCodeAt(i)) >>> 0;
+    }
+    return `${value.slice(0, MAX_STYLE_VALUE_LENGTH)}#len=${value.length}#h=${hash.toString(36)}`;
+  };
+  const read = (pseudo) => {
+    const cs = getComputedStyle(el, pseudo);
+    const out = {};
+    for (const prop of props) {
+      out[prop] = truncateValue(cs.getPropertyValue(prop));
+    }
+    if (pseudo) {
+      out.content = truncateValue(cs.getPropertyValue("content"));
+    }
+    return out;
+  };
+  return {
+    element: read(void 0),
+    before: read("::before"),
+    after: read("::after")
+  };
+}
+function clearMarkersScript(markerAttr) {
+  const clear = (root) => {
+    for (const el of Array.from(root.querySelectorAll(`[${markerAttr}]`))) {
+      el.removeAttribute(markerAttr);
+    }
+    for (const el of Array.from(root.querySelectorAll("*"))) {
+      if (el.shadowRoot) {
+        clear(el.shadowRoot);
+      }
+    }
+  };
+  clear(document);
+  document.activeElement?.blur();
+}
+function measureObscuringScript(el, obscurerAttr) {
+  const empty = {
+    coveredFraction: 0,
+    fullyObscured: false,
+    offscreen: false,
+    opacity: "opaque",
+    obscuredByHtml: null,
+    hasObscurer: false
+  };
+  if (!el) {
+    return empty;
+  }
+  for (const marked of Array.from(
+    document.querySelectorAll(`[${obscurerAttr}]`)
+  )) {
+    marked.removeAttribute(obscurerAttr);
+  }
+  const rect = el.getBoundingClientRect();
+  const left = Math.max(rect.left, 0);
+  const top = Math.max(rect.top, 0);
+  const right = Math.min(rect.right, window.innerWidth);
+  const bottom = Math.min(rect.bottom, window.innerHeight);
+  if (right <= left || bottom <= top) {
+    return { ...empty, offscreen: true };
+  }
+  const width = right - left;
+  const height = bottom - top;
+  const LARGE_ELEMENT_THRESHOLD_PX = 80;
+  const points = [
+    { x: left, y: top },
+    { x: right - 0.5, y: top },
+    { x: left, y: bottom - 0.5 },
+    { x: right - 0.5, y: bottom - 0.5 },
+    { x: left + width / 2, y: top },
+    { x: left + width / 2, y: bottom - 0.5 },
+    { x: left, y: top + height / 2 },
+    { x: right - 0.5, y: top + height / 2 },
+    { x: left + width / 2, y: top + height / 2 }
+  ];
+  if (width > LARGE_ELEMENT_THRESHOLD_PX || height > LARGE_ELEMENT_THRESHOLD_PX) {
+    points.push(
+      { x: left + width * 0.25, y: top + height * 0.25 },
+      { x: left + width * 0.75, y: top + height * 0.25 },
+      { x: left + width * 0.25, y: top + height * 0.75 },
+      { x: left + width * 0.75, y: top + height * 0.75 }
+    );
+  }
+  const hitAt = (x, y) => {
+    const px = Math.min(Math.max(x, 0), window.innerWidth - 1);
+    const py = Math.min(Math.max(y, 0), window.innerHeight - 1);
+    const stack = typeof document.elementsFromPoint === "function" ? document.elementsFromPoint(px, py) : [document.elementFromPoint(px, py)].filter(Boolean);
+    for (let candidate of stack) {
+      while (candidate?.shadowRoot) {
+        const inner = candidate.shadowRoot.elementFromPoint(px, py);
+        if (!inner || inner === candidate) {
+          break;
+        }
+        candidate = inner;
+      }
+      if (!candidate) {
+        continue;
+      }
+      if (candidate === el || el.contains(candidate) || candidate.contains(el)) {
+        return null;
+      }
+      return candidate;
+    }
+    return null;
+  };
+  let covered = 0;
+  const coverCounts = /* @__PURE__ */ new Map();
+  for (const point of points) {
+    const cover = hitAt(point.x, point.y);
+    if (cover) {
+      covered++;
+      coverCounts.set(cover, (coverCounts.get(cover) ?? 0) + 1);
+    }
+  }
+  const coveredFraction = points.length === 0 ? 0 : covered / points.length;
+  if (coveredFraction < 1) {
+    return {
+      ...empty,
+      coveredFraction,
+      fullyObscured: false
+    };
+  }
+  let topCover = null;
+  let topCount = 0;
+  for (const [candidate, count] of coverCounts) {
+    if (count > topCount) {
+      topCover = candidate;
+      topCount = count;
+    }
+  }
+  if (!topCover) {
+    return {
+      ...empty,
+      coveredFraction: 1,
+      fullyObscured: false,
+      opacity: "unknown"
+    };
+  }
+  const coverRect = topCover.getBoundingClientRect();
+  const containsFully = coverRect.left <= rect.left && coverRect.top <= rect.top && coverRect.right >= rect.right && coverRect.bottom >= rect.bottom;
+  if (!containsFully) {
+    return {
+      coveredFraction: 1,
+      fullyObscured: true,
+      offscreen: false,
+      opacity: "unknown",
+      obscuredByHtml: null,
+      hasObscurer: false
+    };
+  }
+  const classifyOpacity = (node) => {
+    const cs = getComputedStyle(node);
+    const opacity2 = Number.parseFloat(cs.opacity);
+    if (!Number.isFinite(opacity2)) {
+      return "unknown";
+    }
+    if (opacity2 < 1) {
+      return "semi-transparent";
+    }
+    const bg = cs.backgroundColor;
+    const rgba = bg.match(
+      /rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)(?:\s*,\s*([\d.]+))?\s*\)/
+    );
+    if (rgba) {
+      const alpha = rgba[4] === void 0 ? 1 : Number.parseFloat(rgba[4]);
+      if (alpha < 1) {
+        return alpha <= 0 ? "semi-transparent" : "semi-transparent";
+      }
+      return "opaque";
+    }
+    if (cs.backgroundImage && cs.backgroundImage !== "none") {
+      return "unknown";
+    }
+    return "unknown";
+  };
+  const opacity = classifyOpacity(topCover);
+  const openingTag = topCover.cloneNode(false);
+  openingTag.removeAttribute(obscurerAttr);
+  topCover.setAttribute(obscurerAttr, "1");
+  return {
+    coveredFraction: 1,
+    fullyObscured: true,
+    offscreen: false,
+    opacity,
+    obscuredByHtml: openingTag.outerHTML,
+    hasObscurer: true
+  };
+}
+function obscurerHandleScript() {
+  return document.querySelector("[data-a11y-obscurer]");
+}
+function clearObscurerScript(obscurerAttr) {
+  for (const marked of Array.from(
+    document.querySelectorAll(`[${obscurerAttr}]`)
+  )) {
+    marked.removeAttribute(obscurerAttr);
+  }
+}
+function installContextObserverScript() {
+  if (window.__a11yContextObserver?.installed) {
+    return;
+  }
+  const state = {
+    baselineHref: location.href,
+    openedWindow: false,
+    submittedForm: false,
+    focusIns: [],
+    softUrlChange: false,
+    installed: true
+  };
+  window.__a11yContextObserver = state;
+  const originalOpen = window.open.bind(window);
+  window.open = (..._args) => {
+    state.openedWindow = true;
+    return {
+      closed: true,
+      close() {
+      },
+      focus() {
+      },
+      blur() {
+      },
+      opener: null,
+      location: { href: "" }
+    };
+  };
+  void originalOpen;
+  document.addEventListener(
+    "submit",
+    (event) => {
+      state.submittedForm = true;
+      event.preventDefault();
+      event.stopPropagation();
+    },
+    true
+  );
+  document.addEventListener(
+    "focus",
+    (event) => {
+      const target = event.target;
+      if (target && target.nodeType === 1) {
+        state.focusIns.push(target);
+      }
+    },
+    true
+  );
+  const noteSoftNav = () => {
+    if (location.href !== state.baselineHref) {
+      state.softUrlChange = true;
+    }
+  };
+  window.addEventListener("hashchange", noteSoftNav);
+  window.addEventListener("popstate", noteSoftNav);
+  const wrapHistory = (method) => {
+    const original = history[method].bind(history);
+    history[method] = ((...args) => {
+      const result = original(...args);
+      noteSoftNav();
+      return result;
+    });
+  };
+  wrapHistory("pushState");
+  wrapHistory("replaceState");
+}
+function drainContextObserverScript(markerAttr) {
+  const attributedAttr = "data-a11y-ctx-attr";
+  const empty = {
+    openedWindow: false,
+    submittedForm: false,
+    focusRemoved: false,
+    redirect: null,
+    softUrlChange: false,
+    navigation: false,
+    attributedHtml: null,
+    hasAttributed: false
+  };
+  const state = window.__a11yContextObserver;
+  if (!state) {
+    return empty;
+  }
+  for (const marked of Array.from(
+    document.querySelectorAll(`[${attributedAttr}]`)
+  )) {
+    marked.removeAttribute(attributedAttr);
+  }
+  const openedWindow = state.openedWindow;
+  const submittedForm = state.submittedForm;
+  const softUrlChange = state.softUrlChange;
+  const focusIns = state.focusIns.slice();
+  state.openedWindow = false;
+  state.submittedForm = false;
+  state.softUrlChange = false;
+  state.focusIns = [];
+  let active = document.activeElement;
+  while (active?.shadowRoot?.activeElement) {
+    active = active.shadowRoot.activeElement;
+  }
+  const intended = focusIns.find(
+    (el) => el !== document.body && el !== document.documentElement
+  ) ?? null;
+  const openingHtml = (node) => {
+    const clone = node.cloneNode(false);
+    clone.removeAttribute(markerAttr);
+    clone.removeAttribute(attributedAttr);
+    return clone.outerHTML;
+  };
+  let focusRemoved = false;
+  let redirect = null;
+  let attributedHtml = null;
+  let hasAttributed = false;
+  const bodyOrNone = !active || active === document.body || active === document.documentElement;
+  if (intended && bodyOrNone) {
+    focusRemoved = true;
+    attributedHtml = openingHtml(intended);
+    intended.setAttribute(attributedAttr, "1");
+    hasAttributed = true;
+  } else if (intended && active && intended !== active) {
+    const composedContains = (ancestor, node) => {
+      let current = node;
+      while (current) {
+        if (current === ancestor) {
+          return true;
+        }
+        const parent = current.parentNode;
+        if (parent) {
+          current = parent;
+          continue;
+        }
+        if (current instanceof ShadowRoot) {
+          current = current.host;
+          continue;
+        }
+        break;
+      }
+      return false;
+    };
+    const same = composedContains(intended, active) || composedContains(active, intended);
+    redirect = same ? "same-subtree" : "outside";
+    attributedHtml = openingHtml(intended);
+    intended.setAttribute(attributedAttr, "1");
+    hasAttributed = true;
+  }
+  return {
+    openedWindow,
+    submittedForm,
+    focusRemoved,
+    redirect,
+    softUrlChange,
+    navigation: false,
+    attributedHtml,
+    hasAttributed
+  };
+}
+function attributedHandleScript() {
+  return document.querySelector("[data-a11y-ctx-attr]");
+}
+function clearAttributedScript() {
+  for (const marked of Array.from(
+    document.querySelectorAll("[data-a11y-ctx-attr]")
+  )) {
+    marked.removeAttribute("data-a11y-ctx-attr");
+  }
+}
+function clearContextFocusInsScript() {
+  const state = window.__a11yContextObserver;
+  if (state) {
+    state.focusIns = [];
+    state.openedWindow = false;
+    state.submittedForm = false;
+    state.softUrlChange = false;
+  }
+}
+function locationHrefScript() {
+  return location.href;
+}
+
+// src/clip.ts
+function bufferedClip(rect, pageWidth, pageHeight, buffer) {
+  const left = Math.max(0, Math.min(buffer, rect.x));
+  const top = Math.max(0, Math.min(buffer, rect.y));
+  const right = Math.max(0, Math.min(buffer, pageWidth - rect.x - rect.width));
+  const bottom = Math.max(
+    0,
+    Math.min(buffer, pageHeight - rect.y - rect.height)
+  );
+  return {
+    x: Math.max(0, rect.x - left),
+    y: Math.max(0, rect.y - top),
+    width: rect.width + left + right,
+    height: rect.height + top + bottom
+  };
+}
+
+// src/focus-style.ts
+var FOCUS_STYLE_PROPERTIES = [
+  "background-color",
+  "background-image",
+  "border-bottom-color",
+  "border-bottom-style",
+  "border-bottom-width",
+  "border-left-color",
+  "border-left-style",
+  "border-left-width",
+  "border-right-color",
+  "border-right-style",
+  "border-right-width",
+  "border-top-color",
+  "border-top-style",
+  "border-top-width",
+  "box-shadow",
+  "color",
+  "font-weight",
+  "outline-color",
+  "outline-style",
+  "outline-width",
+  "text-decoration"
+];
+
+// src/get-selector.ts
+function getSelector(root) {
+  const MAX_LENGTH = 128;
+  const esc = (value) => typeof CSS !== "undefined" && typeof CSS.escape === "function" ? CSS.escape(value) : value;
+  const tagName = (node2) => node2.nodeType === 1 ? node2.nodeName.toLowerCase() : node2.nodeName.toUpperCase().replace(/^#/, "");
+  const rootOf = (element) => {
+    const node2 = element.getRootNode?.();
+    return node2 && typeof node2.querySelectorAll === "function" ? node2 : null;
+  };
+  const matchCount = (queryRoot2, selector) => {
+    try {
+      return queryRoot2.querySelectorAll(selector).length;
+    } catch {
+      return Number.POSITIVE_INFINITY;
+    }
+  };
+  const safeMatches = (element, selector) => {
+    try {
+      return typeof element.matches === "function" && element.matches(selector);
+    } catch {
+      return false;
+    }
+  };
+  const idIsUnique = (element, id) => {
+    const queryRoot2 = rootOf(element);
+    return queryRoot2 === null || matchCount(queryRoot2, `#${esc(id)}`) === 1;
+  };
+  const classFeature = (cls) => ({
+    feature: `.${esc(cls)}`,
+    sharedBy: (sibling) => Array.from(sibling.classList ?? []).includes(cls)
+  });
+  const rarestFeature = (element, queryRoot2) => {
+    const classes = Array.from(element.classList).slice(0, 8);
+    if (!queryRoot2) {
+      const cls = classes[0];
+      return cls === void 0 ? null : classFeature(cls);
+    }
+    let best = null;
+    let bestCount = Number.POSITIVE_INFINITY;
+    for (const cls of classes) {
+      const candidate = classFeature(cls);
+      if (!safeMatches(element, candidate.feature)) {
+        continue;
+      }
+      const count = matchCount(queryRoot2, candidate.feature);
+      if (count < bestCount) {
+        best = candidate;
+        bestCount = count;
+      }
+      if (count === 1) {
+        return best;
+      }
+    }
+    const href = typeof element.getAttribute === "function" ? element.getAttribute("href") : null;
+    if (href && href.length <= 100 && !/["\\?]/.test(href)) {
+      const feature = `[href="${href}"]`;
+      if (safeMatches(element, feature) && matchCount(queryRoot2, feature) < bestCount) {
+        return {
+          feature,
+          sharedBy: (sibling) => typeof sibling.getAttribute === "function" && sibling.getAttribute("href") === href
+        };
+      }
+    }
+    return best;
+  };
+  const positionAmongSiblings = (element, sharedBy) => {
+    const siblings = element.parentNode?.children;
+    if (!siblings) {
+      return { nth: 0, ambiguous: false };
+    }
+    let nth = 0;
+    let count = 0;
+    let shared = 0;
+    for (const sibling of Array.from(siblings)) {
+      if (sibling.nodeName !== element.nodeName) {
+        continue;
+      }
+      count++;
+      if (sibling === element) {
+        nth = count;
+      }
+      if (sharedBy(sibling)) {
+        shared++;
+      }
+    }
+    return { nth, ambiguous: shared > 1 };
+  };
+  const segmentFor = (element, queryRoot2) => {
+    if (element.id && idIsUnique(element, element.id)) {
+      return { segment: `#${esc(element.id)}`, anchored: true };
+    }
+    const feature = rarestFeature(element, queryRoot2);
+    let segment = tagName(element) + (feature === null ? "" : feature.feature);
+    const { nth, ambiguous } = positionAmongSiblings(
+      element,
+      feature === null ? () => true : feature.sharedBy
+    );
+    if (ambiguous && nth > 0) {
+      segment += `:nth-of-type(${nth})`;
+    }
+    return { segment, anchored: false };
+  };
+  const degradedSegmentFor = (element) => {
+    let segment = tagName(element);
+    const { nth, ambiguous } = positionAmongSiblings(element, () => true);
+    if (ambiguous && nth > 0) {
+      segment += `:nth-of-type(${nth})`;
+    }
+    return segment;
+  };
+  const segments = [];
+  let node = root;
+  const queryRoot = root && root.nodeType === 1 ? rootOf(root) : null;
+  try {
+    while (node && node.nodeType === 1) {
+      const element = node;
+      let { segment, anchored } = segmentFor(element, queryRoot);
+      const joinedWith = (candidate) => segments.length ? candidate.length + 1 + segments.join(">").length : candidate.length;
+      if (joinedWith(segment) > MAX_LENGTH - 1) {
+        segment = degradedSegmentFor(element);
+        anchored = false;
+        if (joinedWith(segment) > MAX_LENGTH - 1) {
+          break;
+        }
+      }
+      segments.unshift(segment);
+      if (anchored) {
+        break;
+      }
+      if (queryRoot && matchCount(queryRoot, segments.join(">")) === 1) {
+        break;
+      }
+      node = element.parentNode;
+    }
+  } catch {
+  }
+  return segments.join(">");
+}
+
+// src/truncate-html.ts
+var DEFAULT_MAX_ATTRIBUTE_VALUE_LENGTH = 50;
+var DEFAULT_MAX_LENGTH = 300;
+var ELLIPSIS = "...";
+function truncateHtml(html, options = {}) {
+  if (!html) {
+    return "";
+  }
+  const maxAttributeValueLength = options.maxAttributeValueLength ?? DEFAULT_MAX_ATTRIBUTE_VALUE_LENGTH;
+  const maxLength = options.maxLength ?? DEFAULT_MAX_LENGTH;
+  const closingBracket = html.indexOf(">");
+  const openingTag = closingBracket === -1 ? html : html.slice(0, closingBracket + 1);
+  const trimmed = openingTag.replace(
+    /=(["'])([\s\S]*?)\1/g,
+    (match, quote, value) => {
+      if (value.length <= maxAttributeValueLength) {
+        return match;
+      }
+      return `=${quote}${value.slice(0, maxAttributeValueLength)}${ELLIPSIS}${quote}`;
+    }
+  );
+  if (trimmed.length > maxLength) {
+    return `${trimmed.slice(0, maxLength)}${ELLIPSIS}`;
+  }
+  return trimmed;
+}
+
+// src/unfocused-pair.ts
+async function captureUnfocusedPair(adaptor, options, handle) {
+  if (await adaptor.evaluate(isCenterObscuredScript, handle)) {
+    await adaptor.evaluate(scrollToCenterScript, handle);
+    await new Promise(
+      (resolve) => setTimeout(resolve, options.screenshotSettleDelay)
+    );
+  }
+  const { width: pageWidth, height: pageHeight } = await adaptor.evaluate(pageDimensionsScript);
+  const focusedRect = await adaptor.evaluate(elementRectScript, handle);
+  const focusedClip = bufferedClip(
+    focusedRect,
+    pageWidth,
+    pageHeight,
+    options.screenshotClipBuffer
+  );
+  const scale = adaptor.screenshotClipScale ?? 1;
+  const focusedScreenshot = await adaptor.screenshotClip(focusedClip, scale);
+  await adaptor.evaluate(blurScript, handle);
+  const unfocusedRect = await adaptor.evaluate(elementRectScript, handle);
+  const unfocusedClip = bufferedClip(
+    unfocusedRect,
+    pageWidth,
+    pageHeight,
+    options.screenshotClipBuffer
+  );
+  const unfocusedScreenshot = await adaptor.screenshotClip(
+    unfocusedClip,
+    scale
+  );
+  const unfocusedStyles = await adaptor.evaluate(elementStylesScript, handle, [
+    ...options.styleProps
+  ]);
+  await adaptor.evaluate(focusScript, handle);
+  return {
+    focusedScreenshot,
+    unfocusedScreenshot,
+    unfocusedStyles,
+    focusedRect,
+    unfocusedRect,
+    focusedClip,
+    unfocusedClip,
+    scale
+  };
+}
+
+// src/orchestrator.ts
+function isContextDestroyedError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /Execution context was destroyed|Target closed|frame was detached|navigat/i.test(
+    message
+  );
+}
+var DEFAULT_SCREENSHOT_SETTLE_DELAY2 = 33;
+var DEFAULT_SCREENSHOT_CLIP_BUFFER = 10;
+var DEFAULT_MARKER_LIMIT = 1024;
+var MARKER_ATTR = "data-a11y-focus-idx";
+var OBSCURER_ATTR = "data-a11y-obscurer";
+var OBSCURING_RECHECK_DELAY_MS = 250;
+function createTabOrchestrator(adaptor, options = {}) {
+  const consumers = [];
+  let started = false;
+  let ran = false;
+  return {
+    attach(consumer) {
+      if (started) {
+        throw new Error("Cannot attach after run() has started");
+      }
+      consumers.push(consumer);
+    },
+    async run() {
+      if (ran) {
+        throw new Error("run() has already been called");
+      }
+      ran = true;
+      started = true;
+      if (consumers.length === 0) {
+        return;
+      }
+      const attached = new Set(consumers);
+      const screenshotSettleDelay = options.screenshotSettleDelay ?? DEFAULT_SCREENSHOT_SETTLE_DELAY2;
+      const screenshotClipBuffer = options.screenshotClipBuffer ?? DEFAULT_SCREENSHOT_CLIP_BUFFER;
+      const markerLimit = Math.max(
+        options.markerLimit ?? DEFAULT_MARKER_LIMIT,
+        options.baselineElementLimit ?? 0
+      );
+      const styleProps = [...FOCUS_STYLE_PROPERTIES];
+      const resolved = {
+        screenshotSettleDelay,
+        screenshotClipBuffer,
+        styleProps
+      };
+      let settleTimer;
+      let resolveSettle;
+      const pairByStop = { current: null };
+      let activeHandle;
+      let lastHasAttributed = false;
+      let baselineHref = null;
+      const remainingHas = (capability) => [...attached].some((c) => c.capabilities.has(capability));
+      const contextSignalsWanted = remainingHas("contextSignals");
+      const handleFor = (consumer) => ({
+        disconnect() {
+          attached.delete(consumer);
+          if (attached.size === 0 && settleTimer !== void 0) {
+            clearTimeout(settleTimer);
+            settleTimer = void 0;
+            resolveSettle?.();
+            resolveSettle = void 0;
+          }
+        },
+        ensureUnfocusedPair: () => {
+          if (!consumer.capabilities.has("unfocusedPair")) {
+            throw new Error("Consumer did not declare unfocusedPair");
+          }
+          if (!remainingHas("unfocusedPair")) {
+            throw new Error("Consumer did not declare unfocusedPair");
+          }
+          if (activeHandle === void 0) {
+            throw new Error("unfocusedPair capture not implemented");
+          }
+          pairByStop.current ??= captureUnfocusedPair(
+            adaptor,
+            resolved,
+            activeHandle
+          );
+          return pairByStop.current;
+        }
+      });
+      const end = (reason) => {
+        for (const consumer of attached) {
+          consumer.onSessionEnd?.(reason);
+        }
+        attached.clear();
+      };
+      async function checkContextNavigation() {
+        let href;
+        try {
+          href = await adaptor.evaluate(locationHrefScript);
+        } catch (error) {
+          if (!isContextDestroyedError(error)) {
+            throw error;
+          }
+          return { navigation: true };
+        }
+        if (baselineHref === null || href === baselineHref) {
+          return { navigation: false, raw: null };
+        }
+        let raw = null;
+        try {
+          raw = await adaptor.evaluate(drainContextObserverScript, MARKER_ATTR);
+        } catch {
+          raw = null;
+        }
+        if (raw === null || !raw.softUrlChange) {
+          return { navigation: true };
+        }
+        baselineHref = href;
+        return { navigation: false, raw };
+      }
+      let failure;
+      try {
+        await adaptor.ensureFocusReporting();
+        const payload = await adaptor.evaluate(
+          baselineScript,
+          styleProps,
+          MARKER_ATTR,
+          markerLimit
+        );
+        const interned = /* @__PURE__ */ new Map();
+        for (const entry of payload.entries) {
+          const styles = payload.styles[entry.styleIndex];
+          if (styles !== void 0) {
+            interned.set(entry.index, styles);
+          }
+        }
+        if (contextSignalsWanted) {
+          baselineHref = await adaptor.evaluate(locationHrefScript);
+          await adaptor.evaluate(installContextObserverScript);
+        }
+        for (const consumer of [...attached]) {
+          await consumer.onSessionStart?.(handleFor(consumer));
+        }
+        const visited = /* @__PURE__ */ new Set();
+        let tabIndex = 0;
+        while (attached.size > 0) {
+          pairByStop.current = null;
+          lastHasAttributed = false;
+          const hasFocus = await adaptor.evaluate(() => document.hasFocus());
+          if (!hasFocus) {
+            end("lostFocus");
+            break;
+          }
+          await adaptor.pressTab();
+          await new Promise((resolve) => {
+            resolveSettle = resolve;
+            settleTimer = setTimeout(() => {
+              settleTimer = void 0;
+              resolveSettle = void 0;
+              resolve();
+            }, screenshotSettleDelay);
+          });
+          if (attached.size === 0) {
+            break;
+          }
+          let base;
+          try {
+            base = await adaptor.evaluate(
+              probeActiveElementScript,
+              styleProps,
+              MARKER_ATTR
+            );
+          } catch (error) {
+            if (remainingHas("contextSignals") && isContextDestroyedError(error)) {
+              end("navigation");
+              break;
+            }
+            throw error;
+          }
+          let contextNav = null;
+          if (remainingHas("contextSignals")) {
+            const outcome = await checkContextNavigation();
+            if (outcome.navigation) {
+              end("navigation");
+              break;
+            }
+            contextNav = outcome;
+          }
+          if (base === null || base.isBody) {
+            if (remainingHas("contextSignals")) {
+              let raw;
+              try {
+                raw = contextNav?.raw ?? await adaptor.evaluate(
+                  drainContextObserverScript,
+                  MARKER_ATTR
+                );
+              } catch (error) {
+                if (!isContextDestroyedError(error)) {
+                  throw error;
+                }
+                end("navigation");
+                break;
+              }
+              if (raw.hasAttributed) {
+                const attributedRef = await adaptor.evaluateHandle(
+                  attributedHandleScript
+                );
+                let selector;
+                try {
+                  selector = await adaptor.evaluate(getSelector, attributedRef);
+                } finally {
+                  await adaptor.disposeRef(attributedRef);
+                }
+                const activeElement = {
+                  index: null,
+                  isBody: false,
+                  isIframe: false,
+                  selector,
+                  html: truncateHtml(raw.attributedHtml ?? ""),
+                  styles: { element: {}, before: {}, after: {} },
+                  rect: { x: 0, y: 0, width: 0, height: 0 }
+                };
+                const snapshot = {
+                  tabIndex: ++tabIndex,
+                  activeElement,
+                  contextSignals: {
+                    signals: {
+                      openedWindow: raw.openedWindow,
+                      submittedForm: raw.submittedForm,
+                      focusRemoved: raw.focusRemoved,
+                      redirect: raw.redirect,
+                      softUrlChange: raw.softUrlChange,
+                      navigation: raw.navigation
+                    }
+                  }
+                };
+                const recipients = [...attached].filter(
+                  (consumer) => consumer.capabilities.has("contextSignals")
+                );
+                try {
+                  for (const consumer of recipients) {
+                    await consumer.onTabStop(snapshot, handleFor(consumer));
+                  }
+                } finally {
+                  await adaptor.evaluate(clearAttributedScript);
+                }
+              }
+            }
+            end("completed");
+            break;
+          }
+          if (base.isIframe) {
+            continue;
+          }
+          if (base.index !== null) {
+            if (visited.has(base.index)) {
+              end("completed");
+              break;
+            }
+            visited.add(base.index);
+          }
+          const ref = await adaptor.evaluateHandle(activeElementHandleScript);
+          activeHandle = ref;
+          try {
+            const selector = await adaptor.evaluate(getSelector, ref);
+            const activeElement = {
+              ...base,
+              html: truncateHtml(base.html),
+              selector
+            };
+            const snapshot = {
+              tabIndex: ++tabIndex,
+              activeElement
+            };
+            if (remainingHas("baselineStyles") && activeElement.index !== null) {
+              const baselineStyles = interned.get(activeElement.index);
+              if (baselineStyles !== void 0) {
+                snapshot.baselineStyles = baselineStyles;
+              }
+            }
+            if (remainingHas("contextSignals")) {
+              let signals;
+              try {
+                const raw = contextNav?.raw ?? await adaptor.evaluate(
+                  drainContextObserverScript,
+                  MARKER_ATTR
+                );
+                signals = {
+                  openedWindow: raw.openedWindow,
+                  submittedForm: raw.submittedForm,
+                  focusRemoved: raw.focusRemoved,
+                  redirect: raw.redirect,
+                  softUrlChange: raw.softUrlChange,
+                  navigation: raw.navigation
+                };
+                lastHasAttributed = raw.hasAttributed;
+              } catch (error) {
+                if (!isContextDestroyedError(error)) {
+                  throw error;
+                }
+                signals = {
+                  openedWindow: false,
+                  submittedForm: false,
+                  focusRemoved: false,
+                  redirect: null,
+                  softUrlChange: false,
+                  navigation: true
+                };
+                lastHasAttributed = false;
+              }
+              snapshot.contextSignals = { signals };
+            }
+            if (remainingHas("obscuring")) {
+              let raw = await adaptor.evaluate(
+                measureObscuringScript,
+                ref,
+                OBSCURER_ATTR
+              );
+              if (raw.fullyObscured) {
+                await new Promise(
+                  (resolve) => setTimeout(resolve, OBSCURING_RECHECK_DELAY_MS)
+                );
+                raw = await adaptor.evaluate(
+                  measureObscuringScript,
+                  ref,
+                  OBSCURER_ATTR
+                );
+              }
+              let obscuredBy = null;
+              if (raw.hasObscurer) {
+                const obscurer = await adaptor.evaluateHandle(obscurerHandleScript);
+                try {
+                  const obscurerSelector = await adaptor.evaluate(
+                    getSelector,
+                    obscurer
+                  );
+                  obscuredBy = {
+                    selector: obscurerSelector,
+                    html: truncateHtml(raw.obscuredByHtml ?? "")
+                  };
+                } finally {
+                  await adaptor.disposeRef(obscurer);
+                }
+              }
+              snapshot.obscuring = {
+                coveredFraction: raw.coveredFraction,
+                fullyObscured: raw.fullyObscured,
+                offscreen: raw.offscreen,
+                opacity: raw.opacity,
+                obscuredBy
+              };
+              await adaptor.evaluate(clearObscurerScript, OBSCURER_ATTR);
+            }
+            const recipients = [...attached];
+            for (const consumer of recipients) {
+              await consumer.onTabStop(snapshot, handleFor(consumer));
+            }
+            if (snapshot.contextSignals?.signals.navigation) {
+              end("navigation");
+              break;
+            }
+          } finally {
+            try {
+              if (pairByStop.current !== null) {
+                await pairByStop.current;
+                if (contextSignalsWanted) {
+                  await adaptor.evaluate(clearContextFocusInsScript);
+                  if (lastHasAttributed) {
+                    await adaptor.evaluate(clearAttributedScript);
+                  }
+                }
+              }
+            } catch {
+            }
+            activeHandle = void 0;
+            await adaptor.disposeRef(ref);
+          }
+        }
+      } catch (error) {
+        failure = error;
+      } finally {
+        try {
+          await adaptor.evaluate(clearMarkersScript, MARKER_ATTR);
+        } catch {
+        }
+      }
+      if (failure !== void 0) {
+        end("failed");
+        throw failure;
+      }
+    }
+  };
+}
+export {
+  DEFAULT_ELEMENT_LIMIT,
+  DEFAULT_FAILED_ELEMENT_LIMIT,
+  DEFAULT_SCREENSHOT_SETTLE_DELAY,
+  DEFAULT_TIMEOUT,
+  FOCUS_STYLE_PROPERTIES,
+  activeElementHandleScript,
+  baselineScript,
+  blurScript,
+  bufferedClip,
+  clearMarkersScript,
+  createAuditSelfDisconnect,
+  createTabOrchestrator,
+  elementRectScript,
+  elementStylesScript,
+  focusScript,
+  getSelector,
+  isCenterObscuredScript,
+  pageDimensionsScript,
+  probeActiveElementScript,
+  scrollToCenterScript,
+  truncateHtml
+};
+//# sourceMappingURL=index.js.map