@leonidstern/census 0.0.0-stage → 0.2.0

package/dist/census.mjs

@@ -0,0 +1,2111 @@
+// src/color.ts
+function parseColor(css) {
+  let m = css.match(/^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)(?:\s*[,/]\s*([\d.]+%?))?\s*\)$/);
+  if (m) return [+m[1], +m[2], +m[3], m[4] === void 0 ? 1 : m[4].endsWith("%") ? parseFloat(m[4]) / 100 : +m[4]];
+  m = css.match(/^color\(srgb\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)(?:\s*\/\s*([\d.]+%?))?\s*\)$/);
+  if (m) return [+m[1] * 255, +m[2] * 255, +m[3] * 255, m[4] === void 0 ? 1 : m[4].endsWith("%") ? parseFloat(m[4]) / 100 : +m[4]];
+  m = css.match(/^#([0-9a-f]{3,8})$/i);
+  if (m && [3, 4, 6, 8].includes(m[1].length)) {
+    const h = m[1].length <= 4 ? [...m[1]].map((x) => x + x).join("") : m[1];
+    return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16), h.length === 8 ? parseInt(h.slice(6, 8), 16) / 255 : 1];
+  }
+  return painted(css);
+}
+var paints = /* @__PURE__ */ new Map();
+var probeHost = null;
+var kept = null;
+function colorProbe(host) {
+  probeHost = host;
+  kept = null;
+}
+var paintCtx;
+function painted(css) {
+  if (!/^[a-z(]/i.test(css) || css.length > 240) return null;
+  const had = paints.get(css);
+  if (had !== void 0) return had;
+  if (paintCtx === void 0) {
+    try {
+      const c = typeof document === "undefined" ? null : document.createElement("canvas");
+      if (c) {
+        c.width = c.height = 1;
+      }
+      paintCtx = c?.getContext("2d", { willReadFrequently: true }) ?? null;
+    } catch {
+      paintCtx = null;
+    }
+  }
+  let out = null;
+  try {
+    if (typeof document !== "undefined" && document.body) {
+      const probe = kept ?? document.createElement("i");
+      probe.style.color = "";
+      probe.style.color = `color-mix(in srgb, ${css} 100%, transparent)`;
+      if (probe.style.color) {
+        if (!probeHost) {
+          probe.style.display = "none";
+          document.body.append(probe);
+        } else if (!kept) {
+          probeHost.append(probe);
+          kept = probe;
+        }
+        const said = getComputedStyle(probe).color;
+        if (!probeHost) probe.remove();
+        const m = said.match(/^color\(srgb\s+([-\d.e]+)\s+([-\d.e]+)\s+([-\d.e]+)(?:\s*\/\s*([\d.e]+))?\s*\)$/);
+        if (m) out = [Math.min(255, Math.max(0, +m[1] * 255)), Math.min(255, Math.max(0, +m[2] * 255)), Math.min(255, Math.max(0, +m[3] * 255)), m[4] === void 0 ? 1 : +m[4]];
+      }
+    }
+  } catch {
+    out = null;
+  }
+  try {
+    if (!out && paintCtx) {
+      paintCtx.clearRect(0, 0, 1, 1);
+      paintCtx.fillStyle = "#000";
+      paintCtx.fillStyle = css;
+      if (paintCtx.fillStyle !== "#000000" || /^(#0{3,8}|black|rgba?\(0[,\s]+0[,\s]+0\)?)/i.test(css)) {
+        paintCtx.fillRect(0, 0, 1, 1);
+        const d = paintCtx.getImageData(0, 0, 1, 1).data;
+        out = [d[0], d[1], d[2], d[3] / 255];
+      }
+    }
+  } catch {
+    out = null;
+  }
+  if (paints.size < 200) paints.set(css, out);
+  return out;
+}
+function over(top, under) {
+  const a = top[3];
+  return [top[0] * a + under[0] * (1 - a), top[1] * a + under[1] * (1 - a), top[2] * a + under[2] * (1 - a), 1];
+}
+var lum = (c) => {
+  const ch = (v) => {
+    const x = v / 255;
+    return x <= 0.03928 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * ch(c[0]) + 0.7152 * ch(c[1]) + 0.0722 * ch(c[2]);
+};
+function contrast(a, b) {
+  const x = lum(a), y = lum(b);
+  return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05);
+}
+
+// src/findings.ts
+var CHECKS = {
+  off: { level: "rule", what: "a value off rules.json (colors, type, radii, shadows)" },
+  "no-part": { level: "rule", what: "a control none of rules.parts drew" },
+  contrast: { level: "accessibility", preset: "recommended@1", what: "text contrast, WCAG 1.4.3" },
+  focus: { level: "accessibility", preset: "recommended@1", what: "focus visible, WCAG 2.4.7" },
+  target: { level: "accessibility", preset: "recommended@1", what: "target size, WCAG 2.5.8" },
+  max: { level: "max", preset: "best-practice@1", what: "more distinct values in a group than best practice" }
+};
+var PRESETS = ["recommended@1", "best-practice@1"];
+var MAX_DEFAULTS = {
+  font: 2,
+  type: 8,
+  text: 6,
+  fill: 12,
+  line: 4,
+  radius: 4,
+  shadow: 5,
+  height: 6,
+  layer: 3
+};
+var COLOR_GROUPS = ["fill", "text", "line"];
+var presetsOf = (rules) => (typeof rules.extends === "string" ? [rules.extends] : rules.extends ?? []).filter((e) => PRESETS.includes(e));
+var hasValues = (rules) => !!(rules.colors || rules.type || rules.radii || rules.shadows || rules.parts);
+function checkSetting(rules, check) {
+  const c = CHECKS[check];
+  if (!c) return { level: null };
+  const s = rules.checks?.[check];
+  const byPreset = !!c.preset && presetsOf(rules).includes(c.preset);
+  const byDefault = check === "max" && (!!rules.max || !hasValues(rules));
+  const base = c.level === "rule" || byPreset || byDefault ? c.level : null;
+  if (s === void 0) return { level: base };
+  if (s === "off") return { level: null };
+  if (s === "rule") return { level: "rule" };
+  if (typeof s === "number") return { level: base ?? c.level, n: s };
+  if (Array.isArray(s)) return { level: "rule", n: s[1] };
+  return { level: base };
+}
+var asksChecks = (rules) => !!(rules.extends || rules.checks && Object.values(rules.checks).some((v) => v !== "off") || checkSetting(rules, "max").level);
+function maxFindings(groups, rules, name = 3) {
+  const want = checkSetting(rules, "max");
+  if (!want.level) return [];
+  const level = want.level;
+  const capOf = (group) => rules.max?.[group] ?? MAX_DEFAULTS[group];
+  const out = [];
+  for (const g of groups) {
+    const cap2 = capOf(g.name);
+    if (cap2 === void 0 || cap2 === "off") continue;
+    const n = g.rows.length + (g.more ?? 0);
+    if (n <= cap2) continue;
+    const over2 = n - cap2;
+    const tail = [...g.rows].sort((a, b) => a.n - b.n).slice(0, Math.min(name, over2)).map((r) => `${r.key}${(r.note ?? "").replace(/ \((from|via) .*$/, "")}${r.n ? ` \xD7${r.n}` : ""}${r.at[0] ? `: ${r.at[0]}` : ""}`);
+    out.push({ id: `max|${g.name}`, check: "max", level, key: `${g.name} ${n} values, ${cap2} the max: drop ${over2}, rarest first`, n, at: [...tail, ...over2 > tail.length ? [`... ${over2 - tail.length} more`] : []] });
+  }
+  const palette = Object.keys(rules.colors ?? {}).length;
+  const paletteCap = COLOR_GROUPS.reduce((sum, g) => {
+    const c = capOf(g);
+    return typeof c === "number" ? sum + c : sum;
+  }, 0);
+  if (palette && paletteCap && palette > paletteCap) out.push({ id: "max|rules.json|colors", check: "max", level, key: `rules.json lists ${palette} colors, ${paletteCap} the max`, n: palette, at: [] });
+  return out;
+}
+function findingLines(c, max = 12) {
+  const out = [];
+  const fs = (c.findings ?? []).filter((f) => f.level === "accessibility");
+  if (fs.length) {
+    const lines = [...fs].sort((a, b) => Number(!!a.unsure) - Number(!!b.unsure) || b.n - a.n).slice(0, max).map((f) => `  ${f.key}${f.n > 1 ? ` \xD7${f.n}` : ""}${f.unsure ? " (unsure)" : ""}${f.note ?? ""}${f.at.length ? `: ${f.at.join("; ")}` : ""}`);
+    out.push(`accessibility (${fs.length}, WCAG 2.2 AA; unsure: computed styles can't decide)`, ...lines, ...fs.length > max ? [`  ... ${fs.length - max} more`] : []);
+  }
+  const ms = (c.findings ?? []).filter((f) => f.level === "max");
+  if (ms.length) {
+    out.push(`max (${ms.length} over, best practice)`);
+    for (const f of ms) {
+      out.push(`  ${f.key}${f.note ?? ""}`);
+      for (const a of f.at) out.push(`    ${a}`);
+    }
+  }
+  return out;
+}
+function mergeFindings(pages) {
+  const names = Object.keys(pages);
+  if (!names.some((p) => pages[p].findings)) return void 0;
+  const by = /* @__PURE__ */ new Map();
+  for (const p of names) for (const f of pages[p].findings ?? []) {
+    if (f.level === "max") continue;
+    const had = by.get(f.id), at = f.at.slice(0, 1).map((x) => `[${p}] ${x}`);
+    if (!had) {
+      by.set(f.id, { f: { ...f, at, values: f.values ? [...f.values] : void 0 }, pages: [p] });
+      continue;
+    }
+    had.f.n += f.n;
+    had.pages.push(p);
+    if (had.f.at.length < 3) had.f.at.push(...at);
+    if (f.values) had.f.values = [.../* @__PURE__ */ new Set([...had.f.values ?? [], ...f.values])];
+    had.f.unsure = had.f.unsure && f.unsure;
+  }
+  return [...by.values()].map(({ f, pages: ps }) => ({ ...f, note: `${f.note ?? ""} (${ps.length === names.length && names.length > 1 ? "all" : ps.join("+")})` }));
+}
+function diffFindings(before, after, max = 40) {
+  const a = new Map((before.findings ?? []).map((f) => [f.id, f])), b = new Map((after.findings ?? []).map((f) => [f.id, f]));
+  const line = (f, extra = "") => `  ${f.key}${extra}${f.n > 1 ? ` \xD7${f.n}` : ""}${f.unsure ? " (unsure)" : ""}${f.at[0] ? `: ${f.at[0]}` : ""}`;
+  const capped = (l) => l.length > max ? [...l.slice(0, max), `  ... ${l.length - max} more`] : l;
+  const newRules = [], newAccessibility = [], maxWorse = [], nw = [], fixed = [], worse = [], better = [];
+  for (const [id, f] of b) {
+    const was = a.get(id);
+    if (f.level === "max") {
+      if (!was) {
+        maxWorse.push(f);
+        worse.push(`  ${f.key}`);
+      } else if (f.n > was.n) {
+        maxWorse.push(f);
+        worse.push(`  ${f.key} (was ${was.n})`);
+      } else if (f.n < was.n) better.push(`  ${f.key} (was ${was.n})`);
+      continue;
+    }
+    const more = was ? (f.values ?? []).filter((v) => !(was.values ?? []).includes(v)) : [];
+    if (was && !more.length) continue;
+    (f.level === "rule" ? newRules : newAccessibility).push(f);
+    if (f.level === "accessibility") nw.push(line(f, more.length ? ` (now also ${more.slice(0, 6).join(", ")})` : ""));
+  }
+  for (const [id, f] of a) {
+    if (b.has(id)) continue;
+    if (f.level === "accessibility") fixed.push(line(f));
+    else if (f.level === "max") better.push(`  ${f.key.replace(/:.*$/, "")} \u2014 now under`);
+  }
+  const lines = [
+    ...nw.length ? [`accessibility new (${nw.length})`, ...capped(nw)] : [],
+    ...fixed.length ? [`accessibility fixed (${fixed.length})`, ...capped(fixed)] : [],
+    ...worse.length ? [`max worse (${worse.length})`, ...capped(worse)] : [],
+    ...better.length ? [`max better (${better.length})`, ...capped(better)] : []
+  ];
+  return { lines, newRules, newAccessibility, maxWorse };
+}
+
+// src/census.ts
+var POPUP = "[role=menu],[role=listbox],[role=dialog],[role=alertdialog]";
+var PRESSABLE = "button,a[href],[role=button],[role=tab],[role=option],[role=menuitem],[role=switch],[role=checkbox],[role=radio],[role=treeitem],[role=row],[data-item],[data-section]";
+var MADE = /^(react-aria|_r_|:r|«r|radix-|base-ui-|headlessui-|mui-)/;
+var ownId = (el) => el.id && !MADE.test(el.id) ? el.id : "";
+var PROBLEM = /^(outside|cut-text|overlap|wrapped|no-edge|faint|faded|squeezed|covered|faint-drawn|hidden-drawn) /;
+var REGION = "[role=dialog],[role=alertdialog],[role=menu],[role=listbox],[role=toolbar],[role=tablist],[role=region],header,nav,aside,main";
+var box = (r) => `${Math.round(r.left)},${Math.round(r.top)} ${Math.round(r.width)}x${Math.round(r.height)}`;
+var shown = (el, r) => r.width > 0 && r.height > 0 && r.bottom > 0 && r.right > 0 && r.top < innerHeight && r.left < innerWidth && (typeof el.checkVisibility !== "function" || el.checkVisibility({ opacityProperty: true, visibilityProperty: true }));
+var ownText = (el) => [...el.childNodes].filter((n) => n.nodeType === 3).map((n) => n.textContent ?? "").join("").trim().replace(/\s+/g, " ");
+var WORDY = "button,a,label,h1,h2,h3,h4,h5,h6,[role=button],[role=menuitem],[role=menuitemcheckbox],[role=menuitemradio],[role=option],[role=tab],[role=heading],[role=switch],[role=checkbox],[role=radio]";
+function nameOf(el) {
+  if (ownId(el)) return `#${el.id}`;
+  const role = el.getAttribute("role"), label = el.getAttribute("aria-label");
+  const own = el.closest(WORDY) && !el.closest("[data-census-private]") ? ownText(el) : null;
+  const words2 = (label ?? own ?? "").slice(0, 40);
+  return `${role ?? el.tagName.toLowerCase()}${words2 ? ` ${JSON.stringify(words2)}` : ""}`;
+}
+var inside = (el) => {
+  for (let p = el.parentElement; p; p = p.parentElement) if (ownId(p)) return ` in #${p.id}`;
+  return "";
+};
+function layoutLines(root = document.body, cap2 = 160, skip, faint = FAINT_TEXT) {
+  const regions = [], wrong = [];
+  const texts = [];
+  const controls = [];
+  const seeing = looking();
+  const clipOf = /* @__PURE__ */ new Map();
+  const room = (el) => {
+    if (!el || el === document.documentElement) return new DOMRect(0, 0, innerWidth, innerHeight);
+    if (clipOf.has(el)) return clipOf.get(el);
+    const up = room(el.parentElement);
+    let out = up;
+    if (up && el instanceof HTMLElement && !/visible/.test(getComputedStyle(el).overflow)) out = cross(up, el.getBoundingClientRect());
+    clipOf.set(el, out);
+    return out;
+  };
+  const all = root.querySelectorAll("*");
+  for (let i = 0; i < all.length && i < 8e3; i++) {
+    const el = all[i];
+    if (el.closest("svg") && el.tagName.toLowerCase() !== "svg") continue;
+    if (skip?.(el)) continue;
+    const full = el.getBoundingClientRect();
+    if (el instanceof HTMLElement && full.width > 0 && full.height < 24 && el.scrollHeight > 40 && el.children.length && wrong.length < 60 && /auto|scroll/.test(getComputedStyle(el).overflowY) && (typeof el.checkVisibility !== "function" || el.checkVisibility({ visibilityProperty: true }))) {
+      wrong.push(`squeezed ${nameOf(el)}${inside(el)} ${box(full)}: shows ${Math.round(full.height)}px of ${el.scrollHeight}px`);
+    }
+    if (!shown(el, full)) continue;
+    const space = room(el.parentElement);
+    const r = space && cross(space, full);
+    if (!r) continue;
+    if (el instanceof HTMLElement && wrong.length < 60) {
+      const cs = getComputedStyle(el);
+      if (/flex/.test(cs.display) && cs.flexWrap === "wrap") {
+        const kids = [...el.children].map((c) => ({ c, r: c.getBoundingClientRect() })).filter((k) => k.r.width > 0 && k.r.height > 0);
+        const top = Math.min(...kids.map((k) => k.r.top));
+        const down = kids.filter((k) => k.r.top >= top + Math.max(4, kids[0]?.r.height ?? 0) * 0.75 && k.c.matches(`${WORDY},[id],[aria-label]`));
+        if (kids.length > 1 && down.length) wrong.push(`wrapped ${nameOf(el)}${inside(el)} ${box(full)}: ${down.slice(0, 3).map((k) => nameOf(k.c)).join(", ")} dropped to the next line`);
+      }
+      if (el.matches(PRESSABLE) && !el.closest(OFF)) {
+        const op = seeing.opacity(el);
+        if (op < 0.35) wrong.push(`faded ${nameOf(el)}${inside(el)} ${box(full)}: opacity ${op.toFixed(2)} but not disabled`);
+        else if (r.width >= 4 && r.height >= 4 && (ownId(el) || el.getAttribute("aria-label") || ownText(el))) controls.push({ el, r });
+        const svg = !el.textContent?.trim() ? el.querySelector("svg") : null;
+        if (svg && op >= 0.35) {
+          const ratio = seeing.ratio(el, getComputedStyle(svg).color, op);
+          if (ratio !== null && ratio < FAINT_ICON) wrong.push(`faint ${nameOf(el)}${inside(el)} ${box(full)}: icon contrast ${ratio.toFixed(1)}:1 ${seeing.say(el, getComputedStyle(svg).color)}`);
+        }
+      }
+      if (el.matches("button,[role=button]")) {
+        const bg = cs.backgroundColor;
+        if (!/^(transparent|rgba\([^)]*, 0\))$/.test(bg) && !(parseFloat(cs.borderTopWidth) > 0 && cs.borderTopColor !== bg)) {
+          let up = el.parentElement, under = "";
+          while (up && !under) {
+            const b = getComputedStyle(up).backgroundColor;
+            if (!/^(transparent|rgba\([^)]*, 0\))$/.test(b)) under = b;
+            else up = up.parentElement;
+          }
+          if (under === bg && !(cs.outlineStyle !== "none" && parseFloat(cs.outlineWidth) > 0) && !shadowLayers(cs.boxShadow).rings.length) wrong.push(`no-edge ${nameOf(el)}${inside(el)} ${box(full)}: same color as ${up ? nameOf(up) : "the page"} behind it (${((c) => c ? `rgb(${c.slice(0, 3).map(Math.round).join(",")})` : bg)(parseColor(bg))})`);
+        }
+      }
+    }
+    if ((el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) && el.placeholder && !el.value && wrong.length < 60 && full.width >= 24) {
+      const cs = getComputedStyle(el), ps = getComputedStyle(el, "::placeholder");
+      const ctx = measure ??= document.createElement("canvas").getContext("2d");
+      if (ctx) {
+        ctx.font = `${ps.fontStyle} ${ps.fontWeight} ${ps.fontSize} ${ps.fontFamily}`;
+        const said = ps.textTransform === "uppercase" ? el.placeholder.toUpperCase() : ps.textTransform === "lowercase" ? el.placeholder.toLowerCase() : el.placeholder;
+        const need = ctx.measureText(said).width + (parseFloat(ps.letterSpacing) || 0) * said.length;
+        const lines = el instanceof HTMLTextAreaElement ? Math.max(1, Math.floor((el.clientHeight - parseFloat(cs.paddingTop) - parseFloat(cs.paddingBottom)) / (parseFloat(ps.lineHeight) || parseFloat(ps.fontSize) * 1.2 || 1))) : 1;
+        const has = (el.clientWidth - parseFloat(cs.paddingLeft) - parseFloat(cs.paddingRight) - (parseFloat(cs.textIndent) || 0)) * lines;
+        if (need > has + 1) wrong.push(`cut-text placeholder of ${nameOf(el)}${inside(el)} ${box(full)} needs ${Math.ceil(need)}px, has ${Math.floor(has)}px${cs.textOverflow === "ellipsis" ? " (ends in \u2026)" : ""}`);
+      }
+    }
+    if ((ownId(el) || el.matches(REGION)) && full.width >= 24 && full.height >= 12) {
+      regions.push(`${nameOf(el)} ${box(full)}`);
+      const W = innerWidth, H = innerHeight;
+      const scrolls = (axis) => {
+        for (let p = el.parentElement; p; p = p.parentElement) if (/auto|scroll/.test(getComputedStyle(p)[axis])) return true;
+        return false;
+      };
+      if ((full.top < -1 && space.top <= 1 || full.bottom > H + 1 && space.bottom >= H - 1) && !scrolls("overflowY") || (full.left < -1 && space.left <= 1 || full.right > W + 1 && space.right >= W - 1) && !scrolls("overflowX")) wrong.push(`outside ${nameOf(el)} ${box(full)} window ${W}x${H}`);
+    }
+    if (!ownText(el)) continue;
+    const range = document.createRange();
+    const nodes = [...el.childNodes].filter((n2) => n2.nodeType === 3 && n2.textContent?.trim());
+    range.setStartBefore(nodes[0]);
+    range.setEndAfter(nodes[nodes.length - 1]);
+    const words2 = cross(r, range.getBoundingClientRect());
+    if (words2) texts.push({ el, r: words2, layer: el.closest(POPUP) });
+    if (el instanceof HTMLElement) {
+      const cs = getComputedStyle(el);
+      if (words2 && wrong.length < 60 && !el.closest(OFF)) {
+        const ratio = seeing.ratio(el, cs.color, seeing.opacity(el));
+        if (ratio !== null && ratio < faint) wrong.push(`faint ${nameOf(el)}${inside(el)} ${box(full)}: contrast ${ratio.toFixed(1)}:1 ${seeing.say(el, cs.color)}`);
+      }
+      const clips = cs.textOverflow === "ellipsis" || /hidden|clip/.test(cs.overflowX + cs.overflowY);
+      if (clips && full.width > 2 && full.height > 2 && (el.scrollWidth > el.clientWidth + 1 || el.scrollHeight > el.clientHeight + 1)) {
+        wrong.push(`cut-text ${nameOf(el)}${inside(el)} ${box(full)} needs ${el.scrollWidth}x${el.scrollHeight}`);
+      }
+    }
+  }
+  const showing = (el, r) => {
+    for (const c of document.elementsFromPoint(r.left + r.width / 2, r.top + r.height / 2)) {
+      if (c === el || el.contains(c) || c.contains(el)) return true;
+      if (!/^(transparent|rgba\([^)]*, 0\))$/.test(getComputedStyle(c).backgroundColor)) return false;
+    }
+    return true;
+  };
+  const peek = new CSSStyleSheet();
+  peek.replaceSync("* { pointer-events: auto !important; }");
+  const sheets = [...document.adoptedStyleSheets];
+  document.adoptedStyleSheets = [...sheets, peek];
+  const inert = [...document.querySelectorAll("[inert]")];
+  for (const e of inert) e.inert = false;
+  const n = Math.min(texts.length, 700);
+  try {
+    for (let a = 0; a < n && wrong.length < cap2; a++) {
+      for (let b = a + 1; b < n; b++) {
+        const A = texts[a], B = texts[b];
+        const x = cross(A.r, B.r);
+        if (x && x.width > 3 && x.height > 3 && A.layer === B.layer && !A.el.contains(B.el) && !B.el.contains(A.el) && showing(A.el, A.r) && showing(B.el, B.r)) wrong.push(`overlap ${nameOf(A.el)} ${box(A.r)} / ${nameOf(B.el)} ${box(B.r)}`);
+      }
+    }
+    for (const c of controls.slice(0, 300)) {
+      if (wrong.length >= cap2) break;
+      if (c.el.closest(POPUP)) continue;
+      const by = coverOf(c.el, c.r);
+      if (by) wrong.push(`covered ${nameOf(c.el)}${inside(c.el)} ${box(c.r)}: under ${nameOf(by)}${inside(by)}`);
+    }
+  } finally {
+    document.adoptedStyleSheets = sheets;
+    for (const e of inert) e.inert = true;
+  }
+  const head = [`window ${innerWidth}x${innerHeight}`];
+  const rest = cap2 - head.length - Math.min(wrong.length, 60);
+  return [...head, ...wrong.slice(0, 60), ...regions.slice(0, Math.max(0, rest))];
+}
+var OFF = "[disabled],[aria-disabled=true],[inert],[data-census-dim]";
+var measure;
+var FAINT_TEXT = 2;
+var FAINT_ICON = 1.5;
+var clear = (c) => !c || c[3] < 0.02;
+function looking() {
+  const bg = /* @__PURE__ */ new Map(), op = /* @__PURE__ */ new Map();
+  const base = () => {
+    for (const e of [document.body, document.documentElement]) {
+      const c = e && parseColor(getComputedStyle(e).backgroundColor);
+      if (c && !clear(c)) return over(c, [255, 255, 255, 1]);
+    }
+    return [255, 255, 255, 1];
+  };
+  const back = (el) => {
+    if (!el) return base();
+    const had = bg.get(el);
+    if (had) return had;
+    const c = parseColor(getComputedStyle(el).backgroundColor);
+    const out = clear(c) ? back(el.parentElement) : c[3] >= 0.995 ? c : over(c, back(el.parentElement));
+    bg.set(el, out);
+    return out;
+  };
+  const opacity = (el) => {
+    if (!el) return 1;
+    const had = op.get(el);
+    if (had !== void 0) return had;
+    const out = (parseFloat(getComputedStyle(el).opacity) || 0) * opacity(el.parentElement);
+    op.set(el, out);
+    return out;
+  };
+  return {
+    opacity,
+    back,
+    /** The contrast of `color` drawn at `alpha` in el, against what's behind el. */
+    ratio(el, color, alpha) {
+      const fg = parseColor(color);
+      if (!fg) return null;
+      const under = back(el);
+      return contrast(over([fg[0], fg[1], fg[2], fg[3] * alpha], under), under);
+    },
+    say: (el, color) => {
+      const rgb = (c) => `rgb(${c.slice(0, 3).map(Math.round).join(",")})`, fg = parseColor(color);
+      return `(${fg ? rgb(fg) : color.replace(/\s+/g, "")} on ${rgb(back(el))})`;
+    }
+  };
+}
+function behind(el) {
+  if (!el) return [255, 255, 255, 1];
+  const c = parseColor(getComputedStyle(el).backgroundColor);
+  return clear(c) ? behind(el.parentElement) : c[3] >= 0.995 ? c : over(c, behind(el.parentElement));
+}
+function coverOf(el, r) {
+  for (const c of document.elementsFromPoint(r.left + r.width / 2, r.top + r.height / 2)) {
+    if (c === el || el.contains(c) || c.contains(el)) return null;
+    if (c.closest(POPUP)) return null;
+    const cr = c.getBoundingClientRect();
+    if (cr.width * cr.height > innerWidth * innerHeight * 0.8) continue;
+    const bg = parseColor(getComputedStyle(c).backgroundColor);
+    if (bg && bg[3] > 0.5 || c.tagName === "CANVAS" || c.tagName === "IMG" || c.tagName === "VIDEO") return c;
+  }
+  return null;
+}
+function sayAlign(a, dir) {
+  if (a === "center" || a === "-webkit-center") return "center";
+  if (a === "justify") return "justify";
+  const rtl = dir === "rtl";
+  return a === "end" || a === "right" && !rtl || a === "left" && rtl ? "end" : "start";
+}
+var SAY_JUSTIFY = { center: "center", "flex-end": "end", end: "end", right: "end", "space-between": "between", "space-around": "around", "space-evenly": "evenly" };
+var SAY_ITEMS = { center: "center", "flex-start": "start", start: "start", "flex-end": "end", end: "end", baseline: "baseline" };
+var sayGaps = (g) => {
+  const lo = Math.min(...g), hi = Math.max(...g);
+  return lo === hi ? `${lo}` : g.length <= 6 ? g.join(" ") : `${lo}-${hi}`;
+};
+function layoutOf(el, cs, r, filled) {
+  if (r.width < 4 || r.height < 4) return null;
+  const flex = /flex/.test(cs.display), grid = /grid/.test(cs.display);
+  const pad = [cs.paddingTop, cs.paddingRight, cs.paddingBottom, cs.paddingLeft].map((v) => Math.round(parseFloat(v) || 0));
+  const padded = pad.some(Boolean);
+  if (!flex && !grid && !(filled && padded)) return null;
+  const kids = [...el.children].map((c) => ({ c, b: c.getBoundingClientRect() })).filter(({ c, b }) => b.width > 0 && b.height > 0 && !/^(absolute|fixed)$/.test(getComputedStyle(c).position));
+  if (!kids.length || (flex || grid) && kids.length < 2 && !(filled && padded)) return null;
+  const parts = [];
+  if (grid) {
+    const cols = cs.gridTemplateColumns.split(/\s+(?![^(]*\))/).filter(Boolean).length;
+    const rg = Math.round(parseFloat(cs.rowGap) || 0), cg = Math.round(parseFloat(cs.columnGap) || 0);
+    parts.push(`grid ${cols} col${cols > 1 ? "s" : ""}`);
+    if (rg || cg) parts.push(rg === cg ? `gap ${rg}` : `gap ${rg}/${cg}`);
+  } else if (flex) {
+    const col = /column/.test(cs.flexDirection);
+    parts.push(`${col ? "column" : "row"}${cs.flexWrap === "wrap" ? " wrap" : ""}`);
+    const sorted = [...kids].sort((a, b) => col ? a.b.top - b.b.top : a.b.left - b.b.left);
+    const set = Math.round(parseFloat(col ? cs.rowGap : cs.columnGap) || 0), gaps = [], from = /* @__PURE__ */ new Set();
+    const m = (e, side) => parseFloat(getComputedStyle(e).getPropertyValue(`margin-${side}`)) || 0;
+    for (let i = 1; i < sorted.length; i++) {
+      const a = sorted[i - 1], b = sorted[i];
+      if (!col && Math.min(a.b.bottom, b.b.bottom) - Math.max(a.b.top, b.b.top) <= 0) continue;
+      const g = Math.round(col ? b.b.top - a.b.bottom : b.b.left - a.b.right), mg = Math.round(col ? m(a.c, "bottom") + m(b.c, "top") : m(a.c, "right") + m(b.c, "left"));
+      gaps.push(g);
+      if (set) from.add("gap");
+      if (mg > 0) from.add("margins");
+      if (g - set - mg > 1) from.add("free space");
+    }
+    if (gaps.length) {
+      if (Math.min(...gaps) < 0) parts.push("overlapping");
+      else if (Math.max(...gaps) > 0) parts.push(`${new Set(gaps).size > 1 ? "gaps" : "gap"} ${sayGaps(gaps)}${from.size && !(from.size === 1 && from.has("gap")) ? ` (${[...from].map((f) => f === "gap" ? `gap ${set}` : f).join(" and ")})` : ""}`);
+    }
+  } else parts.push("box");
+  if (padded) parts.push(`pad ${pad.every((p) => p === pad[0]) ? pad[0] : pad[0] === pad[2] && pad[1] === pad[3] ? `${pad[0]} ${pad[1]}` : pad.join(" ")}`);
+  if (flex) {
+    const j = SAY_JUSTIFY[cs.justifyContent], it = SAY_ITEMS[cs.alignItems];
+    if (j) parts.push(`justify ${j}`);
+    if (it) parts.push(`items ${it}`);
+    const grow = kids.filter((k) => parseFloat(getComputedStyle(k.c).flexGrow) > 0).length;
+    if (grow) parts.push(grow === kids.length ? "children grow" : `${grow} of ${kids.length} grow`);
+  }
+  return { key: parts.join(" "), kids: `${kids.length}: ${kids.slice(0, 3).map((k) => nameOf(k.c)).join(", ")}${kids.length > 3 ? ", \u2026" : ""}` };
+}
+function cross(a, b) {
+  const l = Math.max(a.left, b.left), t = Math.max(a.top, b.top), r = Math.min(a.right, b.right), btm = Math.min(a.bottom, b.bottom);
+  return r > l && btm > t ? new DOMRect(l, t, r - l, btm - t) : null;
+}
+var hex = (c) => `#${c.slice(0, 3).map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}${c[3] < 0.995 ? Math.round(c[3] * 255).toString(16).padStart(2, "0") : ""}`;
+var num = (v) => String(Math.round(v * 10) / 10);
+var splitTop = (s) => {
+  const parts = [];
+  let depth = 0, from = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "(" || c === "[") depth++;
+    else if (c === ")" || c === "]") depth--;
+    else if (c === "," && !depth) {
+      parts.push(s.slice(from, i));
+      from = i + 1;
+    }
+  }
+  parts.push(s.slice(from));
+  return parts.map((x) => x.trim());
+};
+function shadowLayers(css) {
+  const out = { rings: [], rest: [] };
+  if (!css || css === "none") return out;
+  for (const layer of splitTop(css)) {
+    let color = "", inset = false;
+    const len = [];
+    const words2 = layer.replace(/[a-z-]+\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)|#[0-9a-f]{3,8}\b/i, (m) => {
+      color = m;
+      return " ";
+    });
+    for (const w of words2.trim().split(/\s+/)) {
+      if (w === "inset") inset = true;
+      else if (/^-?[\d.]+(e[+-]?\d+)?(px)?$/.test(w)) len.push(parseFloat(w));
+      else if (w) color ||= w;
+    }
+    const [x = 0, y = 0, blur = 0, spread = 0] = len;
+    const c = color ? parseColor(color) : null;
+    if (c && c[3] < 0.02 || !x && !y && !blur && !spread) continue;
+    const say = c ? hex(c) : color || "currentcolor";
+    if (!x && !y && !blur) out.rings.push(`${say} ${num(Math.abs(spread))}px (ring${inset ? " inset" : ""})`);
+    else out.rest.push(`${[x, y, blur, spread].map((v) => v ? `${num(v)}px` : "0").join(" ")} ${say}${inset ? " inset" : ""}`);
+  }
+  return out;
+}
+function stateOf(el) {
+  const a = (k) => el.getAttribute(k);
+  const out = [];
+  if (el.disabled === true || a("aria-disabled") === "true" || a("data-disabled") !== null) out.push("disabled");
+  if (a("aria-selected") === "true" || a("aria-checked") === "true" || a("aria-pressed") === "true" || (a("aria-current") ?? "false") !== "false" || /^(on|active|checked|selected)$/.test(a("data-state") ?? "") || a("data-selected") !== null) out.push("selected");
+  if (a("aria-expanded") === "true" || a("data-state") === "open") out.push("open");
+  return out.join(" ");
+}
+function fontDiff(stack, first) {
+  const fam = (s) => s.split(",").map((x) => x.trim()).filter(Boolean);
+  const a = fam(stack), b = fam(first);
+  const plus = a.filter((x) => !b.includes(x)), minus = b.filter((x) => !a.includes(x));
+  if (!plus.length && !minus.length) return `the first stack in another order: ${a.join(", ")}`;
+  if (plus.length + minus.length > a.length + b.length - plus.length - minus.length) return a.join(", ");
+  return `the first stack${plus.length ? ` plus ${plus.map((x) => `${x}${a[0] === x ? " (in front)" : ""}`).join(", ")}` : ""}${minus.length ? ` minus ${minus.join(", ")}` : ""}`;
+}
+var PART_PROPS = ["variant", "size", "tone", "intent", "kind", "appearance", "shape", "density"];
+var MORE_PROPS = ["color", "colorScheme", "colorPalette", "status", "severity", "level"];
+var compName = (t, depth = 0) => {
+  if (depth > 3) return "";
+  if (typeof t === "function") return t.displayName ?? t.name ?? "";
+  if (t && typeof t === "object") {
+    const o = t;
+    return o.displayName ?? compName(o.render ?? o.type, depth + 1);
+  }
+  return "";
+};
+var PLAIN = /^[A-Z][A-Za-z0-9]{2,}$/;
+var PLUMBING = /(Provider|Context|Consumer|Boundary|Slot|Portal|Fragment|FocusManager|FocusScope|FocusTrap|Presence)$/;
+var fiberKey = "";
+var fiberOf = (el) => {
+  const bag = el;
+  if (!fiberKey || !(fiberKey in bag)) {
+    const k = Object.keys(el).find((x) => x.startsWith("__reactFiber$"));
+    if (!k) return null;
+    fiberKey = k;
+  }
+  return bag[fiberKey] ?? null;
+};
+var propsOf = (f, keys = PART_PROPS) => keys.flatMap((k) => {
+  const v = f.memoizedProps?.[k];
+  return (typeof v === "string" || typeof v === "number") && /^[\w.-]{1,20}$/.test(String(v)) ? [`${k}=${v}`] : [];
+}).join(" ");
+var named = (f) => {
+  const n = compName(f.type);
+  return PLAIN.test(n) && !PLUMBING.test(n) ? n : "";
+};
+var family = (name) => name.match(/^[A-Za-z][a-z0-9]*/)?.[0] ?? name;
+var obj = (v) => v && typeof v === "object" ? v : null;
+var propsIn = (o, keys = PART_PROPS) => o ? keys.flatMap((k) => {
+  let v = o[k];
+  if (typeof v === "function") {
+    try {
+      v = /^\[(?:Input )?Signal: (.*)\]$/.exec(String(v))?.[1];
+    } catch {
+      v = void 0;
+    }
+  }
+  return (typeof v === "string" || typeof v === "number") && /^[\w.-]{1,20}$/.test(String(v)) ? [`${k}=${v}`] : [];
+}).join(" ") : "";
+var baseName = (file) => typeof file === "string" ? file.replace(/^.*[\\/]/, "").replace(/\.(vue|svelte|[jt]sx?)$/, "") : "";
+function otherChain(el) {
+  const e = el, out = [];
+  const add = (name, props, src) => {
+    if (PLAIN.test(name) && !PLUMBING.test(name)) out.push({ name, props, fiber: null, gap: false, src });
+  };
+  for (let inst = obj(e.__vueParentComponent), i = 0; inst && i < 12; inst = obj(inst.parent), i++) {
+    if (obj(inst.subTree)?.el !== el && obj(inst.vnode)?.el !== el) break;
+    const type = obj(inst.type) ?? {};
+    add(String(type.name ?? type.__name ?? "") || baseName(type.__file), propsIn(obj(inst.props)), String(obj(obj(inst.parent)?.type)?.__file ?? "") || void 0);
+  }
+  if (out.length) return out;
+  for (let vm = obj(e.__vue__), i = 0; vm && vm.$el === el && i < 12; vm = obj(vm.$parent), i++) {
+    const o = obj(vm.$options) ?? {};
+    add(String(o.name ?? o._componentTag ?? "") || baseName(o.__file), propsIn(obj(vm.$props)), String(obj(obj(vm.$parent)?.$options)?.__file ?? "") || void 0);
+  }
+  if (out.length) return out;
+  const meta = obj(e.__svelte_meta), file = obj(meta?.loc)?.file;
+  if (typeof file === "string") {
+    const up = obj(el.parentElement?.__svelte_meta);
+    if (obj(up?.loc)?.file !== file) {
+      const name = baseName(file);
+      let src;
+      for (let p = obj(meta.parent), i = 0; p && i < 20; p = obj(p.parent), i++) if (p.type === "component" && (!p.componentTag || p.componentTag === name) && typeof p.file === "string") {
+        src = `${p.file}:${p.line ?? 0}`;
+        break;
+      }
+      add(name, "", src);
+    }
+    return out;
+  }
+  const ng = obj(globalThis.ng);
+  if (ng && typeof ng.getComponent === "function") {
+    const get = ng.getComponent;
+    for (const host of [el, el.parentElement && el.parentElement.children.length === 1 ? el.parentElement : null]) {
+      if (!host) continue;
+      let c = null;
+      try {
+        c = obj(get(host));
+      } catch {
+        c = null;
+      }
+      if (c) {
+        add(String(c.constructor?.name ?? "").replace(/Component$/, ""), propsIn(c));
+        break;
+      }
+    }
+  }
+  return out;
+}
+var NOT_APP = /node_modules|react-dom|react-jsx|jsx-dev-runtime|react-server|scheduler|\(native\)|<anonymous>/;
+function fiberSrc(f) {
+  const b = obj(f);
+  if (!b) return "";
+  const ds = obj(b._debugSource);
+  if (ds && typeof ds.fileName === "string") return `${ds.fileName}:${ds.lineNumber ?? 0}`;
+  const st = obj(b._debugStack)?.stack;
+  if (typeof st !== "string") return "";
+  const frames = [];
+  for (const line of st.split("\n").slice(1)) {
+    const m = /((?:https?|file|webpack|turbopack|webpack-internal):\/\/[^\s()]+?):(\d+):(\d+)\)?\s*$/.exec(line);
+    if (m && !NOT_APP.test(m[1])) frames.push(`${m[1]}:${m[2]}:${m[3]}`);
+    if (frames.length === 3) break;
+  }
+  return frames.length ? `{${frames.join(" ")}}` : "";
+}
+function partInfo(el, parts) {
+  const tag = el.getAttribute("data-part");
+  if (tag) {
+    const props = (e) => ["variant", "size", "tone"].flatMap((k) => {
+      const v = e.getAttribute(`data-${k}`);
+      return v ? [`${k}=${v.slice(0, 20)}`] : [];
+    }).join(" ");
+    let say2 = [tag, props(el)].filter(Boolean).join(" ");
+    if (!props(el)) for (let p = el.parentElement, i = 0; p && i < 6; p = p.parentElement, i++) {
+      const t = p.getAttribute("data-part");
+      if (t && family(t) === family(tag) && props(p)) {
+        say2 = `${tag} of ${t} ${props(p)}`;
+        break;
+      }
+    }
+    return { say: say2, key: say2, fiber: null, listed: !parts?.length || parts.includes(tag), cand: true, own: false };
+  }
+  const start = fiberOf(el);
+  let chain = [];
+  let gap = false;
+  if (!start) chain = otherChain(el);
+  else for (let f = start.return, i = 0; f && typeof f.type !== "string" && chain.length < 16 && i < 80; f = f.return, i++) {
+    const raw = compName(f.type);
+    if (/(Provider|Context|Consumer|Boundary)$/.test(raw)) gap = chain.length > 0;
+    else if (PLAIN.test(raw) && !PLUMBING.test(raw)) {
+      chain.push({ name: raw, props: propsOf(f), fiber: f, gap });
+      gap = false;
+    }
+  }
+  if (!chain.length) return null;
+  const text = (c) => c.props ? `${c.name} ${c.props}` : c.name;
+  const inner = chain.find((c) => c.props);
+  let main = chain.find((c) => parts?.includes(c.name));
+  const listed = !!main;
+  const reach = (from, ok) => {
+    let to = from;
+    for (const c of chain.slice(chain.indexOf(from) + 1)) {
+      if (c.gap) break;
+      if (ok(c)) to = c;
+    }
+    return to;
+  };
+  if (main) main = reach(main, (c) => !!parts?.includes(c.name) && family(c.name) === family(main.name));
+  else if (inner) main = reach(inner, (c) => !!c.props);
+  else main = chain[0];
+  let key = text(main);
+  if (!main.props && start) {
+    let hosts = 0;
+    for (let f = start.return, i = 0; f && i < 60 && hosts < 6; f = f.return, i++) {
+      if (typeof f.type === "string") {
+        hosts++;
+        continue;
+      }
+      const name = hosts ? named(f) : "";
+      if (name && family(name) === family(main.name) && propsOf(f)) {
+        key = `${main.name} of ${name} ${propsOf(f)}`;
+        break;
+      }
+    }
+  }
+  const say = inner && inner !== main && inner.name !== main.name && chain.indexOf(inner) < chain.indexOf(main) ? `${key} < ${text(inner)}` : key;
+  return { say, key, fiber: main.fiber, listed, cand: listed || key.includes("="), own: listed || !!main.props, src: start ? void 0 : main.src };
+}
+function partOf(el, parts) {
+  return partInfo(el, parts)?.say ?? "";
+}
+var identEnd = (s, i) => {
+  while (i < s.length) {
+    if (s[i] === "\\") i += 2;
+    else if (/[\w-]/.test(s[i]) || s.charCodeAt(i) > 127) i++;
+    else break;
+  }
+  return i;
+};
+var closeOf = (s, i) => {
+  let d = 0;
+  for (; i < s.length; i++) {
+    if (s[i] === "\\") i++;
+    else if (s[i] === "(" || s[i] === "[") d++;
+    else if ((s[i] === ")" || s[i] === "]") && !--d) return i + 1;
+  }
+  return s.length;
+};
+function specificity(sel) {
+  let n = 0;
+  for (let i = 0; i < sel.length; ) {
+    const c = sel[i];
+    if (c === "\\") i += 2;
+    else if (c === "#") {
+      n += 1e6;
+      i = identEnd(sel, i + 1);
+    } else if (c === ".") {
+      n += 1e3;
+      i = identEnd(sel, i + 1);
+    } else if (c === "[") {
+      n += 1e3;
+      i = closeOf(sel, i);
+    } else if (c === ":") {
+      const el = sel[i + 1] === ":", from = i + (el ? 2 : 1), to = identEnd(sel, from), name = sel.slice(from, to).toLowerCase();
+      const end = sel[to] === "(" ? closeOf(sel, to) : to, arg = end > to ? sel.slice(to + 1, end - 1) : "";
+      if (el || /^(before|after|first-line|first-letter)$/.test(name)) n += 1;
+      else if (/^(is|not|has|matches|-webkit-any|-moz-any)$/.test(name)) n += Math.max(0, ...splitTop(arg).map(specificity));
+      else if (name !== "where") n += 1e3 + (/^nth-(last-)?child$/.test(name) && / of /.test(arg) ? Math.max(0, ...splitTop(arg.slice(arg.indexOf(" of ") + 4)).map(specificity)) : 0);
+      i = end;
+    } else if (/[a-zA-Z_]/.test(c) || sel.charCodeAt(i) > 127) {
+      n += 1;
+      i = identEnd(sel, i);
+    } else i++;
+  }
+  return n;
+}
+var ON_STATE = /\[(?:data-state=["']?(?:on|active|checked|selected)["']?|aria-(?:pressed|checked|selected)=["']?true["']?|data-(?:selected|checked|on)(?:=[^\]]*)?)\]/;
+var PRESSED_ATTR = /\[data-pressed(?:=[^\]]*)?\]/;
+var pressedIsOnIn = (sel, list) => {
+  const alt = (arms) => arms.some((x) => PRESSED_ATTR.test(x)) && arms.some((x) => ON_STATE.test(x) && !PRESSED_ATTR.test(x));
+  if (alt(list)) return true;
+  for (const m of sel.matchAll(/:(?:is|where|matches|-webkit-any)\(/g)) {
+    const open = m.index + m[0].length - 1;
+    if (alt(splitTop(sel.slice(open + 1, closeOf(sel, open) - 1)))) return true;
+  }
+  return false;
+};
+function readSheets() {
+  const layers = /* @__PURE__ */ new Map();
+  const layerCmp = (a, b) => {
+    if (a === b) return 0;
+    if (!a || !b) return a ? -1 : 1;
+    const x = a.split("."), y = b.split(".");
+    for (let i = 0; ; i++) {
+      if (i >= x.length || i >= y.length) return i >= x.length ? 1 : -1;
+      if (x[i] !== y[i]) return (layers.get(x.slice(0, i + 1).join(".")) ?? 0) - (layers.get(y.slice(0, i + 1).join(".")) ?? 0);
+    }
+  };
+  const spec = (r) => r.spec ??= specificity(r.sel);
+  const out = { states: [], plain: [], unreadable: 0, beats: (a, aImp, b, bImp) => {
+    if (aImp !== bImp) return aImp;
+    const l = layerCmp(a.layer, b.layer) * (aImp ? -1 : 1);
+    return l ? l > 0 : spec(a) !== spec(b) ? spec(a) > spec(b) : a.order > b.order;
+  } };
+  let order = 0, anon = 0;
+  const enter = (parent, name) => {
+    let full = parent;
+    for (const seg of name.split(".")) {
+      full = full ? `${full}.${seg}` : seg;
+      if (!layers.has(full)) layers.set(full, layers.size);
+    }
+    return full;
+  };
+  const re = (pseudo, attrs) => new RegExp([`(?<!\\\\)${pseudo}(?![\\w-])`, ...attrs.map((n) => `\\[${n}(?:=[^\\]]*)?\\]`)].join("|"), "g");
+  const STATE = [["hover", re(":hover", ["data-hovered", "data-highlighted"])], ["pressed", re(":active", ["data-pressed"])], ["focus", re(":focus-visible", ["data-focus-visible"])]];
+  const walk = (list, parent, layer) => {
+    for (const rule of list) {
+      if (out.plain.length > 4e4) return;
+      const kind = rule.constructor.name;
+      if (rule instanceof CSSImportRule) {
+        const ln = rule.layerName;
+        try {
+          if (rule.styleSheet && (!rule.media.mediaText || matchMedia(rule.media.mediaText).matches)) walk(rule.styleSheet.cssRules, "", ln == null ? layer : enter(layer, ln || `(${anon++})`));
+        } catch {
+          out.unreadable++;
+        }
+        continue;
+      }
+      if (kind === "CSSLayerStatementRule") {
+        for (const n of rule.nameList ?? []) enter(layer, n);
+        continue;
+      }
+      if (rule instanceof CSSMediaRule && !matchMedia(rule.conditionText).matches) continue;
+      if (rule instanceof CSSSupportsRule && !CSS.supports(rule.conditionText)) continue;
+      if (kind === "CSSStartingStyleRule") continue;
+      const within = kind === "CSSLayerBlockRule" ? enter(layer, rule.name || `(${anon++})`) : layer;
+      let sels = null;
+      if (rule instanceof CSSStyleRule) sels = splitTop(rule.selectorText).map((x) => parent ? x.includes("&") ? x.replaceAll("&", parent) : `${parent} ${x}` : x);
+      else if (parent && kind === "CSSNestedDeclarations") sels = [parent];
+      const style = sels ? rule.style : null;
+      if (sels && style?.length) {
+        order++;
+        for (const sel of sels) {
+          const plain = { sel, style, layer: within, order, has: [] };
+          out.plain.push(plain);
+          for (const [state, r] of STATE) {
+            r.lastIndex = 0;
+            if (!r.test(sel)) continue;
+            plain.has.push(state);
+            r.lastIndex = 0;
+            let base = sel.replace(r, ":where(*)");
+            const pm = /::?(before|after)$/.exec(base);
+            if (pm) base = base.slice(0, pm.index) || "*";
+            const on = state === "pressed" && !/(?<!\\):active(?![\w-])/.test(sel);
+            if (!base.includes("::")) out.states.push({ state, base, pseudo: pm ? pm[1] : "", style, sel, layer: within, order, on, toggle: on && pressedIsOnIn(sel, sels) });
+          }
+        }
+      }
+      const kids = rule.cssRules;
+      if (kids?.length) walk(kids, rule instanceof CSSStyleRule ? sels.length > 1 ? `:is(${sels.join(",")})` : sels[0] : parent, within);
+    }
+  };
+  for (const sheet of [...document.styleSheets, ...document.adoptedStyleSheets ?? []]) {
+    if (sheet.disabled) continue;
+    try {
+      if (!sheet.media.mediaText || matchMedia(sheet.media.mediaText).matches) walk(sheet.cssRules, "", "");
+    } catch {
+      out.unreadable++;
+    }
+  }
+  return out;
+}
+var pseudoOf = (x) => {
+  if (x.pseudo === void 0) {
+    const m = /::?(before|after)$/.exec(x.sel);
+    x.base = m ? x.sel.slice(0, m.index) || "*" : x.sel;
+    x.pseudo = m ? m[1] : x.sel.includes("::") ? "other" : "";
+  }
+  return x.pseudo;
+};
+function resolveVars(v, el, first = []) {
+  const cs = getComputedStyle(el);
+  const get = (name) => {
+    for (const s of first) {
+      const x = s.getPropertyValue(name).trim();
+      if (x) return x;
+    }
+    return cs.getPropertyValue(name).trim();
+  };
+  for (let i = 0; i < 6 && v.includes("var("); i++) v = v.replace(/var\((--[\w-]+)(?:,\s*([^()]*(?:\([^()]*\))?[^()]*))?\)/g, (_, name, fb) => get(name) || (fb ?? "").trim());
+  return v.trim();
+}
+function censusLines(c) {
+  const out = [c.head];
+  for (const g of c.groups) {
+    if (!g.rows.length) continue;
+    const n = g.rows.length + (g.more ?? 0);
+    out.push(`${g.name} (${n}${g.what === void 0 ? " values" : g.what ? `, ${g.what}` : ""})`);
+    for (const r of g.rows) out.push(`  ${rowText(r)}`);
+    if (g.more) out.push(`  ... ${g.more} more`);
+  }
+  if (c.report) out.push(...findingLines(c));
+  return out;
+}
+var looksOf = (r) => {
+  if (!r.flag || !r.looks) return 1;
+  const skins = /* @__PURE__ */ new Map();
+  for (const l of r.looks) skins.set(l.state, (skins.get(l.state) ?? /* @__PURE__ */ new Set()).add(l.skin));
+  return Math.max(new Set(r.looks.map((l) => l.shape)).size, ...[...skins.values()].map((s) => s.size));
+};
+function rowText(r) {
+  if (!r.looks) return `${r.key}${r.n ? ` \xD7${r.n}` : ""}${r.note ?? ""}${r.at.length ? `: ${r.at.join("; ")}` : ""}`;
+  const multi = r.looks.length > 1, n = looksOf(r);
+  const by = /* @__PURE__ */ new Map();
+  for (const l of [...r.looks].sort((a, b) => b.n - a.n)) {
+    const say = l.say.replace("h=content", l.lo === l.hi ? `h${l.lo} (its content's)` : `h${l.lo}-${l.hi} (its content's)`);
+    by.set(l.state, [...by.get(l.state) ?? [], `${say} \xD7${l.n}${multi && l.at.length ? ` (${l.at.join("; ")})` : ""}`]);
+  }
+  return `${r.key}${n > 1 ? ` IN ${n} LOOKS` : ""}${r.note ?? ""}: ${[...by].sort((a, b) => a[0].localeCompare(b[0])).map(([st, v]) => `${st ? `${st}: ` : ""}${v.join(" | ")}`).join(" ; ")}`;
+}
+function mergeCensus(pages, rules = {}) {
+  const names = Object.keys(pages);
+  const groups = [];
+  const accs = /* @__PURE__ */ new Map();
+  for (const page of names) for (const g of pages[page].groups) {
+    let to = groups.find((x) => x.name === g.name);
+    if (!to) {
+      to = { name: g.name, what: g.what, rows: [], more: 0 };
+      groups.push(to);
+      accs.set(to, /* @__PURE__ */ new Map());
+    }
+    to.more = Math.max(to.more ?? 0, g.more ?? 0);
+    const rows = accs.get(to);
+    for (const r of g.rows) {
+      const k = `${r.key}
+${r.note ?? ""}`;
+      let a = rows.get(k);
+      if (!a) {
+        a = { row: { key: r.key, n: 0, note: r.note, at: [], looks: r.looks ? [] : void 0 }, pages: [], at: /* @__PURE__ */ new Map() };
+        rows.set(k, a);
+        to.rows.push(a.row);
+      }
+      a.row.n += r.n;
+      a.pages.push(page);
+      a.at.set(page, r.at);
+      if (r.flag) a.row.flag = true;
+      for (const l of r.looks ?? []) {
+        const had = a.row.looks.find((x) => x.state === l.state && x.say === l.say), at = l.at.slice(0, 1).map((p) => `[${page}] ${p}`);
+        if (!had) a.row.looks.push({ ...l, at });
+        else {
+          had.n += l.n;
+          had.lo = Math.min(had.lo ?? 1e9, l.lo ?? 1e9);
+          had.hi = Math.max(had.hi ?? 0, l.hi ?? 0);
+          if (had.at.length < 2) had.at.push(...at);
+        }
+      }
+    }
+  }
+  for (const rows of accs.values()) for (const a of rows.values()) {
+    a.row.note = `${a.row.note ?? ""} (${a.pages.length === names.length && names.length > 1 ? "all" : a.pages.join("+")})`;
+    const said = /* @__PURE__ */ new Set();
+    for (let i = 0; i < 3; i++) for (const p of a.pages) {
+      const x = a.at.get(p)?.[i];
+      if (x && a.row.at.length < 3 && !said.has(x)) {
+        said.add(x);
+        a.row.at.push(`[${p}] ${x}`);
+      }
+    }
+  }
+  for (const g of groups) if (g.name !== "layout problems") g.rows.sort((a, b) => looksOf(b) - looksOf(a) || b.n - a.n);
+  const merged = mergeFindings(pages), overs = maxFindings(groups, rules), findings = merged || overs.length ? [...merged ?? [], ...overs] : void 0;
+  const report = names.some((p) => pages[p].report);
+  return { head: `${pages[names[0]]?.head ?? "styles on screen"}; pages: ${names.join(", ")}`, groups: groups.map((g) => ({ ...g, more: g.more || void 0 })), ...findings ? { findings } : {}, ...report ? { report } : {} };
+}
+var shares = (sizes, budget) => {
+  const out = sizes.map(() => 0);
+  let left = budget, n = sizes.length;
+  for (const i of sizes.map((_, j) => j).sort((a, b) => sizes[a] - sizes[b])) {
+    out[i] = Math.min(sizes[i], Math.floor(left / n));
+    left -= out[i];
+    n--;
+  }
+  return out;
+};
+function styleLines(rules = {}, root = document.body, cap2 = 220) {
+  return censusLines(styleData(rules, root, cap2));
+}
+function styleData(rules = {}, root = document.body, cap2 = 220) {
+  const host = document.createElement("div");
+  host.setAttribute("data-census-private", "");
+  host.style.display = "none";
+  document.body.append(host);
+  colorProbe(host);
+  try {
+    return census(rules, root, cap2, host);
+  } finally {
+    colorProbe(null);
+    host.remove();
+    forced = /* @__PURE__ */ new WeakMap();
+    rings = /* @__PURE__ */ new WeakMap();
+  }
+}
+var textLines = (el) => {
+  const tops = [], walk = document.createTreeWalker(el, NodeFilter.SHOW_TEXT), range = document.createRange();
+  for (let n = walk.nextNode(), i = 0; n && i < 200; n = walk.nextNode(), i++) {
+    if (!n.nodeValue?.trim()) continue;
+    range.selectNodeContents(n);
+    for (const b of range.getClientRects()) if (b.width > 0 && !tops.some((t) => Math.abs(t - b.top) < b.height / 2)) tops.push(b.top);
+  }
+  return tops.length;
+};
+var CONTROL = "button,[role=button],[role=tab],[role=radio],[role=checkbox],[role=switch],[role=option],[role=menuitem],input,select,textarea,a[href]";
+var NATIVE = "a[href],button,input,select,textarea";
+var forced = /* @__PURE__ */ new WeakMap();
+var rings = /* @__PURE__ */ new WeakMap();
+var LAYER = /^(dialog|alertdialog|menu|listbox|tooltip)$/;
+var LOOK = ["height", "min-height", "border-top-left-radius", "background-color", "color", "font-size", "font-weight", "line-height", "letter-spacing", "font-family", "box-shadow", "border-top-color"];
+var STYLE_KEYS = { height: "height", minHeight: "min-height", borderRadius: "border-top-left-radius", background: "background-color", backgroundColor: "background-color", color: "color", fontSize: "font-size", fontWeight: "font-weight", lineHeight: "line-height", letterSpacing: "letter-spacing", fontFamily: "font-family", boxShadow: "box-shadow", borderColor: "border-top-color" };
+function census(rules, root, cap2, host) {
+  const G = () => /* @__PURE__ */ new Map();
+  const groups = { font: G(), type: G(), text: G(), fill: G(), line: G(), radius: G(), shadow: G(), field: G(), height: G(), layout: G(), align: G(), states: G(), used: G(), layer: G(), rules: G() };
+  const infos = /* @__PURE__ */ new Map();
+  const part = (el) => {
+    let p = infos.get(el);
+    if (p === void 0) {
+      p = partInfo(el, rules.parts);
+      infos.set(el, p);
+    }
+    return p;
+  };
+  const srcs = /* @__PURE__ */ new Map();
+  const srcOf = (p) => {
+    if (!rules.sources || !p) return "";
+    let s = p.src ?? "";
+    if (!s && p.fiber) {
+      s = srcs.get(p.fiber) ?? fiberSrc(p.fiber);
+      srcs.set(p.fiber, s);
+    }
+    return s ? ` @ ${s}` : "";
+  };
+  const hostSrc = (el) => {
+    if (!rules.sources) return "";
+    const loc = obj(obj(el.__svelte_meta)?.loc);
+    const s = fiberSrc(fiberOf(el)) || (loc && typeof loc.file === "string" ? `${loc.file}:${loc.line ?? 0}` : "");
+    return s ? ` @ ${s}` : "";
+  };
+  const owners = /* @__PURE__ */ new Map();
+  const ownerOf = (el) => {
+    let o = owners.get(el);
+    if (o !== void 0) return o;
+    o = null;
+    const makers = /* @__PURE__ */ new Set(), f = fiberOf(el);
+    let told = false;
+    if (f && "_debugOwner" in f) {
+      told = true;
+      for (let m = f._debugOwner, i = 0; m && i < 12; m = m._debugOwner ?? m.owner ?? null, i++) makers.add(compName(m.type) || m.name || "");
+    }
+    for (let a = el.parentElement, i = 0; a && a !== document.body && i < 4; a = a.parentElement, i++) {
+      if (a.matches(CONTROL)) break;
+      const lone = told || a.querySelectorAll(CONTROL).length === 1, ap = part(a);
+      if (ap?.listed && lone && (!told || !ap.fiber || makers.has(compName(ap.fiber.type)))) {
+        o = ap;
+        break;
+      }
+      if (!lone) break;
+    }
+    owners.set(el, o);
+    return o;
+  };
+  const inPart = (el, p) => rules.parts?.length && !p?.listed && el.matches(NATIVE) ? ownerOf(el) : null;
+  const stray = (el, p) => !!rules.parts?.length && !p?.listed && el.matches(NATIVE) && !ownerOf(el);
+  const where = (el) => {
+    for (let p = el.parentElement; p; p = p.parentElement) {
+      const t = p.tagName.toLowerCase(), role = p.getAttribute("role");
+      if (/^(header|footer|nav|aside)$/.test(t)) return ` in ${t}`;
+      if (role && /^(dialog|alertdialog|menu|listbox|tooltip|toolbar)$/.test(role)) return ` in ${role}`;
+    }
+    return inside(el);
+  };
+  const place = (el, r, name = el) => {
+    const p = part(name), st = stateOf(name), no = stray(name, p), own = no ? null : inPart(name, p), tail = no ? "no DS part" : own ? `inside ${own.say}` : "";
+    return `${nameOf(name)}${st ? ` (${st})` : ""}${p ? ` [${p.say}${tail ? `, ${tail}` : ""}]` : tail ? ` [${tail}]` : ""}${where(el)} ${box(r)}`;
+  };
+  const snap = rules.items ? /* @__PURE__ */ new Map() : null;
+  const groupName = new Map(Object.entries(groups).map(([k, v]) => [v, k]));
+  const add = (g, k, el, r, name = el) => {
+    if (snap && snap.size < 4e3) {
+      let it = snap.get(name);
+      if (!it) snap.set(name, it = { el, r, look: /* @__PURE__ */ new Map() });
+      const gn = groupName.get(g), had = it.look.get(gn) ?? [];
+      if (!had.includes(k)) it.look.set(gn, [...had, k]);
+    }
+    let s = g.get(k);
+    if (!s) g.set(k, s = { n: 0, at: [], el: name, els: [] });
+    s.n++;
+    if (s.at.length < 3) {
+      s.at.push(place(el, r, name));
+      s.els?.push(name);
+    }
+    return s;
+  };
+  const looks = /* @__PURE__ */ new Map();
+  const seenLooks = [];
+  const colorOf = (css) => {
+    const c = parseColor(css);
+    return c && c[3] >= 0.02 ? hex(c) : null;
+  };
+  const px = (v) => Math.round(parseFloat(v) * 10) / 10;
+  const lineOf = (cs) => {
+    for (const side of ["top", "right", "bottom", "left"]) {
+      const w = parseFloat(cs.getPropertyValue(`border-${side}-width`));
+      const c = w > 0 && cs.getPropertyValue(`border-${side}-style`) !== "none" ? colorOf(cs.getPropertyValue(`border-${side}-color`)) : null;
+      if (c) return `${c} ${num(w)}px`;
+    }
+    return "";
+  };
+  const cornerOf = (cs) => {
+    const one2 = (v) => {
+      const n = parseFloat(v) || 0;
+      return (v.includes("%") ? n >= 50 : n >= 999) ? "full" : num(n);
+    };
+    const c = [cs.borderTopLeftRadius, cs.borderTopRightRadius, cs.borderBottomRightRadius, cs.borderBottomLeftRadius].map(one2);
+    return c.every((x) => x === c[0]) ? c[0] : c.join(" ");
+  };
+  const sayCorner = (c) => c.split(" ").map((x) => x === "full" || x === "0" ? x : `${x}px`).join(" ");
+  const seeing = looking();
+  const ruleColors = Object.entries(rules.colors ?? {}).map(([k, v]) => [k, parseColor(v)]).filter((x) => !!x[1]);
+  const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2], (a[3] - b[3]) * 255);
+  const tokens = /* @__PURE__ */ new Map();
+  const tokenOf = (h) => {
+    let t = tokens.get(h);
+    if (t) return t;
+    t = {};
+    const c = ruleColors.length ? parseColor(h) : null;
+    if (c) {
+      let best = ruleColors[0], d = Infinity;
+      for (const x of ruleColors) {
+        const e = dist(c, x[1]);
+        if (e < d) {
+          d = e;
+          best = x;
+        }
+      }
+      const solid = d <= 2 || c[3] >= 0.995 ? void 0 : ruleColors.find((x) => x[1][3] >= 0.995 && Math.hypot(c[0] - x[1][0], c[1] - x[1][1], c[2] - x[1][2]) <= 3);
+      t = d <= 2 ? { name: best[0] } : solid ? { name: `${solid[0]}/${Math.round(c[3] * 100)}` } : { off: ` OFF (nearest ${best[0]}, ${Math.round(d)} away)` };
+    }
+    tokens.set(h, t);
+    return t;
+  };
+  const sayColors = (s) => s.replace(/(?<![\dx] )#[0-9a-f]{6,8}\b/g, (h) => {
+    const t = tokenOf(h);
+    return t.name ?? `${h}${t.off ?? ""}`;
+  });
+  const shadowNames = Object.entries(rules.shadows ?? {}).map(([k, v]) => [k, shadowLayers(v).rest.join(", ")]);
+  const sayShadow = (k) => !shadowNames.length || k === "none" ? k : shadowNames.find((x) => x[1] === k)?.[0] ?? `${k} OFF`;
+  const nameOf$ = (h) => h ? tokenOf(h).name ?? null : null;
+  const base$ = (n) => n.replace(/\/\d+$/, "");
+  const legacyRe = rules.legacy?.length ? new RegExp(`(?:^|[ <])(${rules.legacy.map((x) => x.replace(/[^\w-]/g, "")).join("|")})(?= |$)`) : null;
+  const roleCheck = (who, fill, shadow, corner, el, r) => {
+    const want2 = rules.roles?.[who];
+    if (!want2) return;
+    if (want2.fill && base$(nameOf$(fill) ?? "none") !== want2.fill) add(groups.rules, `${who} fill ${fill ?? "none"}: its role takes ${want2.fill}`, el, r);
+    if (want2.shadow && shadow !== want2.shadow) add(groups.rules, `${who} shadow ${shadow}: its role takes ${want2.shadow}`, el, r);
+    if (want2.radius !== void 0 && corner !== String(want2.radius)) add(groups.rules, `${who} corner ${sayCorner(corner)}: its role takes ${want2.radius}px`, el, r);
+  };
+  let skipped = [];
+  try {
+    if (rules.ignore) skipped = [rules.ignore];
+    root.querySelector(rules.ignore || "*");
+  } catch {
+    skipped = [];
+  }
+  const out = new Set(root.querySelectorAll(["[data-census-private]", ...skipped].join(",")));
+  let react = rules.foreign !== false && [...document.body.children].some((c) => fiberOf(c) || [...c.children].some(fiberOf));
+  if (react) {
+    const cs = [...document.querySelectorAll("button,[role=button],input,a[href]")].filter((c) => !c.closest("[data-census-private]"));
+    if (cs.filter((c) => !fiberOf(c)).length * 3 > cs.length) react = false;
+  }
+  const foreign = /* @__PURE__ */ new Map(), embedded = /* @__PURE__ */ new Map(), roots = /* @__PURE__ */ new Map();
+  const isRoot = (el) => {
+    let r = roots.get(el);
+    if (r === void 0) {
+      r = Object.keys(el).some((k) => k.startsWith("__reactContainer$"));
+      roots.set(el, r);
+    }
+    return r;
+  };
+  const foreignTop = (el) => {
+    let top = el;
+    while (top.parentElement && top.parentElement !== document.body && !fiberOf(top.parentElement) && !isRoot(top.parentElement)) top = top.parentElement;
+    let f = foreign.get(top);
+    if (f === void 0) {
+      const par = top.parentElement, pf = par ? fiberOf(par) : null;
+      f = false;
+      if (!pf?.memoizedProps?.dangerouslySetInnerHTML && !isRoot(top) && ![...top.querySelectorAll("*")].some((c) => fiberOf(c) || isRoot(c))) {
+        const tr = top.getBoundingClientRect(), flow = par === document.body && /^(static|relative)$/.test(getComputedStyle(top).position) && tr.width > 0 && tr.height > 0;
+        f = !flow && (top.matches("button,[role=button],input,a[href]") ? [top] : [...top.querySelectorAll("button,[role=button],input,a[href]")]).some((c) => !fiberOf(c));
+      }
+      foreign.set(top, f);
+    }
+    return f ? top : null;
+  };
+  const sheets = readSheets();
+  const pressedIsOn = !!document.querySelector("[data-pressed]:not(:active)");
+  const saysOn = (el) => el.hasAttribute("aria-pressed") || el.hasAttribute("aria-checked") || el.hasAttribute("aria-selected");
+  const lit = /* @__PURE__ */ new Set(), litText = /* @__PURE__ */ new Set(), litBy = /* @__PURE__ */ new Map();
+  for (const st of sheets.states) {
+    if (st.pseudo || st.on && (st.toggle || pressedIsOn)) continue;
+    const tint = !!st.style.getPropertyValue("color");
+    if (!tint && !["background-color", "background", "border-color", "box-shadow", "opacity"].some((k) => st.style.getPropertyValue(k))) continue;
+    let els = litBy.get(st.sel);
+    if (!els) {
+      try {
+        els = [...document.querySelectorAll(st.sel)];
+      } catch {
+        els = [];
+      }
+      litBy.set(st.sel, els);
+    }
+    for (const e of els) {
+      if (st.on && saysOn(e)) continue;
+      lit.add(e);
+      if (tint) litText.add(e);
+    }
+  }
+  const sizing = /* @__PURE__ */ new Map(), sizers = /* @__PURE__ */ new Map();
+  const sized = (el) => {
+    let v = sizing.get(el);
+    if (v !== void 0) return v;
+    const real = (x) => !!x && !/^(auto|0(px)?|fit-content|min-content|max-content|inherit|initial|unset|revert|revert-layer)$/.test(x.trim());
+    v = ["height", "min-height", "block-size", "min-block-size", "aspect-ratio"].some((k) => {
+      const own = el.style?.getPropertyValue(k) ?? "";
+      if (own) return real(own);
+      let list = sizers.get(k), top = null;
+      if (!list) sizers.set(k, list = sheets.plain.filter((x) => x.style.getPropertyValue(k)));
+      const imp = (x) => x.style.getPropertyPriority(k) === "important";
+      for (const x of list) {
+        try {
+          if ((!top || sheets.beats(x, imp(x), top, imp(top))) && el.matches(x.sel)) top = x;
+        } catch {
+        }
+      }
+      return !!top && real(top.style.getPropertyValue(k));
+    });
+    sizing.set(el, v);
+    return v;
+  };
+  const want = (check) => checkSetting(rules, check);
+  const W = { contrast: want("contrast") };
+  const hits = /* @__PURE__ */ new Map();
+  const hit = (id, el, r, more = {}) => {
+    let h = hits.get(id);
+    if (!h) hits.set(id, h = { n: 0, at: [], el, r, ...more });
+    h.n++;
+    if (h.at.length < 3) h.at.push(place(el, r));
+    const nm = nameOf(el);
+    if ((h.names ??= []).length < 20 && !h.names.includes(nm)) h.names.push(nm);
+    if (more.min !== void 0) h.min = Math.min(h.min ?? 99, more.min);
+    if (more.unsure === false) h.unsure = false;
+    return h;
+  };
+  const unsureText = (el, cs, r) => {
+    if (cs.backgroundClip === "text" || cs.getPropertyValue("-webkit-background-clip") === "text" || cs.getPropertyValue("-webkit-text-fill-color") && colorOf(cs.getPropertyValue("-webkit-text-fill-color")) !== colorOf(cs.color) || cs.mixBlendMode !== "normal" || cs.filter !== "none" || cs.textShadow !== "none") return true;
+    for (let e = el; e; e = e.parentElement) {
+      const s = getComputedStyle(e);
+      if (s.backgroundImage !== "none" || s.backdropFilter && s.backdropFilter !== "none") return true;
+      const c = parseColor(s.backgroundColor);
+      if (c && c[3] >= 0.995) break;
+    }
+    for (const c of document.elementsFromPoint(r.left + r.width / 2, r.top + r.height / 2)) {
+      if (c === el || c.contains(el) || el.contains(c)) return false;
+      const s = getComputedStyle(c), bgc = parseColor(s.backgroundColor);
+      if (bgc && bgc[3] > 0.02 || s.backgroundImage !== "none" || /^(IMG|VIDEO|CANVAS)$/.test(c.tagName)) return true;
+    }
+    return false;
+  };
+  const turnedOff = (el) => !!el.closest(`${OFF},fieldset[disabled],[data-disabled]`) || el.disabled === true;
+  const contrastOf = (el, color, cs, r, what) => {
+    const ratio = seeing.ratio(el, color, seeing.opacity(el));
+    if (ratio === null) return;
+    const size = parseFloat(cs.fontSize), weight = parseFloat(cs.fontWeight) || 400;
+    const large = size >= 24 || size >= 18.66 && weight >= 700, team = W.contrast.n;
+    const floor = team !== void 0 ? large ? Math.min(3, team) : team : large ? 3 : 4.5;
+    if (ratio >= floor) return;
+    const fg = colorOf(color) ?? color, bg = hex(seeing.back(el)), id = `contrast|${what}${fg} on ${bg}|${large ? "large" : ""}`;
+    const had = hits.get(id);
+    hit(id, el, r, { min: ratio, big: large, fg, bg, what, ...had && (had.n >= 3 || !had.unsure) ? {} : { unsure: unsureText(el, cs, r) } });
+  };
+  const placeholders = /* @__PURE__ */ new Map(), icons = /* @__PURE__ */ new Map(), tracking = /* @__PURE__ */ new Map();
+  let moving = 0, hot = 0, warm = null;
+  const controls = [];
+  const uses = [];
+  const all = [root, ...root.querySelectorAll("*")];
+  let skip = root.closest("[data-census-private]") ? root : null;
+  for (const el of all) {
+    if (skip) {
+      if (skip.contains(el)) continue;
+      skip = null;
+    }
+    if (out.has(el)) {
+      skip = el;
+      continue;
+    }
+    if (!(el instanceof HTMLElement || el instanceof SVGElement)) continue;
+    if (react && !fiberOf(el)) {
+      const top = foreignTop(el);
+      if (top) {
+        embedded.set(top, (embedded.get(top) ?? 0) + 1);
+        continue;
+      }
+    }
+    const r = el.getBoundingClientRect();
+    if (!shown(el, r)) continue;
+    const cs = getComputedStyle(el);
+    if (el instanceof SVGElement) {
+      if (/^(path|rect|circle|ellipse|line|polyline|polygon|use)$/.test(el.tagName)) {
+        const svg = el.closest("svg") ?? el;
+        const had = icons.get(svg) ?? /* @__PURE__ */ new Set();
+        icons.set(svg, had);
+        for (const v of [cs.fill, cs.stroke]) {
+          const c = v && v !== "none" ? colorOf(v) : null;
+          if (c && !had.has(c)) {
+            had.add(c);
+            add(groups.text, `${c} (icon)`, svg, svg.getBoundingClientRect());
+          }
+        }
+      }
+      continue;
+    }
+    if (warm && !warm.contains(el)) warm = null;
+    if (!warm && litText.has(el)) warm = el;
+    const own = ownText(el);
+    if (!own && !el.children.length && cs.animationName !== "none" && /infinite/.test(cs.animationIterationCount)) {
+      const f = colorOf(cs.backgroundColor) ?? "none";
+      placeholders.set(f, (placeholders.get(f) ?? 0) + 1);
+      continue;
+    }
+    if (own && r.width > 2 && r.height > 2) {
+      const lh = cs.lineHeight === "normal" ? "normal" : String(px(cs.lineHeight)), ls = parseFloat(cs.letterSpacing) ? px(cs.letterSpacing) : 0;
+      add(groups.type, `${px(cs.fontSize)}/${cs.fontWeight}/${lh}${ls ? ` ${ls}ls` : ""}`, el, r);
+      add(groups.font, cs.fontFamily.replace(/["']/g, "").replace(/\s*,\s*/g, ", "), el, r);
+      const t = colorOf(cs.color);
+      if (t && !warm) {
+        add(groups.text, t, el, r);
+        const tn = nameOf$(t);
+        if (rules.text?.length && tn && !rules.text.includes(tn) && !rules.text.includes(base$(tn))) add(groups.rules, `text ${t} is not a text color (text takes ${rules.text.join(", ")})`, el, r);
+        if (rules.pairs && tn) {
+          const under = hex(behind(el)), un = nameOf$(under), takes = un ? rules.pairs[un] ?? rules.pairs[base$(un)] : void 0;
+          if (takes && !takes.includes(tn) && !takes.includes(base$(tn))) add(groups.rules, `text ${t} on ${under}: that fill takes text ${takes.join(", ")}`, el, r);
+        }
+      }
+      const ta = sayAlign(cs.textAlign, cs.direction);
+      if (ta && ta !== "start" && !(ta === "center" && el.closest(CONTROL))) add(groups.align, `text ${ta}`, el, r);
+      const per = tracking.get(px(cs.fontSize)) ?? /* @__PURE__ */ new Map();
+      tracking.set(px(cs.fontSize), per);
+      const had = per.get(ls);
+      if (had) had.n++;
+      else per.set(ls, { n: 1, at: [place(el, r)], el });
+      if (W.contrast.level && !warm && !turnedOff(el) && !el.closest("svg,[role=img]")) contrastOf(el, cs.color, cs, r, "");
+    }
+    if (W.contrast.level && (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) && el.placeholder && !el.value && !turnedOff(el)) {
+      const ps = getComputedStyle(el, "::placeholder");
+      contrastOf(el, ps.color, ps, r, "placeholder ");
+    }
+    const big = r.width >= 4 && r.height >= 4;
+    let bg = colorOf(cs.backgroundColor), line = lineOf(cs), corner = cornerOf(cs);
+    const ctl = big && el.matches(CONTROL);
+    const still = !(bg || ctl) || !el.getAnimations?.().some((a) => a.playState === "running");
+    if (!still) {
+      moving++;
+      bg = null;
+    }
+    const live = lit.has(el);
+    if (live) {
+      if (bg || line || ctl) hot++;
+      bg = null;
+      line = "";
+    }
+    if (bg && big) add(groups.fill, bg, el, r);
+    if (line) add(groups.line, line, el, r);
+    const sh = !live && cs.boxShadow && cs.boxShadow !== "none" ? shadowLayers(cs.boxShadow) : null;
+    for (const ring of sh?.rings ?? []) add(groups.line, ring, el, r);
+    if (corner !== "0" && (bg || line)) add(groups.radius, sayCorner(corner), el, r);
+    if (sh?.rest.length) add(groups.shadow, sh.rest.join(", "), el, r);
+    const lay = layoutOf(el, cs, r, !!(bg || line));
+    if (lay) {
+      const s = add(groups.layout, lay.key, el, r);
+      if (s.at.length && !s.at[s.at.length - 1].includes(" holding ")) s.at[s.at.length - 1] += ` holding ${lay.kids}`;
+    }
+    const role = el.getAttribute("role");
+    if (role && LAYER.test(role) || el === root && root !== document.body) {
+      let lb = bg, ll = line, lc = corner, ls = sh;
+      const inner = !lb && !ls?.rest.length && !!el.parentElement?.closest("[role=dialog],[role=alertdialog],[role=menu],[role=listbox],[role=tooltip]");
+      for (let p2 = el.parentElement, i = 0; !inner && !lb && !ls?.rest.length && p2 && i < 4; p2 = p2.parentElement, i++) {
+        const pcs = getComputedStyle(p2), pb = colorOf(pcs.backgroundColor), ps = shadowLayers(pcs.boxShadow);
+        if (pb || ps.rest.length) {
+          lb = pb;
+          ll = lineOf(pcs);
+          lc = cornerOf(pcs);
+          ls = ps;
+        }
+      }
+      if (!inner) {
+        add(groups.layer, `${role ?? "layer"} corner ${sayCorner(lc)} fill ${lb ?? "none"}${ll ? ` line ${ll}` : ""} shadow ${ls?.rest.length ? ls.rest.join(", ") : "none"}`, el, r);
+        if (role) roleCheck(role, lb, ls?.rest.length ? sayShadow(ls.rest.join(", ")) : "none", lc, el, r);
+      }
+    }
+    const p = part(el);
+    if (p && big) {
+      const old = legacyRe?.exec(p.say)?.[1];
+      if (old) add(groups.rules, `legacy part ${old} on screen`, el, r);
+      const pn = p.key.split(" ")[0];
+      if (rules.roles?.[pn] && !live && still && !stateOf(el)) roleCheck(pn, bg, sh?.rest.length ? sayShadow(sh.rest.join(", ")) : "none", corner, el, r);
+    }
+    let boxR = r, hug = false;
+    if (ctl) {
+      if (!live && (el instanceof HTMLInputElement && /^(text|search|email|number|password|tel|url)$/.test(el.type) || el instanceof HTMLTextAreaElement)) {
+        for (let w = el.parentElement, i = 0; !bg && !line && w && i < 6; w = w.parentElement, i++) {
+          const wr = w.getBoundingClientRect();
+          if (wr.height > r.height * 3 + 8) break;
+          const wcs = getComputedStyle(w), wb = colorOf(wcs.backgroundColor), wl = lineOf(wcs);
+          if (wb || wl) {
+            bg = wb;
+            line = wl;
+            corner = cornerOf(wcs);
+            boxR = wr;
+          }
+        }
+        add(groups.field, `${Math.round(boxR.height)}px corner ${sayCorner(corner)} fill ${bg ?? "none"}${line ? ` line ${line}` : ""}`, el, boxR);
+      }
+      const inner = Math.max(0, ...[...el.children].map((c) => c.getBoundingClientRect().height), own && cs.lineHeight !== "normal" ? parseFloat(cs.lineHeight) : 0);
+      hug = !bg && !line && !parseFloat(cs.paddingTop) && !parseFloat(cs.paddingBottom) && inner >= r.height - 1;
+      const kind = role ?? (el.tagName === "INPUT" ? `input ${el.type}` : el.tagName.toLowerCase());
+      if (!hug) {
+        const s = add(groups.height, `${kind} ${Math.round(boxR.height)}px${boxR === r ? "" : " (field box)"}`, el, boxR);
+        if (p) (s.parts ??= /* @__PURE__ */ new Set()).add(p.key);
+      }
+      controls.push({ el, r: boxR });
+    }
+    const no = stray(el, p), within = no ? null : inPart(el, p);
+    if (big && (p || no || within) && (bg || ctl)) {
+      if (still && !live) {
+        const st = stateOf(el), tc = ctl ? colorOf(cs.color) : null, op = seeing.opacity(el);
+        let h = Math.round(boxR.height);
+        if (ctl && !hug && boxR === r) {
+          const lh = parseFloat(cs.lineHeight), inner = r.height - parseFloat(cs.paddingTop) - parseFloat(cs.paddingBottom) - parseFloat(cs.borderTopWidth) - parseFloat(cs.borderBottomWidth), n = lh > 0 ? Math.round(inner / lh) : 0;
+          if (n >= 2 && Math.abs(inner - n * lh) <= 1 && (el instanceof HTMLTextAreaElement || textLines(el) === n) && !sized(el)) h = Math.round(r.height - (n - 1) * lh);
+        }
+        const shape = `${ctl ? hug ? "h=content " : `h${h} ` : ""}r${corner.replaceAll(" ", "/")}`;
+        const skin = `${shape} fill ${bg ?? "none"}${op < 0.995 ? ` at ${Math.round(op * 100)}%` : ""}`, say = `${skin}${tc ? ` text ${tc}` : ""}`;
+        const key = no ? `${p?.key ?? el.tagName.toLowerCase()} (no DS part)` : within ? `${within.key} ${el.tagName.toLowerCase()}` : p.key;
+        seenLooks.push({ key, flag: no ? false : within ? within.cand : p.cand, st, shape, skin, say, h, hug, at: `${nameOf(el)}${where(el)} ${box(boxR)}${srcOf(within ?? p)}`, fiber: (within ?? p)?.fiber ?? null });
+      }
+    }
+    const props = p?.own && big ? p.fiber?.memoizedProps : null;
+    if (props && uses.length < 600) {
+      const cls = typeof props.className === "string" ? props.className.split(/\s+/).filter(Boolean).slice(0, 40) : [];
+      const style = props.style && typeof props.style === "object" ? Object.keys(props.style).flatMap((k) => STYLE_KEYS[k] ? [STYLE_KEYS[k]] : []) : [];
+      if (cls.length || style.length) uses.push({ el, r, key: p.key, cls, style, ctl });
+    }
+  }
+  const perKey = /* @__PURE__ */ new Map();
+  for (const x of seenLooks) perKey.set(x.key, [...perKey.get(x.key) ?? [], x]);
+  for (const [key, list] of perKey) {
+    if (!list[0].flag || new Set(list.map((x) => x.shape)).size < 2 && new Set(list.map((x) => `${x.st}|${x.skin}`)).size === new Set(list.map((x) => x.st)).size) continue;
+    const more = list.map((x) => x.fiber ? propsOf(x.fiber, MORE_PROPS) : "");
+    if (new Set(more).size > 1) list.forEach((x, i) => {
+      if (more[i]) x.key = `${key} ${more[i]}`;
+    });
+  }
+  for (const x of seenLooks) {
+    const of = looks.get(x.key) ?? { flag: x.flag, m: /* @__PURE__ */ new Map() };
+    looks.set(x.key, of);
+    let l = of.m.get(`${x.st}|${x.say}`);
+    if (!l) of.m.set(`${x.st}|${x.say}`, l = { state: x.st, shape: x.shape, skin: x.skin, say: x.say, n: 0, at: [] });
+    l.n++;
+    if (x.hug) {
+      l.lo = Math.min(l.lo ?? 1e9, x.h);
+      l.hi = Math.max(l.hi ?? 0, x.h);
+    }
+    if (l.at.length < 2) l.at.push(x.at);
+  }
+  const shut = /* @__PURE__ */ new Map();
+  let cut = false;
+  if (rules.closed) {
+    let top = all.map(fiberOf).find(Boolean) ?? null;
+    while (top?.return) top = top.return;
+    const mounted = /* @__PURE__ */ new Set(), fibers = [], stack = top ? [top] : [];
+    const worn = /* @__PURE__ */ new Map();
+    while (stack.length && fibers.length < 6e4) {
+      const f = stack.pop();
+      fibers.push(f);
+      mounted.add(f.memoizedProps);
+      if (f.alternate?.memoizedProps) mounted.add(f.alternate.memoizedProps);
+      const cn = typeof f.type === "string" ? null : f.memoizedProps?.className;
+      if (typeof cn === "string" && cn) for (const t of /* @__PURE__ */ new Set([f.type, f.elementType ?? f.type])) {
+        const l = worn.get(t) ?? [];
+        if (l.length < 400) l.push({ props: propsOf(f), cls: new Set(cn.split(/\s+/)) });
+        worn.set(t, l);
+      }
+      if (f.sibling) stack.push(f.sibling);
+      if (f.child) stack.push(f.child);
+    }
+    if (stack.length) cut = true;
+    const seen = /* @__PURE__ */ new Set();
+    let budget = 3e4;
+    const scan = (v, depth) => {
+      if (!v || typeof v !== "object" || depth > 12) return;
+      if (Array.isArray(v)) {
+        if (seen.has(v)) return;
+        seen.add(v);
+        for (let i = 0; i < v.length && i < 200; i++) {
+          const x = v[i];
+          if (x && typeof x === "object" && !Array.isArray(x) && !x.$$typeof) return;
+          scan(x, depth + 1);
+        }
+        return;
+      }
+      const e = v;
+      if (!e.$$typeof || !e.props || typeof e.props !== "object" || seen.has(v)) return;
+      if (budget-- < 0) {
+        cut = true;
+        return;
+      }
+      seen.add(v);
+      const name = compName(e.type);
+      if (!mounted.has(e.props) && typeof e.props.className === "string" && e.props.className && PLAIN.test(name) && !PLUMBING.test(name)) {
+        const props = propsOf({ type: e.type, return: null, memoizedProps: e.props }), k = `${name} ${props}
+${e.props.className}`, had = shut.get(k), cls = e.props.className.split(/\s+/).filter(Boolean);
+        if (had) had.n++;
+        else if (worn.get(e.type)?.some((w) => w.props === props && cls.every((t) => w.cls.has(t)))) {
+        } else if (shut.size < 300) shut.set(k, { name, props, cls: e.props.className, n: 1 });
+        else cut = true;
+      }
+      for (const k of Object.keys(e.props)) scan(e.props[k], depth + 1);
+    };
+    for (const f of fibers) {
+      const p = f.memoizedProps;
+      if (p && typeof p === "object") for (const k of Object.keys(p)) scan(p[k], 0);
+    }
+    for (const x of shut.values()) {
+      x.el = document.createElement("div");
+      x.el.className = x.cls;
+      host.append(x.el);
+    }
+  }
+  const ghosts = /* @__PURE__ */ new Map();
+  for (const cls of [...uses.map((u) => u.cls), ...[...shut.values()].filter((x) => x.props).map((x) => x.cls.split(/\s+/).filter(Boolean))]) for (const t of cls) if (!ghosts.has(t) && ghosts.size < 500) {
+    const g = document.createElement("div");
+    g.className = t;
+    host.append(g);
+    ghosts.set(t, { el: g, sets: /* @__PURE__ */ new Map() });
+  }
+  const targets = /* @__PURE__ */ new Set([...controls.map((c) => c.el), ...uses.map((u) => u.el), ...[...ghosts.values()].map((g) => g.el)]);
+  const matched = /* @__PURE__ */ new Map(), found = /* @__PURE__ */ new Map();
+  for (const st of sheets.states) {
+    if (st.on && (st.toggle || pressedIsOn)) continue;
+    let els = found.get(st.base);
+    if (!els) {
+      try {
+        els = [...document.querySelectorAll(st.base)].filter((e) => targets.has(e));
+      } catch {
+        els = [];
+      }
+      found.set(st.base, els);
+    }
+    for (const el of els) {
+      const l = matched.get(el);
+      if (l) l.push(st);
+      else matched.set(el, [st]);
+    }
+  }
+  const stateSaid = /* @__PURE__ */ new Map();
+  const setters = /* @__PURE__ */ new Map();
+  const settersOf = (prop) => {
+    let l = setters.get(prop);
+    if (!l) setters.set(prop, l = sheets.plain.filter((x) => x.style.getPropertyValue(prop)));
+    return l;
+  };
+  const statesOf = (el) => {
+    let said = stateSaid.get(el);
+    if (said) return said;
+    said = [];
+    const real = forced.get(el), toggles = saysOn(el);
+    if (real && real.size > 1) {
+      const rest = real.get("rest"), cs = getComputedStyle(el), off2 = el.matches(":disabled");
+      const attrPress = (matched.get(el) ?? []).some((st) => st.state === "pressed" && st.on) && !toggles;
+      for (const [name, look] of real) {
+        if (name === (attrPress ? "pressed" : "pressed-attr")) continue;
+        const state = name === "pressed-attr" ? "pressed" : name;
+        if (state === "rest" || state !== "focus" && cs.pointerEvents === "none" || state !== "hover" && off2) continue;
+        for (const [k, v] of Object.entries(look)) {
+          const c = v ? colorOf(v) : null;
+          const was = (x) => x ? colorOf(x) : null;
+          if (c && c !== was(rest[k]) && !(state === "pressed" && c === was(real.get("hover")?.[k]))) said.push(`${state} ${k.startsWith("overlay") ? "overlay fill" : k} ${c}`);
+        }
+      }
+      stateSaid.set(el, said);
+      return said;
+    }
+    const win = /* @__PURE__ */ new Map();
+    const mine = matched.get(el) ?? [];
+    for (const st of mine) for (const [prop, word] of [["background-color", "fill"], ["color", "text"], ["border-color", "line"]]) {
+      const raw = st.on && toggles ? "" : st.style.getPropertyValue(prop);
+      if (!raw) continue;
+      const k = `${st.state}${st.pseudo ? " overlay" : ""} ${word}`, imp = st.style.getPropertyPriority(prop) === "important", had = win.get(k);
+      if (!had || sheets.beats(st, imp, had.st, had.imp)) win.set(k, { raw, imp, st, prop });
+    }
+    const ecs = win.size ? getComputedStyle(el) : null, off = el.matches(":disabled");
+    for (const [k, w] of win) {
+      const state = w.st.state, long = w.prop === "border-color" ? "border-top-color" : w.prop;
+      if (state !== "focus" && ecs.pointerEvents === "none" || state !== "hover" && off) continue;
+      const inline = w.st.pseudo ? "" : el.style?.getPropertyValue(long) ?? "";
+      if (inline && !(w.imp && el.style.getPropertyPriority(long) !== "important")) continue;
+      if (settersOf(long).some((x) => {
+        if (x === w.st || x.has.includes(state) || pseudoOf(x) !== w.st.pseudo || !sheets.beats(x, x.style.getPropertyPriority(long) === "important", w.st, w.imp)) return false;
+        try {
+          return el.matches(x.base);
+        } catch {
+          return false;
+        }
+      })) continue;
+      const rest = getComputedStyle(el, w.st.pseudo ? `::${w.st.pseudo}` : void 0);
+      if (w.st.pseudo && /^(none|normal)$/.test(rest.content) && !w.st.style.getPropertyValue("content")) continue;
+      if (w.prop === "border-color" && !(parseFloat(rest.borderTopWidth) > 0)) continue;
+      const same = [w.st.style, ...mine.filter((x) => x !== w.st && x.state === state && x.pseudo === w.st.pseudo).reverse().map((x) => x.style)];
+      let value = resolveVars(w.raw, el, same);
+      if (w.prop !== "color" && /currentcolor/i.test(value)) {
+        const tw = win.get(`${state}${w.st.pseudo ? " overlay" : ""} text`) ?? win.get(`${state} text`);
+        const text = tw ? resolveVars(tw.raw, el, [tw.st.style]) : "";
+        value = value.replace(/currentcolor/gi, text && !/currentcolor|inherit/i.test(text) ? text : rest.color);
+      }
+      const c = colorOf(value);
+      if (c && c !== colorOf(rest.getPropertyValue(long))) said.push(`${k} ${c}`);
+    }
+    stateSaid.set(el, said);
+    return said;
+  };
+  const stateRule = (st) => {
+    const w = rules.states?.[st];
+    if (!w) return null;
+    const m = /^wash\s+(\S+)$/.exec(w.trim()), name = m ? m[1] : w.trim(), c = m && rules.colors?.[name] ? parseColor(rules.colors[name]) : null;
+    return m ? c ? { wash: c, name } : null : { name };
+  };
+  for (const c of controls) for (const s of statesOf(c.el)) {
+    add(groups.states, s, c.el, c.r);
+    const m = /^(\w+)( overlay)? fill (#[0-9a-f]{6,8})$/.exec(s), want2 = m ? stateRule(m[1]) : null;
+    if (!m || !want2) continue;
+    const got = parseColor(m[3]);
+    if (want2.wash) {
+      const rest = parseColor(getComputedStyle(c.el).backgroundColor), back = behind(c.el.parentElement), under = rest && rest[3] >= 0.02 ? rest[3] >= 0.995 ? rest : over(rest, back) : back;
+      if (Math.max(under[0], under[1], under[2]) - Math.min(under[0], under[1], under[2]) > 16) continue;
+      const ok = m[2] ? dist(got, want2.wash) <= 2 : dist(got[3] >= 0.995 ? got : over(got, back), over(want2.wash, under)) <= 3;
+      if (!ok) add(groups.rules, `${m[1]} fill ${m[3]} is not a ${want2.name} wash${m[2] ? "" : ` over ${hex(under)}`}`, c.el, c.r);
+    } else if (base$(nameOf$(m[3]) ?? "") !== want2.name) add(groups.rules, `${m[1]} fill ${m[3]}: ${m[1]} takes ${want2.name}`, c.el, c.r);
+  }
+  const focusW = want("focus");
+  if (focusW.level) {
+    const within = sheets.plain.filter((x) => /:focus-within/.test(x.sel)).map((x) => x.sel.replace(/:focus-within/g, ""));
+    for (const c of controls) {
+      const real = forced.get(c.el), ring = real && rings.get(real);
+      if (!real?.has("focus") || !ring?.focus || turnedOff(c.el) || c.el.closest("[inert]") || c.el.getAttribute("tabindex") === "-1") continue;
+      if (JSON.stringify(real.get("focus")) !== JSON.stringify(real.get("rest")) || ring.focus !== ring.rest) continue;
+      let unsure = false;
+      for (let a = c.el.parentElement; a && !unsure; a = a.parentElement) unsure = within.some((s) => {
+        try {
+          return a.matches(s);
+        } catch {
+          return false;
+        }
+      });
+      hit(`focus|${part(c.el)?.key ?? c.el.tagName.toLowerCase()}`, c.el, c.r, { unsure });
+    }
+  }
+  const targetW = want("target");
+  if (targetW.level) {
+    const min = targetW.n ?? 24;
+    const boxes = controls.filter((c) => !c.el.closest("[inert]")).map((c) => ({ el: c.el, r: c.el.getBoundingClientRect() }));
+    const exempt = (el) => {
+      if (turnedOff(el)) return true;
+      const cs = getComputedStyle(el);
+      if (el.matches("a[href]") && cs.display === "inline" && [...el.parentElement?.childNodes ?? []].some((n) => n !== el && n.nodeType === 3 && n.textContent?.trim())) return true;
+      return el instanceof HTMLInputElement && /^(checkbox|radio|range|color|file|date|time)$/.test(el.type) && cs.appearance !== "none";
+    };
+    const small = boxes.filter((b) => (b.r.width < min - 0.5 || b.r.height < min - 0.5) && !exempt(b.el)).map((b) => {
+      let r = b.r;
+      for (const l of b.el.labels ?? []) {
+        const lr = l.getBoundingClientRect();
+        const L = Math.min(r.left, lr.left), T = Math.min(r.top, lr.top);
+        r = new DOMRect(L, T, Math.max(r.right, lr.right) - L, Math.max(r.bottom, lr.bottom) - T);
+      }
+      return { ...b, hit: r };
+    }).filter((b) => b.hit.width < min - 0.5 || b.hit.height < min - 0.5);
+    const mid = (r) => [r.left + r.width / 2, r.top + r.height / 2];
+    const reaches = (x, y, r) => Math.hypot(x - Math.max(r.left, Math.min(x, r.right)), y - Math.max(r.top, Math.min(y, r.bottom))) < min / 2;
+    for (const s of small) {
+      const [x, y] = mid(s.hit);
+      const near = boxes.some((o) => o.el !== s.el && !o.el.contains(s.el) && !s.el.contains(o.el) && reaches(x, y, o.r)) || small.some((o) => o !== s && !o.el.contains(s.el) && !s.el.contains(o.el) && Math.hypot(x - mid(o.hit)[0], y - mid(o.hit)[1]) < min);
+      if (near) hit(`target|${part(s.el)?.key ?? s.el.getAttribute("role") ?? s.el.tagName.toLowerCase()}|${Math.round(s.hit.width)}x${Math.round(s.hit.height)}`, s.el, s.r);
+    }
+  }
+  const closed = [];
+  if (uses.length || shut.size) {
+    const bare = host.appendChild(document.createElement("div")), bcs = getComputedStyle(bare);
+    const base = new Map(LOOK.map((k) => [k, bcs.getPropertyValue(k)]));
+    for (const g of ghosts.values()) {
+      const gcs = getComputedStyle(g.el);
+      for (const k of LOOK) {
+        const v = gcs.getPropertyValue(k);
+        if (v !== base.get(k)) g.sets.set(k, v);
+      }
+    }
+    for (const u of uses) {
+      const cs = getComputedStyle(u.el), set = new Set(u.style), hover = /* @__PURE__ */ new Set();
+      for (const t of u.cls) {
+        const g = ghosts.get(t);
+        if (!g) continue;
+        for (const [k, v] of g.sets) if (cs.getPropertyValue(k) === v) set.add(k);
+        for (const s of statesOf(g.el)) hover.add(s);
+      }
+      const items2 = [];
+      for (const k of LOOK) {
+        if (!set.has(k)) continue;
+        const v = cs.getPropertyValue(k), c = /color$/.test(k) ? colorOf(v) : null;
+        if (k === "height" || k === "min-height") {
+          if (u.ctl) items2.push(`${k === "height" ? "height" : "min height"} ${num(parseFloat(v))}px`);
+        } else if (k === "border-top-left-radius") items2.push(`corner ${sayCorner(cornerOf(cs))}`);
+        else if (k === "background-color") items2.push(`fill ${c ?? "none"}`);
+        else if (k === "color") {
+          if (c) items2.push(`text ${c}`);
+        } else if (k === "border-top-color") {
+          if (c && parseFloat(cs.borderTopWidth) > 0 && c !== colorOf(cs.color)) items2.push(`line ${c}`);
+        } else if (k === "font-size" || k === "line-height") items2.push(`${k === "font-size" ? "size" : "line height"} ${num(parseFloat(v))}px`);
+        else if (k === "font-weight") items2.push(`weight ${v}`);
+        else if (k === "letter-spacing") items2.push(`tracking ${num(parseFloat(v) || 0)}px`);
+        else if (k === "font-family") items2.push(`font ${v.replace(/["']/g, "").split(",")[0]}\u2026`);
+        else if (k === "box-shadow") {
+          const s = shadowLayers(v);
+          items2.push(`shadow ${s.rest.length ? sayShadow(s.rest.join(", ")) : s.rings.length ? s.rings.join(", ") : "none"}`);
+        }
+      }
+      const mine = statesOf(u.el);
+      items2.push(...[...hover].filter((s) => mine.includes(s)));
+      if (!items2.length || items2.every((i) => i.startsWith("text "))) continue;
+      add(groups.used, `${u.key}: ${items2.join("; ")}`, u.el, u.r);
+    }
+    const rows = /* @__PURE__ */ new Map();
+    for (const x of shut.values()) {
+      const cs = getComputedStyle(x.el), fill = colorOf(cs.backgroundColor), sh = shadowLayers(cs.boxShadow), line = lineOf(cs), say = x.props ? `${x.name} ${x.props}` : x.name;
+      let row = "";
+      if (fill && (sh.rest.length || cornerOf(cs) !== "0" || line)) row = `${say}: corner ${sayCorner(cornerOf(cs))} fill ${fill}${line ? ` line ${line}` : ""} shadow ${sh.rest.length ? sayShadow(sh.rest.join(", ")) : "none"}`;
+      else if (x.props && (!rules.parts?.length || rules.parts.includes(x.name))) {
+        const set = /* @__PURE__ */ new Map(), hover = /* @__PURE__ */ new Set();
+        for (const t of x.cls.split(/\s+/)) {
+          const g = ghosts.get(t);
+          if (!g) continue;
+          for (const [k, v] of g.sets) set.set(k, v);
+          for (const st of statesOf(g.el)) hover.add(st);
+        }
+        const items2 = [set.has("height") ? `height ${num(parseFloat(set.get("height")))}px` : "", set.has("border-top-left-radius") ? `corner ${sayCorner(cornerOf(cs))}` : "", fill ? `fill ${fill}` : "", ...hover].filter((i) => i && !/NaN/.test(i));
+        if (items2.length) row = `${say}: set where used: ${items2.join("; ")}`;
+      }
+      if (row) rows.set(row, (rows.get(row) ?? 0) + x.n);
+    }
+    for (const [k, n] of [...rows].slice(0, 30)) closed.push({ key: sayColors(k), n, at: [] });
+  }
+  const SHORT = { "border-top-left-radius": ["border-radius"], "background-color": ["background"], "font-family": ["font"], "line-height": ["font"] };
+  const PASS = /^(inherit|unset|revert|revert-layer)$/;
+  const declared = (style, prop) => style.getPropertyValue(prop).trim() || (SHORT[prop] ?? []).map((k) => style.getPropertyValue(k).trim()).find((v) => v.includes("var(")) || "";
+  const declaring = /* @__PURE__ */ new Map();
+  const whence = (el, prop, inherited) => {
+    let list = declaring.get(prop);
+    if (!list) declaring.set(prop, list = sheets.plain.filter((x) => declared(x.style, prop)));
+    for (let e = el, i = 0; e && i < (inherited ? 16 : 1); e = e.parentElement, i++) {
+      const own = e.style ? declared(e.style, prop) : "";
+      if (own && !PASS.test(own)) return " (from its style attribute)";
+      const hits2 = /* @__PURE__ */ new Map(), pass = [];
+      for (const x of list) {
+        try {
+          if (e.matches(x.sel)) {
+            if (PASS.test(declared(x.style, prop))) pass.push(x);
+            else hits2.set(x.style, x);
+          }
+        } catch {
+        }
+      }
+      if (hits2.size > 1) return "";
+      for (const [style, x] of hits2) {
+        const imp = (r) => r.style.getPropertyPriority(prop) === "important";
+        if (own || pass.some((y) => sheets.beats(y, imp(y), x, imp(x)))) break;
+        const text = declared(style, prop), whole = text.match(/^var\((--[\w-]+)\)$/), vars = style.getPropertyValue(prop) ? [] : [...text.matchAll(/var\((--[\w-]+)/g)];
+        const v = whole?.[1] ?? (vars.length === 1 ? vars[0][1] : "");
+        return ` (from ${x.sel.length > 40 ? `${x.sel.slice(0, 39)}\u2026` : x.sel}, ${v ? `via var(${v})` : "written out"})`;
+      }
+      if (!inherited || !e.parentElement || getComputedStyle(e).getPropertyValue(prop) !== getComputedStyle(e.parentElement).getPropertyValue(prop)) return "";
+    }
+    return "";
+  };
+  const typeNote = (k) => !rules.type?.length || rules.type.includes(k.split(" ")[0]) ? "" : " OFF";
+  const radiusNote = (k) => {
+    if (!rules.radii?.length) return "";
+    const off = k.split(" ").map(parseFloat).filter((v) => v > 0 && !rules.radii.includes(v));
+    return off.length ? ` OFF (nearest ${rules.radii.reduce((a, b) => Math.abs(b - off[0]) < Math.abs(a - off[0]) ? b : a)}px)` : "";
+  };
+  const nearOf = (g, k, list) => {
+    const me = list.find((x) => x[0] === k);
+    for (const [o, s] of list) {
+      if (o === k || s.n < me[1].n) continue;
+      if (g === "text" || g === "fill" || g === "line") {
+        const a = parseColor(k.split(" ")[0]), b = parseColor(o.split(" ")[0]);
+        if (a && b && dist(a, b) > 0 && dist(a, b) <= 12 && k.split(" ").slice(1).join(" ") === o.split(" ").slice(1).join(" ")) return ` near ${sayColors(o.split(" ")[0])}`;
+      } else if (g === "radius" && !/full| /.test(k + o) && Math.abs(parseFloat(k) - parseFloat(o)) <= 1.5) return ` near ${o}`;
+      else if (g === "type") {
+        const [a, b] = [k.split(/[/ ]/), o.split(/[/ ]/)];
+        if (a[0] !== b[0] && Math.abs(parseFloat(a[0]) - parseFloat(b[0])) <= 1 && a[1] === b[1]) return ` near ${o.split(" ")[0]}`;
+        if (a[0] === b[0] && a[1] === b[1] && a[2] !== b[2]) return ` near ${o.split(" ")[0]} (line height)`;
+      } else if (g === "height") {
+        const [ka, kh] = [k.replace(/ \d+px.*$/, ""), parseFloat(k.match(/(\d+)px/)[1])], [oa, oh] = [o.replace(/ \d+px.*$/, ""), parseFloat(o.match(/(\d+)px/)[1])];
+        if (ka === oa && kh !== oh && Math.abs(kh - oh) <= 4 && [...me[1].parts ?? []].some((x) => s.parts?.has(x))) return ` near ${oh}px (same part)`;
+      }
+    }
+    return "";
+  };
+  const WHENCE = { text: ["color", true], fill: ["background-color", false], radius: ["border-top-left-radius", false] };
+  const made = [];
+  for (const [g, map] of Object.entries(groups)) {
+    const list = [...map].sort((a, b) => b[1].n - a[1].n);
+    if (!list.length && !(g === "align" && groups.type.size)) continue;
+    const rows = list.map(([k, s]) => {
+      let key = k, note = "";
+      if (g === "font") {
+        key = k === list[0][0] ? k : fontDiff(k, list[0][0]);
+        note = whence(s.el, "font-family", true);
+      } else if (g === "type") note = typeNote(k);
+      else if (g === "radius") note = radiusNote(k);
+      else if (g === "shadow") key = sayShadow(k);
+      else if (g === "layer") key = `${sayColors(k.slice(0, k.indexOf(" shadow ")))} shadow ${sayShadow(k.slice(k.indexOf(" shadow ") + 8))}`;
+      else if (g === "text" || g === "fill" || g === "line") {
+        const [h, ...rest] = k.split(" "), t = tokenOf(h), near = nearOf(g, k, list);
+        key = [t.name && near !== ` near ${t.name}` ? t.name : h, ...rest].join(" ");
+        note = t.off ?? "";
+      } else key = sayColors(k);
+      note += nearOf(g, k, list);
+      if (note && WHENCE[g] && !/\(icon\)/.test(k)) note += whence(s.el, ...WHENCE[g]);
+      else if (g === "type" && / \(line height\)$/.test(note)) note += whence(s.el, "line-height", true);
+      const at = rules.sources && (g === "used" || g === "rules" || / OFF| near /.test(`${key}${note}`)) ? s.at.map((a, i) => {
+        const e = s.els?.[i];
+        return e ? `${a}${srcOf(part(e) ?? ownerOf(e)) || hostSrc(e)}` : a;
+      }) : s.at;
+      return { key, n: s.n, note: note || void 0, at };
+    });
+    if (g === "align") rows.push({ key: "every other text at the start of its box", n: 0, at: [] });
+    if (g === "type") {
+      for (const [size, per] of tracking) {
+        const signs = [...per].sort((a, b) => b[1].n - a[1].n);
+        const odd = signs.find(([ls]) => ls * signs[0][0] < 0);
+        if (odd) rows.push({ key: `tracking at ${size}px: ${signs.map(([ls, s]) => `${ls > 0 ? "+" : ""}${ls} \xD7${s.n}`).join(", ")}`, n: 0, note: whence(odd[1].el, "letter-spacing", true) || void 0, at: odd[1].at });
+      }
+    }
+    const WHAT = { used: "what a part's use site changed about its look with a class or style of its own", layer: "pop-ups and their boxes", layout: "rows, columns, grids and filled boxes: the gaps between their children as drawn, their padding, how the children sit", align: "words set other than to the start of their box", rules: "the rules file's roles, text, states, pairs and legacy, each line one rule broken" };
+    made.push({ name: g === "used" ? "set where used" : g === "rules" ? "rules broken" : g, what: WHAT[g], rows });
+  }
+  const partRows = [...looks].map(([key, l]) => ({ key, n: [...l.m.values()].reduce((n, x) => n + x.n, 0), at: [], flag: l.flag, looks: [...l.m.values()].map((x) => ({ ...x, skin: sayColors(x.skin), say: sayColors(x.say) })) }));
+  partRows.sort((a, b) => looksOf(b) - looksOf(a) || b.n - a.n);
+  if (closed.length) made.push({ name: "closed", what: "would look; not on screen: pop-ups and their contents the page holds but hasn't opened", rows: closed });
+  if (partRows.length) made.push({ name: "parts", what: "by the component that drew them; looks are height (controls), corner, fill and text color, by state", rows: partRows });
+  const findings = [];
+  const push = (f, level) => {
+    if (level) findings.push({ ...f, level });
+  };
+  const plain = (note) => (note ?? "").replace(/ \((from|via) .*$/, "");
+  const offW = want("off");
+  for (const g of made) {
+    if (/^(parts|closed|left out|layout problems)$/.test(g.name)) continue;
+    for (const r of g.rows) {
+      const said = `${r.key}${r.note ?? ""}`;
+      if (/ OFF/.test(said)) push({ id: `off|${g.name}|${r.key}`, check: "off", key: `${g.name} ${r.key}${plain(r.note)}`, n: r.n, at: r.at.slice(0, 1) }, offW.level);
+    }
+  }
+  for (const r of partRows) if (/\(no DS part\)/.test(r.key)) push({ id: `no-part|${r.key}`, check: "no-part", key: r.key, n: r.n, at: (r.looks ?? []).flatMap((l) => l.at).slice(0, 2) }, want("no-part").level);
+  for (const [id, h] of hits) {
+    const [check, a, b] = id.split("|");
+    if (check === "contrast") {
+      const team = W.contrast.n, floor = team !== void 0 ? h.big ? Math.min(3, team) : team : h.big ? 3 : 4.5, wcag = h.big ? 3 : 4.5;
+      const crit = team !== void 0 && team < wcag ? ` (team floor; WCAG 1.4.3 asks ${wcag})` : " (WCAG 1.4.3)";
+      const nm = (x) => tokenOf(x).name ?? x;
+      push({ id, check, key: `contrast ${h.min.toFixed(2)}:1 ${h.what}${nm(h.fg)} on ${nm(h.bg)}${h.big ? " (large text)" : ""} below ${floor}${crit}`, n: h.n, at: h.at, unsure: h.unsure, values: h.names }, W.contrast.level);
+    } else if (check === "focus") push({ id, check, key: `focus not visible (2.4.7): ${a} changes nothing focused`, n: h.n, at: h.at, unsure: h.unsure, values: h.names }, focusW.level);
+    else if (check === "target") push({ id, check, key: `target ${b} under ${targetW.n ?? 24}px, too close to another (2.5.8): ${a}`, n: h.n, at: h.at, values: h.names }, targetW.level);
+  }
+  findings.push(...maxFindings(made, rules));
+  const give = shares(made.map((g) => g.rows.length), cap2);
+  made.forEach((g, i) => {
+    if (g.rows.length > give[i]) {
+      g.more = g.rows.length - give[i];
+      g.rows = g.rows.slice(0, give[i]);
+    }
+  });
+  const left = [];
+  if (placeholders.size) left.push({ key: "loading placeholders (empty boxes that animate forever)", n: [...placeholders.values()].reduce((a, b) => a + b, 0), at: [[...placeholders].map(([f, n]) => `fill ${sayColors(f)} \xD7${n}`).join(", ")] });
+  if (moving) left.push({ key: "mid-animation when read (a flash or a fade: its fill and look aren't counted)", n: moving, at: [] });
+  if (hot) left.push({ key: "under the pointer, pressed or focused when read (it wears that state's colors: its fill, line and look aren't counted)", n: hot, at: [] });
+  if (cut) left.push({ key: "closed pop-ups: the scan stopped early, the closed list is incomplete", n: 0, at: [] });
+  if (embedded.size) left.push({ key: "not the app's components (drawn by another script: a dev tool, an embedded widget)", n: [...embedded.values()].reduce((a, b) => a + b, 0), at: [...embedded.keys()].slice(0, 4).map((e) => {
+    const b = e.matches("button,a[href]") ? e : e.querySelector("button,[role=button],a[href]") ?? e;
+    return `${nameOf(b)} ${box(b.getBoundingClientRect())}`;
+  }) });
+  if (sheets.unreadable) left.push({ key: `${sheets.unreadable} sheets unreadable (another site's: their hover and pressed colors aren't in states)`, n: 0, at: [] });
+  if (left.length) made.push({ name: "left out", what: "", rows: left });
+  const gone = [...embedded.keys(), ...out];
+  const problems = layoutLines(root, 160, gone.length ? (el) => gone.some((x) => x.contains(el)) : void 0, rules.contrast ?? FAINT_TEXT).filter((l) => PROBLEM.test(l));
+  if (problems.length) made.push({ name: "layout problems", what: "", rows: problems.slice(0, 30).map((l) => ({ key: l, n: 0, at: [] })), more: Math.max(0, problems.length - 30) || void 0 });
+  let items;
+  if (snap) {
+    items = [];
+    for (const [name, it] of snap) {
+      const p = part(name), st = stateOf(name), look = {};
+      for (const [g, ks] of it.look) look[g === "used" ? "set where used" : g === "rules" ? "rules broken" : g] = ks.map((k) => g === "shadow" ? sayShadow(k) : sayColors(k)).join("; ");
+      if (st) look.state = st;
+      const tag = name.getAttribute("role") ?? name.tagName.toLowerCase();
+      items.push({ id: `${nameOf(name)}${p ? ` [${p.say}]` : ""}${where(it.el)}`, loose: `${tag}${p ? ` [${p.key}]` : ""}${where(it.el)}`, at: place(it.el, it.r, name), box: [it.r.left, it.r.top, it.r.width, it.r.height].map(Math.round), look });
+    }
+  }
+  const report = asksChecks(rules);
+  const against = rules.colors || rules.type || rules.radii ? ", checked against the design system's values" : checkSetting(rules, "max").level ? ", against best practice" : "";
+  return { head: `styles on screen, window ${innerWidth}x${innerHeight}${against}`, groups: made, items, findings, ...report ? { report } : {} };
+}
+
+// src/diff.ts
+var BOX = /-?\d+,-?\d+ \d+x\d+/g;
+var LOOK_ORDER = ["state", "height", "field", "layout", "radius", "fill", "line", "text", "align", "type", "font", "shadow", "states", "set where used", "layer"];
+function one(a, b) {
+  const x = a.split(" "), y = b.split(" ");
+  let i = 0;
+  while (i < x.length - 1 && i < y.length - 1 && x[i] === y[i]) i++;
+  return `${x.slice(0, i).join(" ")}${i ? " " : ""}${x.slice(i).join(" ")}\u2192${y.slice(i).join(" ")}`;
+}
+function change(a, b) {
+  if (a === void 0) return `+${b}`;
+  if (b === void 0) return `-${a}`;
+  const x = a.split("; "), y = b.split("; ");
+  if (x.length === 1 && y.length === 1) return one(a, b);
+  const come = y.filter((v) => !x.includes(v)), out = [];
+  const head = (v) => v.split(" ").slice(0, -1).join(" ");
+  for (const g of x.filter((v) => !y.includes(v))) {
+    const j = come.findIndex((c) => head(c) === head(g) && head(g) !== "");
+    if (j < 0) {
+      out.push(`-${g}`);
+      continue;
+    }
+    out.push(one(g, come[j]));
+    come.splice(j, 1);
+  }
+  return [...out, ...come.map((c) => `+${c}`)].join(", ");
+}
+var words = (x) => x.at.match(/^[^"[]*"((?:[^"\\]|\\.)*)"/)?.[1];
+function pairUp(a, b) {
+  const pairs = [];
+  let left = [...a], right = [...b];
+  for (const key of ["id", "loose"]) {
+    const byKey = /* @__PURE__ */ new Map();
+    for (const x of right) byKey.set(x[key], [...byKey.get(x[key]) ?? [], x]);
+    const rest = [];
+    for (const x of left) {
+      const list = byKey.get(x[key]);
+      if (!list?.length) {
+        rest.push(x);
+        continue;
+      }
+      let best = 0, d = Infinity;
+      list.forEach((y, i) => {
+        const e = Math.abs(y.box[0] - x.box[0]) + Math.abs(y.box[1] - x.box[1]);
+        if (e < d) {
+          d = e;
+          best = i;
+        }
+      });
+      pairs.push([x, list.splice(best, 1)[0]]);
+    }
+    left = rest;
+    right = [...byKey.values()].flat();
+  }
+  return { pairs, gone: left, added: right };
+}
+var differs = ([x, y], skip) => words(x) !== words(y) || LOOK_ORDER.some((k) => k !== skip && x.look[k] !== y.look[k]) || Math.abs(x.box[2] - y.box[2]) > 2 || Math.abs(x.box[3] - y.box[3]) > 2;
+function changesOnItsOwn(a, b) {
+  const q = pairUp(a, b);
+  return [...q.gone, ...q.added, ...q.pairs.filter((p) => differs(p, "states")).flatMap(([x, y]) => [x, y])];
+}
+var CONTROL_AT = /^(button|a|link|tab|combobox|checkbox|radio|switch|menuitem|option|input|select|textarea|textbox|searchbox|slider)\b/;
+var regionOf = (x) => x.at.match(/\] in ([a-z][\w -]*?) -?\d+,-?\d+ \d+x\d+$| in ([a-z][\w -]*?) -?\d+,-?\d+ \d+x\d+$/)?.slice(1).find(Boolean) ?? "";
+var nameAt = (x) => x.at.replace(/ \[[^\]]*\]/g, "").replace(/ in [a-z][\w -]*? (?=-?\d+,)/, " ").replace(/ -?\d+,-?\d+ \d+x\d+$/, "");
+var way = (dx, dy) => [dx ? `${Math.abs(dx)}px ${dx < 0 ? "left" : "right"}` : "", dy ? `${Math.abs(dy)}px ${dy < 0 ? "up" : "down"}` : ""].filter(Boolean).join(" and ");
+var lookText = (x) => LOOK_ORDER.filter((k) => x.look[k]).map((k) => `${k} ${x.look[k]}`).join("; ");
+var cap = (lines, n) => lines.length > n ? [...lines.slice(0, n), `  ... ${lines.length - n} more`] : lines;
+function diffCensus(before, after, max = 40, live) {
+  const out = [];
+  const a = before.items ?? [], b = after.items ?? [];
+  const all = pairUp(a, b);
+  const hot = [];
+  if (live?.items) hot.push(...changesOnItsOwn(a, live.items));
+  if (before.again) hot.push(...changesOnItsOwn(a, before.again.items ?? []));
+  if (after.again) hot.push(...changesOnItsOwn(b, after.again.items ?? []));
+  const watched = !!(live?.items || before.again || after.again);
+  const isHot = (x) => hot.some((h) => h.loose === x.loose && Math.abs(h.box[1] - x.box[1]) <= 4 && h.box[0] < x.box[0] + x.box[2] + 4 && x.box[0] < h.box[0] + h.box[2] + 4);
+  let skipped = 0;
+  const keep = (x) => hot.length && isHot(x) ? (skipped++, false) : true;
+  const pairs = all.pairs.filter((p) => !differs(p) || keep(p[1]));
+  const gone = all.gone.filter(keep), added = all.added.filter(keep);
+  const changed = [];
+  const moves = /* @__PURE__ */ new Map();
+  let moved = 0;
+  for (const [x, y] of pairs) {
+    const keys = LOOK_ORDER.filter((k) => x.look[k] !== y.look[k]);
+    const sized = x.id === y.id && !!(y.look.height || y.look.text) && !keys.includes("height") && (Math.abs(x.box[2] - y.box[2]) > 2 || Math.abs(x.box[3] - y.box[3]) > 2);
+    const said = words(x) !== words(y) ? [`words "${words(x) ?? ""}"\u2192"${words(y) ?? ""}"`] : [];
+    if (said.length || keys.length || sized) changed.push(`  ${y.at}: ${[...said, ...keys.map((k) => `${k} ${change(x.look[k], y.look[k])}`), ...sized ? [`size ${x.box[2]}x${x.box[3]}\u2192${y.box[2]}x${y.box[3]}`] : []].join("; ")}`);
+    else if (Math.abs(x.box[0] - y.box[0]) > 2 || Math.abs(x.box[1] - y.box[1]) > 2) {
+      if (!keep(y)) continue;
+      moved++;
+      const region = regionOf(y), dx = y.box[0] - x.box[0], dy = y.box[1] - x.box[1], k = `${region}|${dx}|${dy}`;
+      const m = moves.get(k) ?? { region, dx, dy, els: [] };
+      m.els.push(y);
+      moves.set(k, m);
+    }
+  }
+  const moveLines = [...moves.values()].sort((p, q) => q.els.length - p.els.length || Math.abs(q.dx) + Math.abs(q.dy) - Math.abs(p.dx) - Math.abs(p.dy)).map((m) => {
+    const x0 = Math.min(...m.els.map((e) => e.box[0])), y0 = Math.min(...m.els.map((e) => e.box[1])), x1 = Math.max(...m.els.map((e) => e.box[0] + e.box[2])), y1 = Math.max(...m.els.map((e) => e.box[1] + e.box[3]));
+    const named2 = [...m.els].sort((p, q) => Number(!words(p)) - Number(!words(q))).slice(0, 4).map(nameAt);
+    return `  ${m.region ? `in ${m.region}, ` : ""}${m.els.length} moved ${way(m.dx, m.dy)} (area ${x0},${y0} ${x1 - x0}x${y1 - y0}): ${named2.join("; ")}${m.els.length > 4 ? "; \u2026" : ""}`;
+  });
+  if (!before.items || !after.items) out.push("(a census without items: take both with the capture, or rules.items, to compare elements)");
+  const lost = gone.filter((x) => CONTROL_AT.test(x.at)).length;
+  out.push(`census diff: ${changed.length} changed, ${added.length} new, ${gone.length} gone${lost ? ` (${lost} of them controls, marked !)` : ""}, ${moved} only moved${watched ? `; ${skipped} live (they change on their own, not listed)` : ""}`);
+  if (changed.length) out.push(`changed (${changed.length})`, ...cap(changed, max));
+  if (added.length) out.push(`new (${added.length})`, ...cap(added.map((y) => `  ${y.at}: ${lookText(y)}`), max));
+  if (gone.length) out.push(`gone (${gone.length})`, ...cap(gone.map((x) => `  ${CONTROL_AT.test(x.at) ? "! " : ""}${x.at}: ${lookText(x)}`).sort((p, q) => Number(q.startsWith("  !")) - Number(p.startsWith("  !"))), max));
+  if (moveLines.length) out.push(`moved (${moved}, in ${moveLines.length} groups)`, ...cap(moveLines, Math.min(max, 12)));
+  const rows = (c) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const g of c.groups) {
+      if (g.name === "parts" || g.name === "layout problems" || g.name === "left out") continue;
+      for (const r of g.rows) m.set(`${g.name} ${r.key}`, `${g.name} ${r.key}${r.note ? r.note.replace(/ \((?:from|via) (?:[^()]|\([^()]*\))*\)/g, "") : ""} \xD7${r.n}${r.at[0] ? `: ${r.at[0]}` : ""}`);
+    }
+    return m;
+  };
+  const ra = rows(before), rb = rows(after);
+  const nv = [...rb].filter(([k]) => !ra.has(k)).map(([, v]) => v).sort((p, q) => Number(/ OFF/.test(q)) - Number(/ OFF/.test(p)));
+  const gv = [...ra].filter(([k]) => !rb.has(k)).map(([, v]) => v);
+  if (nv.length) out.push(`values new on the page (${nv.length})`, ...cap(nv.map((v) => `  ${v}`), max));
+  if (gv.length) out.push(`values no longer on the page (${gv.length})`, ...cap(gv.map((v) => `  ${v}`), max));
+  const looks = (c) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const r of c.groups.find((g) => g.name === "parts")?.rows ?? []) m.set(r.key, new Set((r.looks ?? []).map((l) => `${l.state ? `${l.state}: ` : ""}${l.say}`)));
+    return m;
+  };
+  const la = looks(before), lb = looks(after), pl = [];
+  for (const [k, s] of lb) {
+    const was = la.get(k);
+    for (const l of s) if (was && !was.has(l)) pl.push(`  ${k}: new look ${l}`);
+  }
+  for (const [k, s] of la) {
+    const now = lb.get(k);
+    for (const l of s) if (now && !now.has(l)) pl.push(`  ${k}: lost look ${l}`);
+  }
+  if (pl.length) out.push(`parts (${pl.length})`, ...cap(pl, max));
+  const probs = (c) => new Map((c.groups.find((g) => g.name === "layout problems")?.rows ?? []).map((r) => [r.key.replace(BOX, "#"), r.key]));
+  const pa = probs(before), pb = probs(after);
+  const np = [...pb].filter(([k]) => !pa.has(k)).map(([, v]) => `  ${v}`), fp = [...pa].filter(([k]) => !pb.has(k)).map(([, v]) => `  ${v}`);
+  if (np.length) out.push(`layout problems new (${np.length})`, ...cap(np, max));
+  if (fp.length) out.push(`layout problems gone (${fp.length})`, ...cap(fp, max));
+  if (before.report || after.report) out.push(...diffFindings(before, after, max).lines);
+  return out;
+}
+export {
+  CHECKS,
+  MAX_DEFAULTS,
+  PRESETS,
+  asksChecks,
+  behind,
+  censusLines,
+  changesOnItsOwn,
+  checkSetting,
+  contrast,
+  diffCensus,
+  diffFindings,
+  findingLines,
+  fontDiff,
+  layoutLines,
+  maxFindings,
+  mergeCensus,
+  mergeFindings,
+  nameOf,
+  over,
+  ownId,
+  parseColor,
+  partOf,
+  shadowLayers,
+  specificity,
+  stateOf,
+  styleData,
+  styleLines
+};