@leonidstern/census 0.0.0-stage → 0.2.0

package/dist/census.js

@@ -0,0 +1,1990 @@
+"use strict";
+(() => {
+  // 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 cap = capOf(g.name);
+      if (cap === void 0 || cap === "off") continue;
+      const n = g.rows.length + (g.more ?? 0);
+      if (n <= cap) continue;
+      const over2 = n - cap;
+      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, ${cap} 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), at2 = f.at.slice(0, 1).map((x) => `[${p}] ${x}`);
+      if (!had) {
+        by.set(f.id, { f: { ...f, at: at2, 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(...at2);
+      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("+")})` }));
+  }
+
+  // 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 words = (label ?? own ?? "").slice(0, 40);
+    return `${role ?? el.tagName.toLowerCase()}${words ? ` ${JSON.stringify(words)}` : ""}`;
+  }
+  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, cap = 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 words = cross(r, range.getBoundingClientRect());
+      if (words) texts.push({ el, r: words, layer: el.closest(POPUP) });
+      if (el instanceof HTMLElement) {
+        const cs = getComputedStyle(el);
+        if (words && 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 < cap; 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 >= cap) 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 = cap - 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 words = layer.replace(/[a-z-]+\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)|#[0-9a-f]{3,8}\b/i, (m) => {
+        color = m;
+        return " ";
+      });
+      for (const w of words.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 };
+  }
+  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), at2 = l.at.slice(0, 1).map((p) => `[${page}] ${p}`);
+          if (!had) a.row.looks.push({ ...l, at: at2 });
+          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(...at2);
+          }
+        }
+      }
+    }
+    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 styleData(rules = {}, root = document.body, cap = 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, cap, 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 FORCE_ATTR = { hover: "data-hovered", "pressed-attr": "data-pressed", focus: "data-focus-visible" };
+  var lookNow = (el) => {
+    const cs = getComputedStyle(el), o = { fill: cs.backgroundColor, text: cs.color, line: parseFloat(cs.borderTopWidth) > 0 ? cs.borderTopColor : "" };
+    for (const p of ["before", "after"]) {
+      const ps = getComputedStyle(el, `::${p}`);
+      if (!/^(none|normal)$/.test(ps.content)) o[`overlay ${p}`] = ps.backgroundColor;
+    }
+    return o;
+  };
+  var rings = /* @__PURE__ */ new WeakMap();
+  var ringNow = (el) => {
+    const cs = getComputedStyle(el);
+    return [cs.outlineStyle !== "none" && parseFloat(cs.outlineWidth) > 0 ? `outline ${cs.outlineStyle} ${cs.outlineWidth} ${cs.outlineColor} ${cs.outlineOffset}` : "", cs.boxShadow !== "none" ? `shadow ${cs.boxShadow}` : "", `decoration ${cs.textDecorationLine}`, `border ${cs.borderTopWidth} ${cs.borderTopStyle} ${cs.borderTopColor}`].join("|");
+  };
+  var SKIP_ATTR = /^(id|href|src|alt|title|value|name|placeholder|for|tabindex|aria-(label|labelledby|describedby|controls|owns|activedescendant|posinset|setsize|valuenow|valuetext)|data-census-.*|data-(key|id|index|testid|test-id|value|row-index|item-index))$/;
+  function stateKey(el, rest) {
+    const own = [...el.attributes].filter((a) => !SKIP_ATTR.test(a.name)).map((a) => `${a.name}=${a.value}`).sort().join(" ");
+    const up = [];
+    for (let a = el.parentElement; a && a !== document.body; a = a.parentElement) up.push(`${a.tagName} ${a.getAttribute("class") ?? ""} ${a.getAttribute("style") ?? ""}`);
+    const at2 = `${el.previousElementSibling ? "" : "first"} ${el.nextElementSibling ? "" : "last"}`;
+    return [el.tagName, own, at2, JSON.stringify(rest), up.join(" < ")].join("|");
+  }
+  function forceMark() {
+    let i = 0;
+    const seen = /* @__PURE__ */ new Map();
+    for (const el of document.querySelectorAll(CONTROL)) {
+      const r = el.getBoundingClientRect();
+      if (r.width < 4 || r.height < 4 || r.bottom < 0 || r.top > innerHeight || r.right < 0 || r.left > innerWidth || !el.checkVisibility()) continue;
+      const rest = lookNow(el), key = stateKey(el, rest), like = seen.get(key);
+      if (like) {
+        forced.set(el, like);
+        continue;
+      }
+      const readings = /* @__PURE__ */ new Map([["rest", rest]]);
+      rings.set(readings, { rest: ringNow(el) });
+      seen.set(key, readings);
+      forced.set(el, readings);
+      el.setAttribute("data-census-f", String(i));
+      for (let a = el.parentElement; a && a !== document.documentElement; a = a.parentElement) a.setAttribute("data-census-up", `${a.getAttribute("data-census-up") ?? ""} ${i}`.trim());
+      if (++i >= 400) break;
+    }
+    return i;
+  }
+  function forceRead(i, read, next) {
+    const el = document.querySelector(`[data-census-f="${i}"]`);
+    if (!el) return;
+    const map = forced.get(el), set = (state) => {
+      const a = FORCE_ATTR[state];
+      if (a && !el.hasAttribute(a)) {
+        el.setAttribute(a, "true");
+        el.setAttribute("data-census-set", a);
+      }
+    };
+    const clear2 = () => {
+      const a = el.getAttribute("data-census-set");
+      if (a) {
+        el.removeAttribute(a);
+        el.removeAttribute("data-census-set");
+      }
+    };
+    if (read) {
+      map?.set(read, lookNow(el));
+      if (read === "focus" && map) {
+        const r = rings.get(map);
+        if (r) r.focus = ringNow(el);
+      }
+      clear2();
+      if (read === "pressed") {
+        set("pressed-attr");
+        map?.set("pressed-attr", lookNow(el));
+        clear2();
+      }
+    }
+    if (next) set(next);
+  }
+  function forceDone() {
+    for (const el of document.querySelectorAll("[data-census-f],[data-census-up]")) {
+      el.removeAttribute("data-census-f");
+      el.removeAttribute("data-census-up");
+    }
+  }
+  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, cap, 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 one = (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(one);
+      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 at2 = 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: at2 };
+      });
+      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), cap);
+    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/browser.ts
+  var at = (sel) => sel ? document.querySelector(sel) ?? document.body : document.body;
+  window.census = {
+    data: (rules, sel) => styleData(rules, at(sel)),
+    lines: (c) => censusLines(c),
+    merge: (pages) => mergeCensus(pages),
+    layout: () => layoutLines(),
+    // for a capture that forces states through the DevTools Protocol
+    forceMark,
+    forceRead,
+    forceDone
+  };
+})();