@seybel/breakhound 0.0.0-stage → 1.0.0

package/dist/inject.js

@@ -0,0 +1,2236 @@
+"use strict";
+(() => {
+  // ../analyzers/src/dom.ts
+  var UNCLIPPED = {
+    left: -Infinity,
+    right: Infinity,
+    top: -Infinity,
+    bottom: Infinity,
+    width: Infinity,
+    height: Infinity
+  };
+  function intersectBox(a, b) {
+    const left = Math.max(a.left, b.left);
+    const right = Math.min(a.right, b.right);
+    const top = Math.max(a.top, b.top);
+    const bottom = Math.min(a.bottom, b.bottom);
+    if (right <= left || bottom <= top) return null;
+    return { left, right, top, bottom, width: right - left, height: bottom - top };
+  }
+  function clipFor(rect, style, outer) {
+    const x = style.overflowX !== "visible";
+    const y = style.overflowY !== "visible";
+    if (!x && !y) return outer;
+    const own = {
+      left: x ? rect.left : -Infinity,
+      right: x ? rect.right : Infinity,
+      top: y ? rect.top : -Infinity,
+      bottom: y ? rect.bottom : Infinity,
+      width: x ? rect.width : Infinity,
+      height: y ? rect.height : Infinity
+    };
+    return intersectBox(own, outer) ?? { ...rect, right: rect.left, width: 0 };
+  }
+  var SKIP_TAGS = /* @__PURE__ */ new Set([
+    "SCRIPT",
+    "STYLE",
+    "TEMPLATE",
+    "NOSCRIPT",
+    "LINK",
+    "META",
+    "HEAD",
+    "TITLE",
+    "BR",
+    "WBR",
+    "SOURCE",
+    "TRACK",
+    "OPTION",
+    "OPTGROUP",
+    "DATALIST"
+  ]);
+  var DEV_OVERLAYS = [
+    "nextjs-portal",
+    "[data-nextjs-toast]",
+    "[data-nextjs-dev-tools-button]",
+    "#__next-build-watcher",
+    "#__next-prerender-indicator",
+    "#nuxt-devtools-container",
+    "#vue-inspector-container",
+    "#__vue-devtools-container__",
+    "vite-error-overlay",
+    "vite-plugin-checker-error-overlay",
+    "astro-dev-toolbar",
+    "astro-dev-overlay",
+    "#webpack-dev-server-client-overlay",
+    "#react-refresh-overlay",
+    ".tsqd-parent-container",
+    ".TanStackRouterDevtools",
+    "#svelte-inspector-host",
+    "vercel-live-feedback"
+  ].join(",");
+  var LEAF_TAGS = /* @__PURE__ */ new Set([
+    "svg",
+    "SVG",
+    "MATH",
+    "math",
+    "SELECT",
+    "TEXTAREA",
+    "IFRAME",
+    "VIDEO",
+    "CANVAS"
+  ]);
+  function renderedChildren(el) {
+    if (el.shadowRoot) return Array.from(el.shadowRoot.children);
+    if (el instanceof HTMLSlotElement) {
+      const assigned = el.assignedElements({ flatten: true });
+      if (assigned.length) return assigned;
+    }
+    return Array.from(el.children);
+  }
+  function composedParent(el) {
+    if (el.assignedSlot) return el.assignedSlot;
+    if (el.parentElement) return el.parentElement;
+    const root = el.parentNode;
+    return root instanceof ShadowRoot ? root.host : null;
+  }
+  function closestComposed(el, selector) {
+    for (let p = el; p; p = composedParent(p)) {
+      if (p.matches(selector)) return p;
+    }
+    return null;
+  }
+  function shadowRoots() {
+    const out = [];
+    const walk = (root) => {
+      for (const el of root.querySelectorAll("*")) {
+        if (el.shadowRoot) {
+          out.push(el.shadowRoot);
+          walk(el.shadowRoot);
+        }
+      }
+    };
+    walk(document);
+    return out;
+  }
+  function toBox(r) {
+    return {
+      left: r.left + window.scrollX,
+      right: r.right + window.scrollX,
+      top: r.top + window.scrollY,
+      bottom: r.bottom + window.scrollY,
+      width: r.width,
+      height: r.height
+    };
+  }
+  function clipsX(style) {
+    return style.overflowX !== "visible";
+  }
+  function isRendered(el, style) {
+    if (style.display === "none" || style.visibility === "hidden" || style.visibility === "collapse") {
+      return false;
+    }
+    if (typeof el.checkVisibility === "function") {
+      return el.checkVisibility({ opacityProperty: true, visibilityProperty: true });
+    }
+    return Number.parseFloat(style.opacity) > 0;
+  }
+  function isVisuallyHidden(rec) {
+    const { style, rect } = rec;
+    if (rect.width <= 1 || rect.height <= 1) {
+      if (style.overflow !== "visible" || style.position === "absolute") return true;
+    }
+    if (style.clip && style.clip !== "auto" && /rect\(\s*0/.test(style.clip)) return true;
+    if (style.clipPath && /inset\(\s*50%/.test(style.clipPath)) return true;
+    return false;
+  }
+  var ORNAMENT_OPACITY = 0.3;
+  function isOrnament(rec) {
+    if (rec.el.closest('[aria-hidden="true"]')) return true;
+    let opacity = 1;
+    for (let p = rec; p; p = p.parent) {
+      opacity *= Number.parseFloat(p.style.opacity) || 0;
+      if (opacity < ORNAMENT_OPACITY) return true;
+    }
+    return false;
+  }
+  var BREAKS_ANYWHERE = /[\u0e00-\u0eff\u1000-\u109f\u1780-\u17ff\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uac00-\ud7af\uf900-\ufaff]/g;
+  function breaksAnywhere(text) {
+    const chars = text.replace(/\s/g, "").length;
+    return chars > 0 && (text.match(BREAKS_ANYWHERE)?.length ?? 0) * 2 >= chars;
+  }
+  var MAX_FRAGMENTS = 64;
+  function measureOwnText(el) {
+    let left = Infinity;
+    let right = -Infinity;
+    let top = Infinity;
+    let bottom = -Infinity;
+    const lineTops = [];
+    const pieces = [];
+    const range = document.createRange();
+    let text = "";
+    for (const node of el.childNodes) {
+      if (node.nodeType !== Node.TEXT_NODE || !node.textContent?.trim()) continue;
+      text += ` ${node.textContent}`;
+      range.selectNodeContents(node);
+      for (const r of range.getClientRects()) {
+        if (r.width === 0 || r.height === 0) continue;
+        left = Math.min(left, r.left);
+        right = Math.max(right, r.right);
+        top = Math.min(top, r.top);
+        bottom = Math.max(bottom, r.bottom);
+        pieces.push(r);
+        if (!lineTops.some((t) => Math.abs(t - r.top) < r.height / 2)) lineTops.push(r.top);
+      }
+    }
+    text = text.replace(/\s+/g, " ").trim();
+    if (left === Infinity) return { rect: null, fragments: [], lines: 0, text };
+    const sx = window.scrollX;
+    const sy = window.scrollY;
+    const fragments = pieces.length <= MAX_FRAGMENTS ? pieces.map((r) => ({
+      left: r.left + sx,
+      right: r.right + sx,
+      top: r.top + sy,
+      bottom: r.bottom + sy,
+      width: r.width,
+      height: r.height
+    })) : [];
+    return {
+      fragments,
+      rect: {
+        left: left + sx,
+        right: right + sx,
+        top: top + sy,
+        bottom: bottom + sy,
+        width: right - left,
+        height: bottom - top
+      },
+      lines: lineTops.length,
+      text
+    };
+  }
+  function snapshot() {
+    const html = document.documentElement;
+    const body = document.body;
+    const htmlStyle = getComputedStyle(html);
+    const bodyStyle = body ? getComputedStyle(body) : htmlStyle;
+    const viewportWidth = html.clientWidth;
+    const scrollWidth = Math.max(html.scrollWidth, body?.scrollWidth ?? 0);
+    const rootClipsX = clipsX(htmlStyle) || clipsX(bodyStyle);
+    const records = [];
+    const byElement = /* @__PURE__ */ new Map();
+    const visit = (el, parent, depth) => {
+      if (SKIP_TAGS.has(el.tagName) || el.matches(DEV_OVERLAYS)) return;
+      const style = getComputedStyle(el);
+      if (!isRendered(el, style)) return;
+      if (style.display === "contents") {
+        for (const child of renderedChildren(el)) visit(child, parent, depth);
+        return;
+      }
+      const own = LEAF_TAGS.has(el.tagName) ? { rect: null, fragments: [], lines: 0, text: "" } : measureOwnText(el);
+      let outOfFlow = parent?.outOfFlow ?? null;
+      if (style.position === "fixed") outOfFlow = "fixed";
+      else if (style.position === "absolute" && outOfFlow !== "fixed") outOfFlow = "absolute";
+      const positioned = style.position === "fixed" || style.position === "absolute";
+      const rect = toBox(el.getBoundingClientRect());
+      const clip = style.position === "fixed" ? UNCLIPPED : parent?.innerClip ?? UNCLIPPED;
+      const innerClip = el === document.body || el === html ? clip : clipFor(rect, style, clip);
+      const rec = {
+        el,
+        parent,
+        style,
+        rect,
+        // Text hidden by the element's own overflow (ellipsis, line-clamp) is not painted.
+        textRect: own.rect && style.overflowX === "visible" && style.overflowY === "visible" ? own.rect : own.rect && intersectBox(own.rect, innerClip),
+        textFragments: own.fragments,
+        rawTextRect: own.rect,
+        text: own.text,
+        textLines: own.lines,
+        clipAncestor: parent && parent.el !== body && parent.el !== html && clipsX(parent.style) ? parent : parent?.clipAncestor ?? null,
+        outOfFlow,
+        oofRoot: null,
+        clip,
+        innerClip,
+        depth
+      };
+      rec.oofRoot = positioned ? rec : parent?.oofRoot ?? null;
+      records.push(rec);
+      byElement.set(el, rec);
+      if (LEAF_TAGS.has(el.tagName)) return;
+      for (const child of renderedChildren(el)) visit(child, rec, depth + 1);
+    };
+    if (body) {
+      for (const child of renderedChildren(body)) visit(child, null, 1);
+    }
+    return {
+      viewportWidth,
+      viewportHeight: html.clientHeight,
+      rootClipsX,
+      rootScrollsX: !rootClipsX && scrollWidth > viewportWidth,
+      rtl: bodyStyle.direction === "rtl",
+      scrollWidth,
+      records,
+      byElement
+    };
+  }
+  function isDeliberateOffset(rec) {
+    const s = rec.style;
+    if ((Number.parseFloat(s.marginLeft) || 0) < 0) return true;
+    if ((Number.parseFloat(s.marginRight) || 0) < 0) return true;
+    if ((Number.parseFloat(s.marginTop) || 0) < 0) return true;
+    if ((Number.parseFloat(s.marginBottom) || 0) < 0) return true;
+    if (s.transform && s.transform !== "none") return true;
+    if (s.position === "relative" && (s.top !== "auto" && s.top !== "0px" || s.left !== "auto" && s.left !== "0px")) {
+      return true;
+    }
+    return false;
+  }
+  function contentBox(rec) {
+    const s = rec.style;
+    const bl = Number.parseFloat(s.borderLeftWidth) || 0;
+    const br = Number.parseFloat(s.borderRightWidth) || 0;
+    const pl = Number.parseFloat(s.paddingLeft) || 0;
+    const pr = Number.parseFloat(s.paddingRight) || 0;
+    const left = rec.rect.left + bl + pl;
+    const right = rec.rect.right - br - pr;
+    return { ...rec.rect, left, right, width: right - left };
+  }
+  function paintedRight(rec) {
+    return Math.max(rec.rect.right, rec.textRect?.right ?? -Infinity);
+  }
+  function paintedLeft(rec) {
+    return Math.min(rec.rect.left, rec.textRect?.left ?? Infinity);
+  }
+  function isInline(style) {
+    return style.display === "inline";
+  }
+  function fontSize(rec) {
+    return Number.parseFloat(rec.style.fontSize) || 16;
+  }
+  var TOUCH_MAX_WIDTH = 767;
+  function px(n) {
+    return Math.round(n);
+  }
+
+  // ../analyzers/src/source.ts
+  var SOURCE_ATTR = "data-bh-src";
+  function fromAttribute(value, exact) {
+    const m = value.match(/^(.+?)(?::(\d+))?(?::(\d+))?$/);
+    if (!m?.[1]) return null;
+    return {
+      file: m[1],
+      ...m[2] ? { line: Number(m[2]) } : {},
+      ...m[3] ? { column: Number(m[3]) } : {},
+      exact
+    };
+  }
+  var NOT_APP_CODE = /node_modules|\/\.vite\/deps\/|\/@vite\/|\/@react-refresh|\/_next\/static\/chunks\/|react-dom|jsx-dev-runtime|react-stack/;
+  function fileFromStack(stack) {
+    for (const line of stack.split("\n")) {
+      const m = line.match(/((?:https?|file):\/\/[^\s)]+|webpack-internal:\/\/\/[^\s)]+):\d+:\d+/);
+      const url = m?.[1];
+      if (!url || NOT_APP_CODE.test(url)) continue;
+      if (url.startsWith("webpack-internal:")) {
+        const path = url.match(/\/\.\/(.+)$/)?.[1];
+        if (path) return path.split("?")[0] ?? null;
+        continue;
+      }
+      try {
+        const u = new URL(url);
+        return u.protocol === "file:" ? decodeURIComponent(u.pathname) : u.pathname;
+      } catch {
+      }
+    }
+    return null;
+  }
+  function componentName(type) {
+    if (!type) return void 0;
+    if (typeof type === "function") return type.displayName || type.name || void 0;
+    return type.displayName || componentName(type.type) || componentName(type.render);
+  }
+  function reactSource(el) {
+    const key = Object.keys(el).find((k) => k.startsWith("__reactFiber$"));
+    const fiber = key ? el[key] : null;
+    if (!fiber) return null;
+    const owner = fiber._debugOwner;
+    const component = componentName(owner?.type);
+    const debug = fiber._debugSource;
+    if (debug?.fileName && !NOT_APP_CODE.test(debug.fileName)) {
+      return {
+        file: debug.fileName,
+        ...debug.lineNumber ? { line: debug.lineNumber } : {},
+        ...debug.columnNumber ? { column: debug.columnNumber } : {},
+        ...component ? { component } : {},
+        exact: true
+      };
+    }
+    const stack = fiber._debugStack;
+    const text = typeof stack === "string" ? stack : stack?.stack;
+    const file = typeof text === "string" ? fileFromStack(text) : null;
+    return file ? { file, ...component ? { component } : {}, exact: false } : null;
+  }
+  function vueSource(el) {
+    for (let instance = el.__vueParentComponent; instance; instance = instance.parent) {
+      const file = instance.type?.__file;
+      if (typeof file === "string" && !NOT_APP_CODE.test(file)) {
+        const component = instance.type.__name || instance.type.name;
+        return { file, ...component ? { component } : {}, exact: false };
+      }
+    }
+    return null;
+  }
+  function sourceOf(el) {
+    try {
+      const own = el.getAttribute(SOURCE_ATTR);
+      if (own) return fromAttribute(own, true);
+      const found = reactSource(el) ?? vueSource(el);
+      if (found) return found;
+      const above = el.parentElement?.closest(`[${SOURCE_ATTR}]`);
+      const value = above?.getAttribute(SOURCE_ATTR);
+      return value ? fromAttribute(value, false) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  // ../analyzers/src/selector.ts
+  var cache = /* @__PURE__ */ new WeakMap();
+  var owners = /* @__PURE__ */ new WeakMap();
+  function elementOf(info) {
+    return owners.get(info);
+  }
+  function isStableId(id) {
+    if (!id || /[:«»]/.test(id)) return false;
+    if (/^(radix|headlessui|react-aria|mui|chakra|ember)[-_]/i.test(id)) return false;
+    if (/\d{3,}/.test(id)) return false;
+    return /^[A-Za-z][\w-]*$/.test(id);
+  }
+  function usefulClasses(el) {
+    const out = [];
+    for (const c of el.classList) {
+      if (/[:[\]/!@.%#()]/.test(c)) continue;
+      if (/^(css|sc|jsx|emotion|svelte|astro|styled)-[\w-]*\d/i.test(c)) continue;
+      if (/^_?[a-zA-Z]+_[a-zA-Z0-9]+__[\w-]{4,}$/.test(c)) continue;
+      if (/^[a-z]{1,3}[A-Z0-9]\w{4,}$/.test(c) && /\d/.test(c)) continue;
+      out.push(c);
+    }
+    return out.sort((a, b) => score(b) - score(a)).slice(0, 2);
+  }
+  function score(c) {
+    let s = c.length;
+    if (/^(flex|grid|block|inline|hidden|p[trblxy]?-|m[trblxy]?-|w-|h-|text-|bg-|gap-)/.test(c))
+      s -= 20;
+    return s;
+  }
+  function cssEscape(s) {
+    return CSS.escape(s);
+  }
+  function segment(el, withClasses, withNth) {
+    let s = el.tagName.toLowerCase();
+    if (withClasses)
+      s += usefulClasses(el).map((c) => `.${cssEscape(c)}`).join("");
+    if (withNth) {
+      const siblings = el.parentElement?.children ?? el.parentNode?.children;
+      const same = Array.from(siblings ?? []).filter((c) => c.tagName === el.tagName);
+      if (same.length > 1) s += `:nth-of-type(${same.indexOf(el) + 1})`;
+    }
+    return s;
+  }
+  function isUnique(selector, el, root) {
+    try {
+      const found = root.querySelectorAll(selector);
+      return found.length === 1 && found[0] === el;
+    } catch {
+      return false;
+    }
+  }
+  var SHADOW_SEPARATOR = " >>> ";
+  function selectorWithin(el, root) {
+    if (el.id && isStableId(el.id) && isUnique(`#${cssEscape(el.id)}`, el, root))
+      return `#${cssEscape(el.id)}`;
+    const parts = [];
+    let current = el;
+    while (current && current !== document.documentElement) {
+      if (current !== el && current.id && isStableId(current.id)) {
+        parts.unshift(`#${cssEscape(current.id)}`);
+        const candidate = parts.join(" > ");
+        if (isUnique(candidate, el, root)) return candidate;
+        parts.shift();
+      }
+      for (const [cls, nth] of [
+        [true, false],
+        [true, true]
+      ]) {
+        const candidate = [segment(current, cls, nth), ...parts].join(" > ");
+        if (isUnique(candidate, el, root)) return candidate;
+      }
+      parts.unshift(segment(current, true, true));
+      current = current.parentElement;
+    }
+    return parts.join(" > ");
+  }
+  function selectorFor(el) {
+    const root = el.getRootNode();
+    if (root instanceof ShadowRoot) {
+      return `${selectorFor(root.host)}${SHADOW_SEPARATOR}${selectorWithin(el, root)}`;
+    }
+    return selectorWithin(el, document);
+  }
+  var selectors = /* @__PURE__ */ new WeakMap();
+  function cachedSelector(el) {
+    let s = selectors.get(el);
+    if (s === void 0) {
+      s = selectorFor(el);
+      selectors.set(el, s);
+    }
+    return s;
+  }
+  function lineage(el, max = 16) {
+    const out = [];
+    for (let p = composedParent(el); p && p !== document.body && out.length < max; p = composedParent(p)) {
+      out.push(cachedSelector(p));
+    }
+    return out;
+  }
+  function resolveSelector(selector) {
+    let root = document;
+    let found = null;
+    for (const part of selector.split(SHADOW_SEPARATOR)) {
+      if (!root) return null;
+      try {
+        found = root.querySelector(part);
+      } catch {
+        return null;
+      }
+      root = found?.shadowRoot ?? null;
+    }
+    return found;
+  }
+  function readablePath(el) {
+    const parts = [];
+    let current = el;
+    while (current && current !== document.body && parts.length < 4) {
+      const cls = usefulClasses(current)[0];
+      parts.unshift(current.tagName.toLowerCase() + (cls ? `.${cls}` : ""));
+      current = composedParent(current);
+    }
+    return parts.join(" > ");
+  }
+  function openingTag(el) {
+    const tag = el.tagName.toLowerCase();
+    let out = `<${tag}`;
+    for (const attr of el.attributes) {
+      if (attr.name === SOURCE_ATTR) continue;
+      const value = attr.value.length > 60 ? `${attr.value.slice(0, 60)}...` : attr.value;
+      out += value ? ` ${attr.name}="${value.replace(/"/g, "&quot;")}"` : ` ${attr.name}`;
+    }
+    out += ">";
+    return out.length > 200 ? `${out.slice(0, 197)}...>` : out;
+  }
+  function findByText(wanted) {
+    const needle = wanted.replace(/\s+/g, " ").trim().toLowerCase();
+    if (needle.length < 3 || !document.body) return null;
+    const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT);
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+      const el = node.parentElement;
+      if (!el || el.closest("script, style, noscript")) continue;
+      const r = el.getBoundingClientRect();
+      if (r.width < 1 || r.height < 1) continue;
+      for (let p = el; p && p !== document.body; p = p.parentElement) {
+        const text = (p.textContent ?? "").replace(/\s+/g, " ").toLowerCase();
+        if (text.includes(needle)) return describe(p);
+        if (text.length > needle.length * 4) break;
+      }
+    }
+    return null;
+  }
+  function describe(el) {
+    const cached = cache.get(el);
+    if (cached) return cached;
+    const text = (el.textContent ?? "").replace(/\s+/g, " ").trim();
+    const info = {
+      selector: cachedSelector(el),
+      path: readablePath(el),
+      html: openingTag(el),
+      text: text ? text.length > 80 ? `${text.slice(0, 77)}...` : text : null,
+      source: sourceOf(el)
+    };
+    cache.set(el, info);
+    owners.set(info, el);
+    return info;
+  }
+
+  // ../analyzers/src/detectors/page-overflow.ts
+  var TOLERANCE = 0.5;
+  var SIDEWAYS_CONTENT = /* @__PURE__ */ new Set(["TABLE", "PRE", "CODE"]);
+  var PAGE_CONTENT = "h1,h2,h3,h4,form,input,textarea,select,main,article";
+  function wrapperEdge(snap, rec) {
+    const container = rec.clipAncestor;
+    if (!container) return { kind: "root" };
+    const vw = snap.viewportWidth;
+    if (container.rect.left > 1 || container.rect.right < vw - 1) return null;
+    const cs = container.style;
+    if (cs.scrollSnapType && cs.scrollSnapType !== "none") return null;
+    const holdsPage = container.rect.height >= snap.viewportHeight / 2 || container.el.querySelector(PAGE_CONTENT) !== null;
+    if (!holdsPage) return null;
+    for (let p = rec; p && p !== container; p = p.parent) {
+      if (SIDEWAYS_CONTENT.has(p.el.tagName)) return null;
+      if (p.style.transform && p.style.transform !== "none") return null;
+    }
+    return {
+      kind: "wrapper",
+      container,
+      scrolls: cs.overflowX === "auto" || cs.overflowX === "scroll"
+    };
+  }
+  function sticksOut(snap, rec) {
+    if (isVisuallyHidden(rec)) return null;
+    const right = paintedRight(rec);
+    const left = paintedLeft(rec);
+    if (right <= snap.viewportWidth + TOLERANCE && left >= -TOLERANCE) return null;
+    if (rec.outOfFlow === "fixed") {
+      return rec.clipAncestor ? null : { rec, right, left, edge: { kind: "screen" } };
+    }
+    const edge = wrapperEdge(snap, rec);
+    return edge ? { rec, right, left, edge } : null;
+  }
+  function pageOverflow(snap) {
+    const hits = /* @__PURE__ */ new Map();
+    for (const rec of snap.records) {
+      const hit = sticksOut(snap, rec);
+      if (hit) hits.set(rec, hit);
+    }
+    const findings = [];
+    for (const hit of hits.values()) {
+      const { rec, edge } = hit;
+      let p = rec.parent;
+      let covered = false;
+      while (p) {
+        if (hits.has(p)) {
+          covered = true;
+          break;
+        }
+        p = p.parent;
+      }
+      if (covered) continue;
+      const vw = snap.viewportWidth;
+      const clipped = edge.kind === "root" ? snap.rootClipsX : edge.kind === "screen" || !edge.scrolls;
+      const fullyOffscreen = hit.left >= vw || hit.right <= 0;
+      if (clipped && fullyOffscreen) continue;
+      const overflowRight = Math.max(0, hit.right - vw);
+      const overflowLeft = Math.max(0, -hit.left);
+      const side = overflowRight >= overflowLeft ? "right" : "left";
+      const amount = px(Math.max(overflowRight, overflowLeft));
+      if (amount < 1) continue;
+      const endSide = snap.rtl ? "left" : "right";
+      const scrolls = side === endSide && (edge.kind === "root" ? snap.rootScrollsX : edge.kind === "wrapper" && edge.scrolls);
+      if (!scrolls && rec.outOfFlow && isDecorative(rec.el)) continue;
+      if (!scrolls && isOrnament(rec)) continue;
+      const textOnly = rec.rect.right <= vw + TOLERANCE && rec.rect.left >= -TOLERANCE;
+      let title;
+      if (!scrolls) title = `Content cut off at the ${side} edge by ${amount}px`;
+      else if (edge.kind === "root")
+        title = `Page scrolls horizontally (${amount}px wider than the viewport)`;
+      else title = `Content scrolls sideways inside a full-width container (${amount}px too wide)`;
+      findings.push({
+        suggestion: shrinkSuggestion(rec, textOnly),
+        detector: "page-overflow",
+        severity: scrolls ? "error" : "warning",
+        title,
+        element: describe(rec.el),
+        lineage: lineage(rec.el),
+        ...edge.kind === "wrapper" ? { related: describe(edge.container.el) } : {},
+        evidence: {
+          overflowPx: amount,
+          side,
+          viewportWidth: vw,
+          elementWidth: px(rec.rect.width),
+          causedByText: textOnly,
+          clippedBy: edge.kind === "root" ? snap.rootClipsX ? "page" : "none" : edge.kind === "screen" ? "screen" : "wrapper"
+        },
+        styles: pick(rec.style, [
+          "width",
+          "min-width",
+          "max-width",
+          "white-space",
+          "overflow-wrap",
+          "word-break",
+          "flex-shrink",
+          "position",
+          "margin-left",
+          "margin-right",
+          "transform"
+        ])
+      });
+    }
+    return findings;
+  }
+  function longestWord(text) {
+    let longest = "";
+    for (const raw of text.split(/\s+/)) {
+      const word = raw.replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, "");
+      if (word.length > longest.length) longest = word;
+    }
+    return longest;
+  }
+  function shrinkSuggestion(rec, textOnly) {
+    const s = rec.style;
+    if (textOnly) {
+      if (s.whiteSpace === "nowrap" || s.whiteSpace === "pre") {
+        return `white-space: ${s.whiteSpace} keeps this text on one line. Allow it to wrap on small screens.`;
+      }
+      const word = longestWord(rec.text);
+      if (word && /^[\p{L}\p{M}'’-]+$/u.test(word)) {
+        const size = Number.parseFloat(s.fontSize);
+        return size >= 24 ? `The word "${word}" is wider than the screen at ${Math.round(size)}px. Scale the text down on small screens, for example font-size: clamp(1.75rem, 4vw + 1rem, ${Math.round(size / 16 * 100) / 100}rem).` : `The word "${word}" is too long to fit here. Add hyphens: auto (with a lang attribute on the page) or overflow-wrap: break-word.`;
+      }
+      return "Long unbreakable text (a URL, email or code). Add overflow-wrap: anywhere to its container.";
+    }
+    const minWidth = Number.parseFloat(s.minWidth);
+    if (minWidth > 0) {
+      return `min-width: ${s.minWidth} stops it from shrinking. Lower it or drop it on small screens.`;
+    }
+    if (s.flexShrink === "0") {
+      return "flex-shrink: 0 stops it from shrinking. Let it shrink, or wrap the row.";
+    }
+    if (s.whiteSpace === "nowrap") {
+      return "white-space: nowrap keeps its content on one line. Allow wrapping on small screens.";
+    }
+    const parent = rec.parent?.style.display ?? "";
+    if (parent.includes("flex") || parent.includes("grid")) {
+      return "It is a flex/grid item that will not shrink below its content. Add min-width: 0 to it, or replace its fixed width with max-width: 100%.";
+    }
+    return "It is wider than the screen here. Replace any fixed width with max-width: 100% or a fluid width.";
+  }
+  var CONTENT_SELECTOR = "img,video,canvas,iframe,input,button,select,textarea,a[href]";
+  function isDecorative(el) {
+    if (el.matches(CONTENT_SELECTOR)) return false;
+    if (el.textContent?.trim()) return false;
+    if (el.querySelector(CONTENT_SELECTOR)) return false;
+    if (el.shadowRoot) return false;
+    for (const child of el.querySelectorAll("*")) if (child.shadowRoot) return false;
+    return true;
+  }
+  var DEFAULT_VALUES = {
+    "flex-shrink": "1",
+    position: "static",
+    "object-fit": "fill",
+    overflow: "visible",
+    "flex-basis": "auto",
+    transform: "none"
+  };
+  function pick(style, props) {
+    const out = {};
+    for (const prop of props) {
+      const v = style.getPropertyValue(prop);
+      if (!v || v === "none" || v === "normal" || v === "auto" || v === "0px") continue;
+      if (DEFAULT_VALUES[prop] === v) continue;
+      out[prop] = v;
+    }
+    return out;
+  }
+
+  // ../analyzers/src/detectors/containment.ts
+  var TOLERANCE2 = 1;
+  var VERTICAL_TOLERANCE = 2;
+  var MEDIA = /* @__PURE__ */ new Set(["IMG", "VIDEO", "IFRAME", "CANVAS", "EMBED", "OBJECT", "svg", "PICTURE"]);
+  function alpha(color) {
+    if (!color || color === "transparent") return 0;
+    const m = color.match(/rgba?\(([^)]+)\)/);
+    if (!m?.[1]) return 1;
+    const parts = m[1].split(/[\s,/]+/).filter(Boolean);
+    return parts.length >= 4 ? Number.parseFloat(parts[3] ?? "1") : 1;
+  }
+  function effectiveBackground(rec) {
+    let p = rec;
+    while (p) {
+      if (alpha(p.style.backgroundColor) > 0) return p.style.backgroundColor;
+      p = p.parent;
+    }
+    const body = getComputedStyle(document.body).backgroundColor;
+    if (alpha(body) > 0) return body;
+    return getComputedStyle(document.documentElement).backgroundColor;
+  }
+  function isBounded(rec) {
+    const s = rec.style;
+    if (clipsX(s) || isInline(s) || rec.rect.width < 24 || rec.rect.height < 16) return false;
+    const border = Number.parseFloat(s.borderLeftWidth) > 0 && alpha(s.borderLeftColor) > 0 || Number.parseFloat(s.borderRightWidth) > 0 && alpha(s.borderRightColor) > 0;
+    if (border) return true;
+    if (s.boxShadow && s.boxShadow !== "none") return true;
+    if (s.backgroundImage && s.backgroundImage !== "none") return true;
+    const bg = s.backgroundColor;
+    return alpha(bg) > 0 && bg !== effectiveBackground(rec.parent);
+  }
+  function sameContext(a, b) {
+    return a.oofRoot === b.oofRoot && a.clipAncestor === b.clipAncestor;
+  }
+  function overflowAmount(child, box) {
+    return Math.max(paintedRight(child) - box.right, box.left - paintedLeft(child), 0);
+  }
+  function overflowBelow(child, container) {
+    if (isInline(child.style)) return 0;
+    return Math.max(child.rect.bottom - container.rect.bottom, 0);
+  }
+  function offsetOnPurpose(rec, container) {
+    for (let p = rec; p && p !== container; p = p.parent) {
+      if (isDeliberateOffset(p) || p.style.float !== "none") return true;
+    }
+    return false;
+  }
+  function contentOverflow(snap) {
+    const bounded = /* @__PURE__ */ new Set();
+    for (const rec of snap.records) if (isBounded(rec)) bounded.add(rec);
+    const findings = [];
+    const escapes = /* @__PURE__ */ new Map();
+    for (const rec of snap.records) {
+      if (isVisuallyHidden(rec) || rec.outOfFlow === "fixed") continue;
+      let container = rec.parent;
+      while (container && !bounded.has(container)) container = container.parent;
+      if (!container || !sameContext(rec, container)) continue;
+      const sideways = overflowAmount(rec, container.rect);
+      if (sideways > TOLERANCE2) {
+        const side = paintedRight(rec) - container.rect.right >= sideways - 0.01 ? "right" : "left";
+        escapes.set(rec, { container, side, amount: sideways });
+        continue;
+      }
+      const below = overflowBelow(rec, container);
+      if (below > VERTICAL_TOLERANCE && !offsetOnPurpose(rec, container)) {
+        escapes.set(rec, { container, side: "bottom", amount: below });
+      }
+    }
+    for (const [rec, { container, side, amount: raw }] of escapes) {
+      if (rec.parent && escapes.get(rec.parent)?.container === container) continue;
+      const amount = px(raw);
+      if (side === "bottom") {
+        findings.push({
+          detector: "content-overflow",
+          severity: "error",
+          title: `Content spills ${amount}px out of the bottom of its container`,
+          element: describe(rec.el),
+          related: describe(container.el),
+          evidence: {
+            overflowPx: amount,
+            side,
+            containerHeight: px(container.rect.height),
+            elementHeight: px(rec.rect.height)
+          },
+          styles: pick(container.style, ["height", "max-height", "min-height"]),
+          suggestion: `The container is ${px(container.rect.height)}px tall and its content needs more room at this width. Use min-height instead of a fixed height.`
+        });
+        continue;
+      }
+      const textOnly = rec.rect.right <= container.rect.right + TOLERANCE2 && rec.rect.left >= container.rect.left - TOLERANCE2;
+      findings.push({
+        suggestion: shrinkSuggestion(rec, textOnly),
+        detector: "content-overflow",
+        severity: "error",
+        title: textOnly ? `Text spills ${amount}px outside its container` : `Content spills ${amount}px outside its container`,
+        element: describe(rec.el),
+        lineage: lineage(rec.el),
+        related: describe(container.el),
+        evidence: {
+          overflowPx: amount,
+          side,
+          containerWidth: px(container.rect.width),
+          elementWidth: px(rec.rect.width),
+          causedByText: textOnly
+        },
+        styles: pick(rec.style, [
+          "width",
+          "min-width",
+          "white-space",
+          "overflow-wrap",
+          "word-break",
+          "flex-shrink",
+          "flex-basis"
+        ])
+      });
+    }
+    return findings;
+  }
+  function isMedia(el) {
+    return MEDIA.has(el.tagName);
+  }
+  function mediaOverflow(snap) {
+    const findings = [];
+    for (const rec of snap.records) {
+      if (!isMedia(rec.el) || rec.outOfFlow) continue;
+      if (rec.el.tagName === "PICTURE") continue;
+      let container = rec.parent;
+      while (container && (isInline(container.style) || container.el.tagName === "PICTURE")) {
+        container = container.parent;
+      }
+      if (!container || container.clipAncestor !== rec.clipAncestor || clipsX(container.style))
+        continue;
+      const ml = Number.parseFloat(rec.style.marginLeft) || 0;
+      const mr = Number.parseFloat(rec.style.marginRight) || 0;
+      if (ml < 0 || mr < 0) continue;
+      const box = contentBox(container);
+      const excess = rec.rect.width - box.width;
+      if (excess <= TOLERANCE2 || rec.rect.right <= box.right + TOLERANCE2) continue;
+      findings.push({
+        detector: "media-overflow",
+        severity: "error",
+        title: `${label(rec.el)} is ${px(excess)}px wider than its container`,
+        element: describe(rec.el),
+        lineage: lineage(rec.el),
+        related: describe(container.el),
+        evidence: {
+          overflowPx: px(excess),
+          mediaWidth: px(rec.rect.width),
+          containerWidth: px(box.width)
+        },
+        styles: pick(rec.style, ["width", "min-width", "max-width", "height", "object-fit"]),
+        suggestion: "Add max-width: 100% and height: auto so it scales down with its container."
+      });
+    }
+    return findings;
+  }
+  function label(el) {
+    switch (el.tagName) {
+      case "IMG":
+        return "Image";
+      case "VIDEO":
+        return "Video";
+      case "IFRAME":
+      case "EMBED":
+      case "OBJECT":
+        return "Embed";
+      case "CANVAS":
+        return "Canvas";
+      default:
+        return "Graphic";
+    }
+  }
+
+  // ../analyzers/src/detectors/elements.ts
+  var MAX_DISTORTION = 0.05;
+  var MIN_TARGET = 24;
+  var TARGETS = 'a[href], button, input:not([type="hidden"]), select, textarea, summary, [role="button"], [role="link"], [role="tab"], [role="menuitem"], [role="checkbox"], [role="switch"], [tabindex]:not([tabindex="-1"])';
+  function distortedMedia(snap) {
+    const findings = [];
+    for (const rec of snap.records) {
+      if (rec.el.tagName !== "IMG" || isVisuallyHidden(rec)) continue;
+      const img = rec.el;
+      if (!img.complete || !img.naturalWidth || !img.naturalHeight) continue;
+      if (/\.svg(\?|#|$)|^data:image\/svg/i.test(img.currentSrc || img.src)) continue;
+      if (rec.style.objectFit && rec.style.objectFit !== "fill") continue;
+      const s = rec.style;
+      const w = rec.rect.width - (Number.parseFloat(s.paddingLeft) || 0) - (Number.parseFloat(s.paddingRight) || 0) - (Number.parseFloat(s.borderLeftWidth) || 0) - (Number.parseFloat(s.borderRightWidth) || 0);
+      const h = rec.rect.height - (Number.parseFloat(s.paddingTop) || 0) - (Number.parseFloat(s.paddingBottom) || 0) - (Number.parseFloat(s.borderTopWidth) || 0) - (Number.parseFloat(s.borderBottomWidth) || 0);
+      if (w < 16 || h < 16) continue;
+      const natural = img.naturalWidth / img.naturalHeight;
+      const rendered = w / h;
+      const distortion = Math.abs(rendered / natural - 1);
+      if (distortion <= MAX_DISTORTION) continue;
+      findings.push({
+        detector: "distorted-media",
+        severity: "warning",
+        title: `Image is ${rendered > natural ? "stretched" : "squashed"} ${Math.round(distortion * 100)}% out of proportion`,
+        element: describe(rec.el),
+        evidence: {
+          renderedRatio: Math.round(rendered * 100) / 100,
+          naturalRatio: Math.round(natural * 100) / 100,
+          renderedWidth: px(w),
+          renderedHeight: px(h)
+        },
+        styles: pick(rec.style, ["width", "height", "max-width", "object-fit", "aspect-ratio"]),
+        suggestion: "Keep width and height proportional (height: auto), or crop with object-fit: cover."
+      });
+    }
+    return findings;
+  }
+  function center(b) {
+    return { x: (b.left + b.right) / 2, y: (b.top + b.bottom) / 2 };
+  }
+  function distanceToBox(p, b) {
+    const dx = Math.max(b.left - p.x, 0, p.x - b.right);
+    const dy = Math.max(b.top - p.y, 0, p.y - b.bottom);
+    return Math.hypot(dx, dy);
+  }
+  function isInlineTextLink(rec) {
+    if (rec.el.tagName !== "A" || !rec.style.display.startsWith("inline")) return false;
+    const parent = rec.el.parentElement;
+    if (!parent) return false;
+    const own = rec.el.textContent?.trim().length ?? 0;
+    const around = parent.textContent?.trim().length ?? 0;
+    return around > own + 10;
+  }
+  function hasLabel(el) {
+    if (!(el instanceof HTMLInputElement)) return false;
+    if (el.type !== "checkbox" && el.type !== "radio") return false;
+    return (el.labels?.length ?? 0) > 0;
+  }
+  function smallTapTargets(snap) {
+    if (snap.viewportWidth > TOUCH_MAX_WIDTH) return [];
+    const targets = [];
+    for (const rec of snap.records) {
+      if (!rec.el.matches(TARGETS) || isVisuallyHidden(rec)) continue;
+      if (rec.el.matches('[disabled], [aria-disabled="true"]')) continue;
+      if (rec.rect.width === 0 || rec.rect.height === 0) continue;
+      let nested = false;
+      for (let p = rec.parent; p; p = p.parent) {
+        if (p.el.matches(TARGETS)) {
+          nested = true;
+          break;
+        }
+      }
+      if (!nested) targets.push(rec);
+    }
+    const failing = [];
+    for (const rec of targets) {
+      const { width, height } = rec.rect;
+      if (width >= MIN_TARGET && height >= MIN_TARGET) continue;
+      if (isInlineTextLink(rec) || hasLabel(rec.el)) continue;
+      const c = center(rec.rect);
+      const crowded = targets.some((other) => {
+        if (other === rec) return false;
+        if (distanceToBox(c, other.rect) < MIN_TARGET / 2) return true;
+        const small = other.rect.width < MIN_TARGET || other.rect.height < MIN_TARGET;
+        const oc = center(other.rect);
+        return small && Math.hypot(oc.x - c.x, oc.y - c.y) < MIN_TARGET;
+      });
+      if (crowded) failing.push(rec);
+    }
+    const siblings = /* @__PURE__ */ new Map();
+    for (const rec of targets) siblings.set(rec.parent, (siblings.get(rec.parent) ?? 0) + 1);
+    const byParent = /* @__PURE__ */ new Map();
+    for (const rec of failing) {
+      const list = byParent.get(rec.parent);
+      if (list) list.push(rec);
+      else byParent.set(rec.parent, [rec]);
+    }
+    const findings = [];
+    for (const [parent, list] of byParent) {
+      const first = list[0];
+      if (!first) continue;
+      const grouped = parent !== null && (siblings.get(parent) ?? 0) > 1;
+      const minW = Math.min(...list.map((r) => r.rect.width));
+      const minH = Math.min(...list.map((r) => r.rect.height));
+      findings.push({
+        detector: "small-tap-target",
+        severity: "warning",
+        title: list.length > 1 ? `${list.length} tap targets are ${px(minW)}\xD7${px(minH)}px and crowd each other` : `Tap target is ${px(first.rect.width)}\xD7${px(first.rect.height)}px and too close to its neighbours`,
+        element: describe(grouped ? parent.el : first.el),
+        ...grouped ? { related: describe(first.el) } : {},
+        evidence: { width: px(minW), height: px(minH), minimum: MIN_TARGET, targets: list.length },
+        styles: pick(first.style, ["width", "height", "padding", "font-size"]),
+        suggestion: "Make each target at least 24\xD724px (44\xD744px is better for touch), or add space between them."
+      });
+    }
+    return findings;
+  }
+  function viewportMeta() {
+    const meta = document.querySelector('meta[name="viewport" i]');
+    const content = meta?.getAttribute("content")?.replace(/\s+/g, "") ?? "";
+    if (/width=device-width/i.test(content)) return [];
+    const head = document.head ?? document.documentElement;
+    return [
+      {
+        detector: "viewport-meta",
+        severity: "error",
+        title: meta ? "Viewport meta tag does not use width=device-width" : "Missing the responsive viewport meta tag",
+        element: describe(meta ?? head),
+        evidence: { content: content || "missing" },
+        styles: {},
+        suggestion: 'Add <meta name="viewport" content="width=device-width, initial-scale=1"> to <head>. Without it phones render the page at desktop width and shrink it.'
+      }
+    ];
+  }
+
+  // ../analyzers/src/detectors/overlap.ts
+  var MIN_OVERLAP = 4;
+  var BAND_PX = 200;
+  var MIN_TEXT_LINE_SHARE = 0.3;
+  var REPLACED = /* @__PURE__ */ new Set([
+    "IMG",
+    "VIDEO",
+    "CANVAS",
+    "IFRAME",
+    "svg",
+    "INPUT",
+    "SELECT",
+    "TEXTAREA",
+    "BUTTON"
+  ]);
+  function itemBox(rec) {
+    const raw = REPLACED.has(rec.el.tagName) ? rec.rect : rec.textRect;
+    if (!raw || raw.width <= 0 || raw.height <= 0) return null;
+    return intersectBox(raw, rec.clip);
+  }
+  function ancestors(rec) {
+    const chain = [];
+    let p = rec;
+    while (p) {
+      chain.push(p);
+      p = p.parent;
+    }
+    return chain;
+  }
+  function isExplicitlyPlacedGridItem(rec) {
+    const s = rec.style;
+    return s.gridRowStart !== "auto" || s.gridColumnStart !== "auto";
+  }
+  function branches(a, b) {
+    const chainA = ancestors(a).reverse();
+    const chainB = ancestors(b).reverse();
+    let i = 0;
+    while (i < chainA.length && i < chainB.length && chainA[i] === chainB[i]) i++;
+    const branchA = chainA[i];
+    const branchB = chainB[i];
+    if (!branchA || !branchB) return null;
+    const lca = i > 0 ? chainA[i - 1] ?? null : null;
+    for (const rec of chainA.slice(i)) if (isDeliberateOffset(rec)) return null;
+    for (const rec of chainB.slice(i)) if (isDeliberateOffset(rec)) return null;
+    if (lca?.style.display.includes("grid")) {
+      if (isExplicitlyPlacedGridItem(branchA) && isExplicitlyPlacedGridItem(branchB)) return null;
+    }
+    return { lca, a: branchA, b: branchB };
+  }
+  function intersect(a, b) {
+    return {
+      w: Math.min(a.right, b.right) - Math.max(a.left, b.left),
+      h: Math.min(a.bottom, b.bottom) - Math.max(a.top, b.top)
+    };
+  }
+  function paintedOverlap(x, y) {
+    let best = { w: 0, h: 0 };
+    for (const a of x.parts) {
+      for (const b of y.parts) {
+        const o = intersect(a, b);
+        if (o.w > 0 && o.h > 0 && o.w * o.h > best.w * best.h) best = o;
+      }
+    }
+    return best;
+  }
+  var SPILL_PX = 2;
+  function spillOf(branch, x, y) {
+    for (const item of [x, y]) {
+      if (!ancestors(item.rec).includes(branch) || item.rec === branch) continue;
+      const box = branch.rect;
+      if (item.box.bottom > box.bottom + SPILL_PX) return { box: branch, direction: "down" };
+      if (item.box.right > box.right + SPILL_PX || item.box.left < box.left - SPILL_PX) {
+        return { box: branch, direction: "across" };
+      }
+    }
+    return null;
+  }
+  function name(rec) {
+    return `\`${describe(rec.el).selector}\``;
+  }
+  function suggestionFor(g) {
+    if (g.spill?.direction === "down") {
+      return `The content of ${name(g.spill.box)} is taller than its box at this width and runs down over what comes next. Its height is fixed (height or max-height) and the content no longer fits once it wraps; use min-height instead, or let it grow with its content.`;
+    }
+    if (g.spill?.direction === "across") {
+      return `The content of ${name(g.spill.box)} is wider than its box at this width and runs sideways into its neighbour. Let it shrink or wrap (min-width: 0 on flex or grid items, overflow-wrap: anywhere for long words, max-width: 100% for media).`;
+    }
+    const lca = g.lca;
+    const display = lca?.style.display ?? "";
+    if (lca && display.includes("flex") && !lca.style.flexDirection.startsWith("column")) {
+      return `They sit side by side in the flex row ${name(lca)}, which runs out of room at this width. Let the row wrap (flex-wrap: wrap), let the item that should give way shrink (min-width: 0), or stack them below this width with a media query.`;
+    }
+    if (lca && display.includes("grid")) {
+      return `They share the grid ${name(lca)}, whose columns are too narrow here for what is in them. Use minmax(0, 1fr) columns so items can shrink, or switch to fewer columns below this width.`;
+    }
+    return "These two areas stop making room for each other at this width. Stack them earlier with a media query, or let the narrower one shrink (min-width: 0).";
+  }
+  function overlap(snap) {
+    const items = [];
+    for (const rec of snap.records) {
+      if (rec.outOfFlow || isVisuallyHidden(rec)) continue;
+      const box = itemBox(rec);
+      if (!box || box.width < 1 || box.height < 1) continue;
+      const isText = !REPLACED.has(rec.el.tagName);
+      const parts = isText ? rec.textFragments.map((f) => intersectBox(f, rec.clip)).filter((f) => !!f && f.width > 0 && f.height > 0) : [];
+      items.push({
+        rec,
+        box,
+        parts: parts.length ? parts : [box],
+        lineHeight: isText ? box.height / Math.max(1, rec.textLines) : 0
+      });
+    }
+    const groups = /* @__PURE__ */ new Map();
+    const index = /* @__PURE__ */ new Map();
+    for (const [i, r] of snap.records.entries()) index.set(r, i);
+    const bands = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const last = Math.floor(item.box.bottom / BAND_PX);
+      for (let b = Math.floor(item.box.top / BAND_PX); b <= last; b++) {
+        const list = bands.get(b);
+        if (list) list.push(item);
+        else bands.set(b, [item]);
+      }
+    }
+    for (const [band, list] of bands) {
+      list.sort((x, y) => x.box.left - y.box.left);
+      for (let i = 0; i < list.length; i++) {
+        const x = list[i];
+        for (let j = i + 1; j < list.length; j++) {
+          const y = list[j];
+          if (y.box.left >= x.box.right - MIN_OVERLAP) break;
+          if (Math.floor(Math.max(x.box.top, y.box.top) / BAND_PX) !== band) continue;
+          const rough = intersect(x.box, y.box);
+          if (rough.w < MIN_OVERLAP || rough.h < MIN_OVERLAP) continue;
+          const { w, h } = paintedOverlap(x, y);
+          const minH = Math.max(
+            MIN_OVERLAP,
+            MIN_TEXT_LINE_SHARE * Math.max(x.lineHeight, y.lineHeight)
+          );
+          if (w < MIN_OVERLAP || h < minH) continue;
+          const split = branches(x.rec, y.rec);
+          if (!split) continue;
+          const [first, second] = (index.get(split.a) ?? 0) < (index.get(split.b) ?? 0) ? [split.a, split.b] : [split.b, split.a];
+          const key = `${index.get(first)}:${index.get(second)}`;
+          const spill = spillOf(first, x, y) ?? spillOf(second, x, y);
+          const g = groups.get(key);
+          if (g) {
+            g.w = Math.max(g.w, w);
+            g.h = Math.max(g.h, h);
+            g.pairs++;
+            g.spill ??= spill;
+          } else {
+            groups.set(key, { a: first, b: second, lca: split.lca, w, h, pairs: 1, spill });
+          }
+        }
+      }
+    }
+    const findings = [];
+    for (const g of groups.values()) {
+      findings.push({
+        detector: "overlap",
+        severity: "error",
+        title: `Overlaps another element (${px(g.w)}\xD7${px(g.h)}px)`,
+        element: describe(g.a.el),
+        related: describe(g.b.el),
+        evidence: { overlapWidth: px(g.w), overlapHeight: px(g.h), overlappingPairs: g.pairs },
+        suggestion: suggestionFor(g),
+        styles: pick(g.a.style, [
+          "display",
+          "position",
+          "width",
+          "min-width",
+          "flex-shrink",
+          "grid-template-columns"
+        ])
+      });
+    }
+    return findings;
+  }
+
+  // ../analyzers/src/detectors/text.ts
+  var CUT_TOLERANCE = 1;
+  var MIN_GUTTER = 4;
+  var MIN_TINY_FONT = 12;
+  var MAX_TINY_FINDINGS = 8;
+  var MIN_LARGE_FONT = 28;
+  var MIN_LARGE_CHARS_PER_LINE = 12;
+  var MAX_LARGE_FINDINGS = 8;
+  function scrollsOn(style, axis) {
+    const v = axis === "x" ? style.overflowX : style.overflowY;
+    return v === "auto" || v === "scroll";
+  }
+  function clipsOn(style, axis) {
+    return (axis === "x" ? style.overflowX : style.overflowY) !== "visible";
+  }
+  function truncatesOnPurpose(rec, axis) {
+    const s = rec.style;
+    if (axis === "x") return s.textOverflow === "ellipsis" || s.textOverflow === "clip";
+    return !!s.webkitLineClamp && s.webkitLineClamp !== "none";
+  }
+  function findClipper(rec, raw, axis) {
+    for (let p = rec; p; p = p.parent) {
+      if (!clipsOn(p.style, axis)) continue;
+      const cut = axis === "x" ? raw.left < p.rect.left - CUT_TOLERANCE || raw.right > p.rect.right + CUT_TOLERANCE : raw.top < p.rect.top - CUT_TOLERANCE || raw.bottom > p.rect.bottom + CUT_TOLERANCE;
+      if (cut) return p;
+    }
+    return null;
+  }
+  function clippersWithVisibleText(snap) {
+    const out = /* @__PURE__ */ new Set();
+    for (const rec of snap.records) {
+      if (!rec.textRect) continue;
+      for (let p = rec.parent; p; p = p.parent) {
+        if (out.has(p)) break;
+        if (clipsOn(p.style, "y")) out.add(p);
+      }
+    }
+    return out;
+  }
+  function clippedText(snap) {
+    const byClipper = /* @__PURE__ */ new Map();
+    const vw = snap.viewportWidth;
+    let showing = null;
+    for (const rec of snap.records) {
+      const raw = rec.rawTextRect;
+      if (!raw || rec.outOfFlow === "fixed" || isVisuallyHidden(rec) || isOrnament(rec)) continue;
+      const visible = intersectBox(raw, rec.innerClip);
+      let axis;
+      let clipper;
+      let cut;
+      if (visible) {
+        const cutX = raw.width - visible.width;
+        const cutY = raw.height - visible.height;
+        axis = cutY > CUT_TOLERANCE ? "y" : cutX > CUT_TOLERANCE ? "x" : null;
+        if (!axis) continue;
+        clipper = findClipper(rec, raw, axis);
+        cut = axis === "x" ? cutX : cutY;
+      } else {
+        axis = "y";
+        clipper = findClipper(rec, raw, "y");
+        if (!clipper || raw.top < clipper.rect.bottom - CUT_TOLERANCE) continue;
+        showing ??= clippersWithVisibleText(snap);
+        if (!showing.has(clipper)) continue;
+        cut = raw.bottom - clipper.rect.bottom;
+      }
+      if (!clipper || scrollsOn(clipper.style, axis) || clipper.rect.height < 2) continue;
+      if (axis === "x" && clipper.rect.left <= 1 && clipper.rect.right >= vw - 1) continue;
+      let deliberate = false;
+      for (let p = rec; p; p = p.parent) {
+        if (truncatesOnPurpose(p, axis) || p.style.transform && p.style.transform !== "none") {
+          deliberate = true;
+          break;
+        }
+        if (p === clipper) break;
+      }
+      if (deliberate) continue;
+      const prev = byClipper.get(clipper);
+      if (prev) {
+        prev.count++;
+        if (cut > prev.cut) Object.assign(prev, { rec, axis, cut });
+      } else {
+        byClipper.set(clipper, { rec, axis, cut, count: 1 });
+      }
+    }
+    const findings = [];
+    for (const [clipper, { rec, axis, cut, count }] of byClipper) {
+      const fixedSize = axis === "y" ? clipper.style.height : clipper.style.width;
+      findings.push({
+        detector: "clipped-text",
+        severity: "warning",
+        title: `Container cuts off its text (${px(cut)}px hidden ${axis === "y" ? "below" : "to the side"})`,
+        element: describe(clipper.el),
+        related: describe(rec.el),
+        evidence: { hiddenPx: px(cut), axis, clippedTextElements: count },
+        styles: pick(clipper.style, [
+          "height",
+          "max-height",
+          "width",
+          "max-width",
+          "overflow",
+          "white-space"
+        ]),
+        suggestion: axis === "y" ? `The container clips its content at ${fixedSize}. Let it grow (min-height instead of height), or truncate on purpose with line-clamp.` : "The container is too narrow for this text. Let the text wrap, or truncate on purpose with text-overflow: ellipsis."
+      });
+    }
+    return findings;
+  }
+  function lineText(rec) {
+    for (const child of rec.el.children) {
+      const display = getComputedStyle(child).display;
+      if (display !== "none" && !display.startsWith("inline")) return rec.text;
+    }
+    const el = rec.el;
+    return (el.innerText ?? el.textContent ?? "").replace(/\s+/g, " ").trim();
+  }
+  function squishedText(snap) {
+    const findings = [];
+    for (const rec of snap.records) {
+      if (!rec.textRect || rec.textLines < 3 || isVisuallyHidden(rec) || isInline(rec.style))
+        continue;
+      const text = lineText(rec);
+      const chars = text.replace(/\s/g, "").length;
+      if (chars < 8) continue;
+      if (rec.rect.width >= 10 * fontSize(rec)) continue;
+      const words = text.split(" ").filter(Boolean).length;
+      const perLine = chars / rec.textLines;
+      if ((rec.textLines <= words || breaksAnywhere(text)) && perLine >= 3) continue;
+      findings.push({
+        detector: "squished-text",
+        severity: "warning",
+        title: `Text squeezed to about ${Math.max(1, Math.round(perLine))} characters per line`,
+        element: describe(rec.el),
+        evidence: {
+          lines: rec.textLines,
+          charsPerLine: Math.round(perLine * 10) / 10,
+          width: px(rec.rect.width)
+        },
+        styles: pick(rec.style, ["width", "min-width", "flex-basis", "word-break", "overflow-wrap"]),
+        suggestion: "This column gets too narrow at this width. Give it a min-width, or stack the layout earlier."
+      });
+    }
+    return findings;
+  }
+  function browserDefault(rec) {
+    const control = rec.el.closest("button, input, select, textarea");
+    if (!control) return false;
+    const around = control.parentElement;
+    return !!around && fontSize(rec) < Number.parseFloat(getComputedStyle(around).fontSize);
+  }
+  function tinyText(snap) {
+    if (snap.viewportWidth > TOUCH_MAX_WIDTH) return [];
+    const byParent = /* @__PURE__ */ new Map();
+    for (const rec of snap.records) {
+      if (!rec.textRect || rec.text.length < 3 || isVisuallyHidden(rec) || isOrnament(rec)) continue;
+      const size = fontSize(rec);
+      if (size >= MIN_TINY_FONT) continue;
+      const g = byParent.get(rec.parent);
+      if (g) {
+        g.count++;
+        if (size < g.size) Object.assign(g, { rec, size });
+      } else {
+        byParent.set(rec.parent, { rec, size, count: 1 });
+      }
+    }
+    const findings = [];
+    for (const [parent, g] of byParent) {
+      if (findings.length >= MAX_TINY_FINDINGS) break;
+      const grouped = g.count > 1 && parent !== null;
+      const size = Math.round(g.size * 10) / 10;
+      findings.push({
+        detector: "tiny-text",
+        severity: "info",
+        title: g.count > 1 ? `${g.count} pieces of text are ${size}px on small screens` : `Text is ${size}px on small screens`,
+        element: describe(grouped ? parent.el : g.rec.el),
+        ...grouped ? { related: describe(g.rec.el) } : {},
+        evidence: { fontSizePx: size, textElements: g.count },
+        styles: pick(g.rec.style, ["font-size", "line-height"]),
+        suggestion: browserDefault(g.rec) ? "Form controls don't take the page's font unless told to, and Safari's default is 11px. Add font: inherit to button, input, select and textarea." : "Use at least 12px (16px for body text) on small screens."
+      });
+    }
+    return findings;
+  }
+  function forcedLines(el, style) {
+    let lines = 1;
+    const keepsNewlines = /^(pre|pre-wrap|pre-line|break-spaces)$/.test(style.whiteSpace);
+    for (const node of el.childNodes) {
+      if (node.nodeName === "BR") lines++;
+      else if (keepsNewlines && node.nodeType === Node.TEXT_NODE) {
+        lines += (node.textContent?.trim().match(/\n/g) ?? []).length;
+      }
+    }
+    return lines;
+  }
+  function oversizedText(snap) {
+    const vw = snap.viewportWidth;
+    if (vw > TOUCH_MAX_WIDTH) return [];
+    const findings = [];
+    for (const rec of snap.records) {
+      if (findings.length >= MAX_LARGE_FINDINGS) break;
+      if (!rec.textRect || rec.textLines < 3 || isVisuallyHidden(rec)) continue;
+      const size = fontSize(rec);
+      if (size < MIN_LARGE_FONT) continue;
+      const words = rec.text.split(" ").filter(Boolean).length;
+      if (words < 2) continue;
+      const chars = rec.text.replace(/\s/g, "").length;
+      const perLine = chars / rec.textLines;
+      if (perLine >= MIN_LARGE_CHARS_PER_LINE) continue;
+      if (rec.textLines > words && rec.rect.width < 10 * size) continue;
+      if (rec.style.writingMode && !rec.style.writingMode.startsWith("horizontal")) continue;
+      if (rec.outOfFlow || isOrnament(rec)) continue;
+      if (rec.textLines - forcedLines(rec.el, rec.style) < 2) continue;
+      let block = rec;
+      while (!isBlock(block) && block.parent) block = block.parent;
+      const room = block.parent ? contentBox(block.parent).width : vw;
+      if (block.rect.width < room * 0.9 || block.rect.width < vw * 0.6) continue;
+      const rem = Math.round(size / 16 * 100) / 100;
+      findings.push({
+        detector: "oversized-text",
+        severity: "warning",
+        title: `Text is too big for the screen (${px(size)}px, ${rec.textLines} lines of a word or two)`,
+        element: describe(rec.el),
+        evidence: {
+          fontSizePx: px(size),
+          lines: rec.textLines,
+          charsPerLine: Math.round(perLine * 10) / 10,
+          screenShare: Math.round(rec.textRect.height / snap.viewportHeight * 100) / 100
+        },
+        styles: pick(rec.style, ["font-size", "line-height", "letter-spacing"]),
+        suggestion: `Scale it down on small screens, for example font-size: clamp(1.75rem, 4vw + 1rem, ${rem}rem), or a smaller size below 640px.`
+      });
+    }
+    return findings;
+  }
+  function isBlock(rec) {
+    return !rec.style.display.startsWith("inline") && rec.style.display !== "contents";
+  }
+  function edgeGutter(snap) {
+    const vw = snap.viewportWidth;
+    if (vw > TOUCH_MAX_WIDTH) return [];
+    const groups = /* @__PURE__ */ new Map();
+    for (const rec of snap.records) {
+      const t = rec.textRect;
+      if (!t || rec.outOfFlow === "fixed" || isVisuallyHidden(rec) || rec.text.length < 2) continue;
+      if (isOrnament(rec)) continue;
+      if (t.left < -0.5 || t.right > vw + 0.5) continue;
+      let moves = false;
+      let overflows = rec.rect.right > vw + 0.5 || rec.rect.left < -0.5;
+      for (let p = rec.parent; p && !moves && !overflows; p = p.parent) {
+        if (scrollsOn(p.style, "x") || p.style.transform && p.style.transform !== "none") {
+          moves = true;
+        }
+        if (p.rect.right > vw + 0.5 || p.rect.left < -0.5) overflows = true;
+      }
+      if (moves || overflows) continue;
+      let container = rec;
+      while (!isBlock(container) && container.parent) container = container.parent;
+      const box = contentBox(container);
+      const leftGap = box.left;
+      const rightGap = vw - box.right;
+      let side = null;
+      if (leftGap < MIN_GUTTER && t.left < MIN_GUTTER + 0.5) side = "left";
+      else if (rightGap < MIN_GUTTER && (rec.textLines >= 2 || t.right > vw - MIN_GUTTER))
+        side = "right";
+      if (!side) continue;
+      const gap = side === "left" ? leftGap : rightGap;
+      const g = groups.get(container);
+      if (g) {
+        g.count++;
+        if (gap < g.gap) Object.assign(g, { gap, side, rec });
+      } else {
+        groups.set(container, { side, gap, count: 1, rec });
+      }
+    }
+    const findings = [];
+    for (const [container, g] of groups) {
+      findings.push({
+        detector: "edge-gutter",
+        severity: "warning",
+        title: `Text touches the ${g.side} edge of the screen (${Math.max(0, px(g.gap))}px gap)`,
+        element: describe(container.el),
+        evidence: { gapPx: Math.max(0, px(g.gap)), side: g.side, textElements: g.count },
+        styles: pick(container.style, [
+          "padding-left",
+          "padding-right",
+          "margin-left",
+          "margin-right",
+          "width"
+        ]),
+        suggestion: "Add horizontal padding (around 16px) to this container on small screens."
+      });
+    }
+    return findings;
+  }
+
+  // ../analyzers/src/detectors/wrap.ts
+  var NAV_CONTEXT = 'nav, header, [role="navigation"], [role="tablist"], [role="menubar"], [role="banner"]';
+  var LABEL = 'button, [role="button"], [role="tab"], [role="menuitem"]';
+  var MAX_LABEL_CHARS = 40;
+  function isRowContainer(rec) {
+    const s = rec.style;
+    if (s.display === "flex" || s.display === "inline-flex") {
+      return s.flexDirection.startsWith("row") && s.flexWrap !== "nowrap";
+    }
+    return false;
+  }
+  function inlineChildren(rec, byElement) {
+    const out = [];
+    for (const child of renderedChildren(rec.el)) {
+      const c = byElement.get(child);
+      if (!c || c.outOfFlow || isVisuallyHidden(c)) continue;
+      out.push(c);
+    }
+    return out;
+  }
+  function allInlineLevel(children) {
+    return children.length > 0 && children.every(
+      (c) => c.style.display.startsWith("inline") && c.style.display !== "inline-table"
+    );
+  }
+  function countRows(children) {
+    const tops = [];
+    for (const c of children) {
+      const half = Math.max(4, c.rect.height / 2);
+      if (!tops.some((t) => Math.abs(t - c.rect.top) < half)) tops.push(c.rect.top);
+    }
+    return tops.length;
+  }
+  function textLinesDeep(el) {
+    const tops = [];
+    const walker = document.createTreeWalker(el, NodeFilter.SHOW_TEXT);
+    const range = document.createRange();
+    for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+      if (!node.textContent?.trim()) continue;
+      const box = node.parentElement?.getBoundingClientRect();
+      if (box && (box.width <= 1 || box.height <= 1)) continue;
+      range.selectNodeContents(node);
+      for (const r of range.getClientRects()) {
+        if (r.width === 0 || r.height === 0) continue;
+        if (!tops.some((t) => Math.abs(t.top - r.top) < Math.max(t.height, r.height) / 2)) {
+          tops.push({ top: r.top, height: r.height });
+        }
+      }
+    }
+    return tops.length;
+  }
+  function wrapStats(snap) {
+    const stats = [];
+    for (const rec of snap.records) {
+      if (isVisuallyHidden(rec)) continue;
+      const children = inlineChildren(rec, snap.byElement);
+      if (children.length >= 2 && (isRowContainer(rec) || allInlineLevel(children))) {
+        if (closestComposed(rec.el, NAV_CONTEXT)) {
+          stats.push({
+            element: describe(rec.el),
+            kind: "row",
+            lines: countRows(children),
+            items: children.length
+          });
+        }
+      }
+      const isLabel = rec.el.matches(LABEL) || rec.el.matches("a[href]") && closestComposed(rec.el, NAV_CONTEXT) !== null;
+      if (isLabel) {
+        const text = rec.el.textContent?.replace(/\s+/g, " ").trim() ?? "";
+        if (text && text.length <= MAX_LABEL_CHARS && text.includes(" ")) {
+          stats.push({
+            element: describe(rec.el),
+            kind: "label",
+            lines: textLinesDeep(rec.el),
+            items: 1
+          });
+        }
+      }
+    }
+    return stats;
+  }
+
+  // ../analyzers/src/fingerprint.ts
+  var LANDMARKS = /* @__PURE__ */ new Set([
+    "HEADER",
+    "NAV",
+    "MAIN",
+    "ASIDE",
+    "FOOTER",
+    "SECTION",
+    "ARTICLE",
+    "FORM"
+  ]);
+  var MAX_DEPTH = 5;
+  var MAX_ELEMENTS = 400;
+  function isStructural(rec, depth) {
+    if (depth <= 3) return true;
+    if (LANDMARKS.has(rec.el.tagName)) return true;
+    const d = rec.style.display;
+    return depth <= MAX_DEPTH && (d.includes("flex") || d.includes("grid"));
+  }
+  function rowsAndColumns(children) {
+    const rows = [];
+    const counts = [];
+    for (const c of children) {
+      const tol = Math.max(4, Math.min(c.rect.height / 2, 24));
+      const i = rows.findIndex((t) => Math.abs(t - c.rect.top) < tol);
+      if (i === -1) {
+        rows.push(c.rect.top);
+        counts.push(1);
+      } else {
+        counts[i] = (counts[i] ?? 0) + 1;
+      }
+    }
+    return counts.join(".");
+  }
+  function layoutSignature(snap, index) {
+    const children = /* @__PURE__ */ new Map();
+    for (const rec of snap.records) {
+      if (!rec.parent || rec.outOfFlow === "fixed") continue;
+      const list = children.get(rec.parent);
+      if (list) list.push(rec);
+      else children.set(rec.parent, [rec]);
+    }
+    const branchDepth = /* @__PURE__ */ new Map();
+    for (const rec of snap.records) {
+      const parent = rec.parent;
+      const parentDepth = parent ? branchDepth.get(parent) ?? 0 : 0;
+      const branches2 = parent ? (children.get(parent)?.length ?? 0) > 1 : true;
+      branchDepth.set(rec, parentDepth + (branches2 ? 1 : 0));
+    }
+    const parts = [];
+    for (const rec of snap.records) {
+      if (parts.length >= MAX_ELEMENTS) break;
+      if (rec.outOfFlow === "fixed" || !isStructural(rec, branchDepth.get(rec) ?? 0)) continue;
+      const kids = (children.get(rec) ?? []).filter(
+        (c) => !c.outOfFlow && !c.style.display.startsWith("inline")
+      );
+      const s = rec.style;
+      let mode = s.display;
+      if (mode.includes("flex")) mode += `/${s.flexDirection}`;
+      const wraps = mode.includes("flex") && s.flexWrap !== "nowrap";
+      const arrangement = kids.length > 1 && !wraps ? rowsAndColumns(kids) : String(kids.length);
+      parts.push(`${index(rec.el)}=${mode}:${arrangement}`);
+    }
+    return parts.join("|");
+  }
+  var MEDIA_EM = 16;
+  var QUERY_UNITS = "(px|em|rem)";
+  function parseContainerCondition(text) {
+    const out = [];
+    const name2 = text.match(/^\s*(?!not\b|style\b|scroll-state\b)([a-zA-Z_][\w-]*)\s*(?=\(|$)/)?.[1] ?? null;
+    const add = (value, unit, after) => out.push({ name: name2, value: Number.parseFloat(value), unit, after });
+    const legacy = new RegExp(`(min|max)-(?:width|inline-size)\\s*:\\s*([\\d.]+)${QUERY_UNITS}`, "g");
+    for (let m = legacy.exec(text); m; m = legacy.exec(text)) {
+      add(m[2] ?? "0", m[3] ?? "px", m[1] === "max");
+    }
+    const range = new RegExp(`(?:width|inline-size)\\s*(>=|>|<=|<)\\s*([\\d.]+)${QUERY_UNITS}`, "g");
+    for (let m = range.exec(text); m; m = range.exec(text)) {
+      add(m[2] ?? "0", m[3] ?? "px", m[1] === "<=" || m[1] === ">");
+    }
+    const reversed = new RegExp(
+      `([\\d.]+)${QUERY_UNITS}\\s*(>=|>|<=|<)\\s*(?:width|inline-size)`,
+      "g"
+    );
+    for (let m = reversed.exec(text); m; m = reversed.exec(text)) {
+      add(m[1] ?? "0", m[2] ?? "px", m[3] === "<" || m[3] === ">=");
+    }
+    return out;
+  }
+  var queryCache = null;
+  function containerQueries() {
+    if (typeof CSSContainerRule === "undefined") return [];
+    const roots = [document, ...shadowRoots()];
+    const sheets = roots.flatMap((r) => [...r.styleSheets, ...r.adoptedStyleSheets ?? []]);
+    const key = sheets.map((s) => {
+      try {
+        return s.cssRules.length;
+      } catch {
+        return -1;
+      }
+    }).join(",");
+    if (queryCache?.key === key) return queryCache.queries;
+    const queries = [];
+    const seen = /* @__PURE__ */ new Set();
+    const walk = (rules) => {
+      for (const rule of rules) {
+        if (rule instanceof CSSContainerRule) {
+          for (const q of parseContainerCondition(rule.conditionText)) {
+            const id = `${q.name}|${q.value}${q.unit}|${q.after}`;
+            if (!seen.has(id)) {
+              seen.add(id);
+              queries.push(q);
+            }
+          }
+        }
+        if (rule instanceof CSSImportRule) {
+          try {
+            if (rule.styleSheet) walk(rule.styleSheet.cssRules);
+          } catch {
+          }
+        } else if ("cssRules" in rule && rule.cssRules) {
+          walk(rule.cssRules);
+        }
+      }
+    };
+    for (const sheet of sheets) {
+      try {
+        walk(sheet.cssRules);
+      } catch {
+      }
+    }
+    queryCache = { key, queries };
+    return queries;
+  }
+  var MAX_CONTAINER_BITS = 256;
+  function containerSignature(snap) {
+    const queries = containerQueries();
+    if (!queries.length) return void 0;
+    const rootFont = Number.parseFloat(getComputedStyle(document.documentElement).fontSize) || 16;
+    let bits = "";
+    for (const rec of snap.records) {
+      const s = rec.style;
+      if (!s.containerType || s.containerType === "normal") continue;
+      const names = s.containerName.split(/\s+/);
+      const size = rec.rect.width - (Number.parseFloat(s.paddingLeft) || 0) - (Number.parseFloat(s.paddingRight) || 0) - (Number.parseFloat(s.borderLeftWidth) || 0) - (Number.parseFloat(s.borderRightWidth) || 0);
+      for (const q of queries) {
+        if (q.name && !names.includes(q.name)) continue;
+        const unit = q.unit === "px" ? 1 : q.unit === "em" ? Number.parseFloat(s.fontSize) || 16 : rootFont;
+        const threshold = q.value * unit;
+        bits += (q.after ? size > threshold : size >= threshold) ? "1" : "0";
+        if (bits.length >= MAX_CONTAINER_BITS) return bits;
+      }
+    }
+    return bits || void 0;
+  }
+  function declaredBreakpoints() {
+    const found = /* @__PURE__ */ new Set();
+    const toPx = (value, unit) => Number.parseFloat(value) * (unit === "px" ? 1 : MEDIA_EM);
+    const after = (w) => Math.floor(w) + 1;
+    const read = (text) => {
+      const legacy = /(min|max)-width\s*:\s*([\d.]+)(px|em|rem)/g;
+      for (let m = legacy.exec(text); m; m = legacy.exec(text)) {
+        const [, kind, value = "0", unit = "px"] = m;
+        const w = toPx(value, unit);
+        found.add(Math.round(kind === "max" ? after(w) : w));
+      }
+      const range = /width\s*(>=|>|<=|<)\s*([\d.]+)(px|em|rem)/g;
+      for (let m = range.exec(text); m; m = range.exec(text)) {
+        const [, op, value = "0", unit = "px"] = m;
+        const w = toPx(value, unit);
+        found.add(Math.round(op === "<=" || op === ">" ? after(w) : w));
+      }
+      const reversed = /([\d.]+)(px|em|rem)\s*(>=|>|<=|<)\s*width/g;
+      for (let m = reversed.exec(text); m; m = reversed.exec(text)) {
+        const [, value = "0", unit = "px", op] = m;
+        const w = toPx(value, unit);
+        found.add(Math.round(op === "<" || op === ">=" ? after(w) : w));
+      }
+    };
+    const walk = (rules) => {
+      for (const rule of rules) {
+        if (typeof CSSContainerRule !== "undefined" && rule instanceof CSSContainerRule) {
+          continue;
+        }
+        if (rule instanceof CSSMediaRule) read(rule.conditionText ?? rule.media.mediaText);
+        else if (rule instanceof CSSImportRule) {
+          read(rule.media.mediaText);
+          readSheet(rule.styleSheet);
+          continue;
+        }
+        if ("cssRules" in rule && rule.cssRules)
+          walk(rule.cssRules);
+      }
+    };
+    const readSheet = (sheet) => {
+      if (!sheet) return;
+      read(sheet.media.mediaText);
+      try {
+        walk(sheet.cssRules);
+      } catch {
+      }
+    };
+    const roots = [document, ...shadowRoots()];
+    for (const root of roots) {
+      for (const sheet of root.styleSheets) readSheet(sheet);
+      for (const sheet of root.adoptedStyleSheets ?? []) readSheet(sheet);
+    }
+    return [...found].filter((w) => w > 0).sort((a, b) => a - b);
+  }
+
+  // ../analyzers/src/states.ts
+  var CANDIDATES = [
+    "[aria-expanded]",
+    "[aria-haspopup]",
+    "[popovertarget]",
+    "[commandfor]",
+    "[data-bs-toggle]",
+    "[data-toggle]",
+    "details > summary",
+    "button",
+    '[role="button"]'
+  ].join(",");
+  var MENU_CLASS = /(hamburger|burger|navbar-toggler|nav-?toggle|toggle-?nav|menu-?(toggle|button|btn|icon|trigger)|toggle-?menu|mobile-?(menu|nav)-?(toggle|button|btn|trigger)?|drawer-?toggle|sidebar-?toggle|offcanvas-?toggle)/i;
+  var MENU_LABEL = /^(?:(?:open|toggle|show)\s+)?(?:the\s+)?(?:(?:main|site|mobile|primary)\s+)?(?:menu|navigation|nav|sidebar)(?:\s+menu)?$|^[☰≡]$/i;
+  var MAX_TOGGLES = 40;
+  function nameOf(el) {
+    const aria = el.getAttribute("aria-label")?.trim();
+    if (aria) return aria;
+    const by = el.getAttribute("aria-labelledby");
+    if (by) {
+      const text2 = by.split(/\s+/).map((id) => document.getElementById(id)?.textContent ?? "").join(" ").replace(/\s+/g, " ").trim();
+      if (text2) return text2;
+    }
+    const text = (el.textContent ?? "").replace(/\s+/g, " ").trim();
+    if (text) return text;
+    return el.getAttribute("title")?.trim() ?? "";
+  }
+  function shortLabel(el, kind) {
+    const name2 = nameOf(el);
+    if (!/[\p{L}\p{N}]/u.test(name2)) return kind;
+    return name2.length > 40 ? `${name2.slice(0, 37)}...` : name2;
+  }
+  function targetOf(el, attr) {
+    const id = el.getAttribute(attr);
+    if (!id) return null;
+    return el.getRootNode().getElementById?.(id) ?? null;
+  }
+  function bootstrapKind(value) {
+    switch (value) {
+      case "modal":
+        return "dialog";
+      case "offcanvas":
+      case "dropdown":
+        return "menu";
+      case "collapse":
+        return "disclosure";
+      default:
+        return null;
+    }
+  }
+  function looksLikeMenu(el) {
+    const names = [
+      typeof el.className === "string" ? el.className : "",
+      el.id,
+      el.getAttribute("data-testid") ?? ""
+    ].join(" ");
+    return MENU_CLASS.test(names) || MENU_LABEL.test(nameOf(el));
+  }
+  function kindOf(el) {
+    if (el.matches("details > summary")) {
+      const details = el.parentElement;
+      return details.open || details.querySelector(":scope > summary") !== el ? null : "details";
+    }
+    if (el.matches('input, select, textarea, [role="combobox"], [contenteditable]')) return null;
+    if (el.hasAttribute("popovertarget")) {
+      return el.getAttribute("popovertargetaction") === "hide" ? null : "popover";
+    }
+    if (el.hasAttribute("commandfor")) {
+      const command = el.getAttribute("command");
+      if (command === "show-modal") return "dialog";
+      if (command === "toggle-popover" || command === "show-popover") return "popover";
+      return null;
+    }
+    const expanded = el.getAttribute("aria-expanded");
+    if (expanded === "true") return null;
+    const popup = el.getAttribute("aria-haspopup");
+    if (popup === "dialog") return "dialog";
+    if (popup && popup !== "false") return "menu";
+    const bootstrap = bootstrapKind(
+      el.getAttribute("data-bs-toggle") ?? el.getAttribute("data-toggle")
+    );
+    if (bootstrap) return bootstrap;
+    if (expanded === "false") return looksLikeMenu(el) ? "menu" : "disclosure";
+    if (el.matches('button, [role="button"]') && looksLikeMenu(el)) return "menu";
+    return null;
+  }
+  function safeToClick(el) {
+    if (el.matches(':disabled, [aria-disabled="true"]')) return false;
+    if (el instanceof HTMLButtonElement && el.type === "submit" && el.form) return false;
+    const href = el instanceof HTMLAnchorElement ? el.getAttribute("href") : null;
+    return !href || href.startsWith("#") || /^javascript:/i.test(href);
+  }
+  function isShown(el) {
+    const r = el.getBoundingClientRect();
+    if (r.width < 1 || r.height < 1) return false;
+    if (r.right <= 0 || r.left >= window.innerWidth) return false;
+    const check = el.checkVisibility;
+    if (check && !check.call(el, { opacityProperty: true, visibilityProperty: true })) return false;
+    if (!check && getComputedStyle(el).visibility === "hidden") return false;
+    return !el.closest('[aria-hidden="true"], [inert]');
+  }
+  function ignored(el, rules) {
+    const marked = closestComposed(el, "[data-breakhound-ignore]");
+    if (marked) {
+      const scope = (marked.getAttribute("data-breakhound-ignore") ?? "").split(/[\s,]+/);
+      if (scope.every((s) => !s) || scope.includes("all") || scope.includes("states")) return true;
+    }
+    return rules.some((rule) => {
+      if (rule.detectors) return false;
+      try {
+        return Boolean(closestComposed(el, rule.selector));
+      } catch {
+        return false;
+      }
+    });
+  }
+  function groupOf(el, kind) {
+    const shape = (e) => e ? `${e.tagName}.${[...e.classList].map((c) => c.replace(/\d+/g, "")).sort().join(".")}` : "";
+    const panel = targetOf(el, "aria-controls");
+    return `${kind}|${shape(el)}|${shape(el.parentElement)}|${panel ? shape(panel) : ""}`;
+  }
+  var PRIORITY = {
+    menu: 0,
+    dialog: 0,
+    popover: 1,
+    disclosure: 2,
+    details: 3
+  };
+  function findToggles(rules = []) {
+    const out = [];
+    const panels = /* @__PURE__ */ new Set();
+    for (const el of document.querySelectorAll(CANDIDATES)) {
+      if (out.length >= MAX_TOGGLES) break;
+      if (el.closest(DEV_OVERLAYS)) continue;
+      const kind = kindOf(el);
+      if (!kind || !safeToClick(el) || !isShown(el) || ignored(el, rules)) continue;
+      const panel = targetOf(el, "aria-controls") ?? targetOf(el, "popovertarget");
+      if (panel) {
+        if (panels.has(panel)) continue;
+        panels.add(panel);
+      }
+      const inHeader = Boolean(el.closest('header, nav, [role="banner"], [role="navigation"]'));
+      out.push({
+        selector: cachedSelector(el),
+        kind,
+        label: shortLabel(el, kind),
+        group: groupOf(el, kind),
+        priority: PRIORITY[kind] * 2 + (inHeader ? 0 : 1)
+      });
+    }
+    return out;
+  }
+  function toggleState(selector) {
+    const el = resolveSelector(selector);
+    if (!el) return { shown: false, open: null };
+    const shown = isShown(el);
+    if (el.matches("details > summary")) {
+      return { shown, open: el.parentElement.open };
+    }
+    const expanded = el.getAttribute("aria-expanded");
+    if (expanded === "true" || expanded === "false") return { shown, open: expanded === "true" };
+    const target = targetOf(el, "popovertarget") ?? targetOf(el, "commandfor");
+    if (target instanceof HTMLDialogElement) return { shown, open: target.open };
+    if (target?.hasAttribute("popover")) {
+      try {
+        return { shown, open: target.matches(":popover-open") };
+      } catch {
+        return { shown, open: null };
+      }
+    }
+    return { shown, open: null };
+  }
+  function setDetails(selector, open) {
+    const details = resolveSelector(selector)?.parentElement;
+    if (details instanceof HTMLDetailsElement) details.open = open;
+  }
+  function clickPoint(selector) {
+    const el = resolveSelector(selector);
+    if (!el) return null;
+    let r = el.getBoundingClientRect();
+    if (r.top < 0 || r.bottom > window.innerHeight) {
+      el.scrollIntoView({ block: "center", inline: "nearest" });
+      r = el.getBoundingClientRect();
+    }
+    const x = Math.min(window.innerWidth - 1, Math.max(0, r.left + r.width / 2));
+    const y = Math.min(window.innerHeight - 1, Math.max(0, r.top + r.height / 2));
+    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 null;
+    return hit === el || el.contains(hit) || el.getRootNode() !== document && hit.contains(el) ? { x, y } : null;
+  }
+  var before = null;
+  function markShown() {
+    before = new WeakSet([document.body]);
+    for (const el of document.body.querySelectorAll("*")) if (isShown(el)) before.add(el);
+  }
+  function newlyShown(toggle) {
+    const seen = before;
+    before = null;
+    if (!seen) return null;
+    const trigger = resolveSelector(toggle);
+    let best = null;
+    for (const el of document.body.querySelectorAll("*")) {
+      if (seen.has(el) || trigger && (trigger === el || trigger.contains(el))) continue;
+      if (el.parentElement && !seen.has(el.parentElement) && isShown(el.parentElement)) continue;
+      if (!isShown(el)) continue;
+      const r = el.getBoundingClientRect();
+      const area = r.width * r.height;
+      if (!best || area > best.area) best = { el, area };
+    }
+    return best && best.area >= 2e3 ? cachedSelector(best.el) : null;
+  }
+  function selectorShown(selector) {
+    const el = resolveSelector(selector);
+    return el ? isShown(el) : false;
+  }
+
+  // ../analyzers/src/types.ts
+  var DETECTOR_IDS = [
+    "page-overflow",
+    "content-overflow",
+    "media-overflow",
+    "overlap",
+    "unexpected-wrap",
+    "clipped-text",
+    "squished-text",
+    "distorted-media",
+    "small-tap-target",
+    "tiny-text",
+    "oversized-text",
+    "edge-gutter",
+    "viewport-meta"
+  ];
+
+  // ../analyzers/src/highlight.ts
+  var OVERLAY_ATTR = "data-breakhound-overlay";
+  function find(selector) {
+    return selector ? resolveSelector(selector) : null;
+  }
+  function overlay(style) {
+    const div = document.createElement("div");
+    div.setAttribute(OVERLAY_ATTR, "");
+    Object.assign(div.style, {
+      position: "absolute",
+      zIndex: "2147483647",
+      pointerEvents: "none",
+      ...style
+    });
+    document.documentElement.appendChild(div);
+  }
+  function highlight(opts) {
+    const target = find(opts.selector);
+    if (!target) return null;
+    const boxes = [{ el: target, color: "#e11d48" }];
+    const other = find(opts.related);
+    if (other && other !== target) boxes.push({ el: other, color: "#f59e0b" });
+    const sx = window.scrollX;
+    const sy = window.scrollY;
+    const vw = document.documentElement.clientWidth;
+    let top = Number.POSITIVE_INFINITY;
+    let bottom = Number.NEGATIVE_INFINITY;
+    let right = vw;
+    for (const { el, color } of boxes) {
+      const r = el.getBoundingClientRect();
+      if (r.width === 0 && r.height === 0) continue;
+      top = Math.min(top, r.top + sy);
+      bottom = Math.max(bottom, r.bottom + sy);
+      right = Math.max(right, r.right + sx);
+      overlay({
+        left: `${r.left + sx - 2}px`,
+        top: `${r.top + sy - 2}px`,
+        width: `${r.width + 4}px`,
+        height: `${r.height + 4}px`,
+        outline: `3px solid ${color}`,
+        background: `${color}14`
+      });
+    }
+    if (!Number.isFinite(top)) return null;
+    const docHeight = document.documentElement.scrollHeight;
+    const y = Math.max(0, top - opts.pad);
+    const end = Math.min(docHeight, bottom + opts.pad, y + opts.maxHeight);
+    if (opts.showEdge) {
+      overlay({
+        left: `${vw - 1}px`,
+        top: `${y}px`,
+        width: "0",
+        height: `${end - y}px`,
+        borderLeft: "2px dashed #2563eb"
+      });
+    }
+    const scrollWidth = document.documentElement.scrollWidth;
+    return {
+      x: 0,
+      y,
+      width: Math.min(Math.max(vw, Math.ceil(right) + 16), Math.max(vw, scrollWidth)),
+      height: Math.max(1, end - y)
+    };
+  }
+  function clearHighlights() {
+    for (const el of document.querySelectorAll(`[${OVERLAY_ATTR}]`)) el.remove();
+  }
+
+  // ../analyzers/src/settle.ts
+  var frame = () => new Promise((resolve) => requestAnimationFrame(() => resolve()));
+  async function settleAfterResize(maxWaitMs) {
+    await frame();
+    await frame();
+    const probe = window.__breakhound_settle;
+    if (probe && probe.pending() > 0) {
+      const deadline = performance.now() + maxWaitMs;
+      while (probe.pending() > 0 && performance.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      await frame();
+      await frame();
+    }
+    window.scrollTo(0, 0);
+  }
+
+  // ../analyzers/src/index.ts
+  var DETECTORS = {
+    "page-overflow": pageOverflow,
+    "media-overflow": mediaOverflow,
+    "content-overflow": contentOverflow,
+    overlap,
+    "clipped-text": clippedText,
+    "squished-text": squishedText,
+    "distorted-media": distortedMedia,
+    "small-tap-target": smallTapTargets,
+    "tiny-text": tinyText,
+    "oversized-text": oversizedText,
+    "edge-gutter": edgeGutter,
+    "viewport-meta": viewportMeta
+  };
+  var IGNORE_ATTR = "data-breakhound-ignore";
+  function parseDetectors(value) {
+    const list = (value ?? "").split(/[\s,]+/).filter(Boolean);
+    return list.length === 0 || list.includes("all") ? "all" : new Set(list);
+  }
+  function isIgnored(info, detector, rules) {
+    if (!info) return false;
+    const el = elementOf(info);
+    if (!el) return false;
+    for (let p = el; p; p = composedParent(p)) {
+      if (!p.hasAttribute(IGNORE_ATTR)) continue;
+      const scope = parseDetectors(p.getAttribute(IGNORE_ATTR));
+      if (scope === "all" || scope.has(detector)) return true;
+    }
+    for (const rule of rules) {
+      if (rule.detectors && !rule.detectors.includes(detector)) continue;
+      try {
+        if (closestComposed(el, rule.selector)) return true;
+      } catch {
+      }
+    }
+    return false;
+  }
+  function analyze(options = {}) {
+    const enabled = new Set(options.detectors ?? DETECTOR_IDS);
+    const rules = options.ignore ?? [];
+    const snap = snapshot();
+    const findings = [];
+    for (const [id, run] of Object.entries(DETECTORS)) {
+      if (!enabled.has(id)) continue;
+      for (const f of run(snap)) {
+        if (isIgnored(f.element, id, rules) || isIgnored(f.related, id, rules)) continue;
+        findings.push(f);
+      }
+    }
+    const wraps = enabled.has("unexpected-wrap") ? wrapStats(snap).filter((w) => !isIgnored(w.element, "unexpected-wrap", rules)) : [];
+    const containers = containerSignature(snap);
+    return {
+      width: snap.viewportWidth,
+      findings,
+      wraps,
+      signature: layoutSignature(snap, cachedSelector),
+      ...containers ? { containers } : {},
+      ...options.toggles ? { toggles: findToggles(rules) } : {}
+    };
+  }
+  var MEDIA_CONTENT = /* @__PURE__ */ new Set([
+    "IMG",
+    "SVG",
+    "svg",
+    "CANVAS",
+    "VIDEO",
+    "IFRAME",
+    "OBJECT",
+    "EMBED"
+  ]);
+  function hasContent() {
+    const visit = (el) => {
+      if (el.matches(DEV_OVERLAYS)) return false;
+      if (MEDIA_CONTENT.has(el.tagName)) {
+        const r = el.getBoundingClientRect();
+        return r.width > 0 && r.height > 0;
+      }
+      for (const node of el.childNodes) {
+        if (node.nodeType === Node.TEXT_NODE && node.textContent?.trim()) {
+          const range = document.createRange();
+          range.selectNodeContents(node);
+          if (range.getClientRects().length > 0) return true;
+        }
+      }
+      return renderedChildren(el).some(visit);
+    };
+    return document.body ? visit(document.body) : false;
+  }
+
+  // ../analyzers/src/inject.ts
+  var api = {
+    analyze,
+    declaredBreakpoints,
+    settleAfterResize,
+    highlight,
+    clearHighlights,
+    hasContent,
+    resolveSelector,
+    toggleState,
+    setDetails,
+    clickPoint,
+    markShown,
+    newlyShown,
+    selectorShown,
+    findByText
+  };
+  window.__breakhound = api;
+})();