@designesy/score 0.9.1 → 0.9.3

package/dist/engine.js

@@ -267,17 +267,2046 @@ function httpsFetch(url, headers, timeoutMs = 8000, hop = 0) {
         }
     });
 }
+// ── Linear-time scanning, shared by both engine copies (engine 1.5.1) ──────
+// Each helper below returns exactly what the regular expression it replaced
+// returned: the same matches at the same indexes with the same groups, or the
+// same string after the same replace. The replaced patterns retried from every
+// candidate start and rescanned the rest of the run each time, so their cost
+// grew with the square (one url() pattern with the cube) of a long run of the
+// right characters on a fetched page. These read each run once.
+// test/linear-scan.test.mjs runs every helper against the pattern it replaced,
+// over the fixture pages and generated input, and times each on 100 KB.
+/** JavaScript's \s: WhiteSpace and LineTerminator code units. */
+function isJsSpace(c) {
+    return c === 32 || (c >= 9 && c <= 13) || c === 0xa0 || c === 0x1680 || (c >= 0x2000 && c <= 0x200a)
+        || c === 0x2028 || c === 0x2029 || c === 0x202f || c === 0x205f || c === 0x3000 || c === 0xfeff;
+}
+/** The index after the run of \s that starts at `i`. */
+function wsEnd(s, i) {
+    while (i < s.length && isJsSpace(s.charCodeAt(i)))
+        i++;
+    return i;
+}
+/**
+ * Spans of OPEN[\s\S]*?CLOSE, global and leftmost, as [start, end, ...] pairs.
+ * `open` matches a fixed-length opener, `close` the closer; both global. A
+ * closer is looked for once per opener, and when there is none after one
+ * opener there is none after any later one, so the scan stops there.
+ */
+function lazyBlockSpans(text, open, close) {
+    const spans = [];
+    let pos = 0;
+    for (;;) {
+        open.lastIndex = pos;
+        const o = open.exec(text);
+        if (!o)
+            break;
+        close.lastIndex = o.index + o[0].length;
+        const c = close.exec(text);
+        if (!c)
+            break;
+        spans.push(o.index, c.index + c[0].length);
+        pos = c.index + c[0].length;
+    }
+    return spans;
+}
+/** `text` with each [start, end) span replaced by `rep`. */
+function replaceSpans(text, spans, rep) {
+    if (spans.length === 0)
+        return text;
+    const parts = [];
+    let last = 0;
+    for (let k = 0; k < spans.length; k += 2) {
+        parts.push(text.slice(last, spans[k]), rep);
+        last = spans[k + 1];
+    }
+    parts.push(text.slice(last));
+    return parts.join('');
+}
+/** html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '') */
+function withoutScriptsAndStyles(html) {
+    const noScripts = replaceSpans(html, lazyBlockSpans(html, /<script/gi, /<\/script>/gi), '');
+    return replaceSpans(noScripts, lazyBlockSpans(noScripts, /<style/gi, /<\/style>/gi), '');
+}
+/** css.replace(/\/\*[\s\S]*?\*\//g, rep) */
+function withoutCssComments(css, rep) {
+    return replaceSpans(css, lazyBlockSpans(css, /\/\*/g, /\*\//g), rep);
+}
+/** text.replace(/<[^>]*>/g, rep), or /<[^>]+>/g when `nonEmpty`. */
+function withoutTags(text, rep, nonEmpty) {
+    const spans = [];
+    let pos = 0;
+    for (;;) {
+        const lt = text.indexOf('<', pos);
+        if (lt < 0)
+            break;
+        if (nonEmpty && text.charCodeAt(lt + 1) === 62) {
+            pos = lt + 1;
+            continue;
+        }
+        const gt = text.indexOf('>', lt + 1);
+        if (gt < 0)
+            break;
+        spans.push(lt, gt + 1);
+        pos = gt + 1;
+    }
+    return replaceSpans(text, spans, rep);
+}
+/**
+ * Matches of <TAG[^>]*>([\s\S]*?)<\/TAG> (global): `open` matches `<TAG`,
+ * `close` the closing tag, both global. groups[0] is the content.
+ */
+function elementMatches(html, open, close) {
+    const out = [];
+    let pos = 0;
+    for (;;) {
+        open.lastIndex = pos;
+        const o = open.exec(html);
+        if (!o)
+            break;
+        const gt = html.indexOf('>', o.index + o[0].length);
+        if (gt < 0)
+            break;
+        close.lastIndex = gt + 1;
+        const c = close.exec(html);
+        if (!c)
+            break;
+        const end = c.index + c[0].length;
+        out.push({ index: o.index, text: html.slice(o.index, end), groups: [html.slice(gt + 1, c.index)] });
+        pos = end;
+    }
+    return out;
+}
+/**
+ * Matches of <NAME[^>]*ATTR[^>]*>([\s\S]*?)CLOSE (global). `open` matches `<`
+ * and as much of the name as must precede the attribute; `attr` and `close`
+ * are global. An opener whose tag holds no ATTR rules out every opener before
+ * the same `>`; one with no CLOSE after it rules out every later one.
+ */
+function roleElementMatches(html, open, attr, close) {
+    const out = [];
+    let pos = 0;
+    let attrFrom = -1;
+    let attrAt = -1;
+    for (;;) {
+        open.lastIndex = pos;
+        const o = open.exec(html);
+        if (!o)
+            break;
+        const gt = html.indexOf('>', o.index + 1);
+        if (gt < 0)
+            break;
+        const from = o.index + o[0].length;
+        if (!(attrFrom >= 0 && from >= attrFrom && from <= attrAt)) {
+            attr.lastIndex = from;
+            const a = attr.exec(html);
+            attrFrom = from;
+            attrAt = a ? a.index : Infinity;
+        }
+        if (attrAt >= gt) {
+            pos = gt + 1;
+            continue;
+        }
+        close.lastIndex = gt + 1;
+        const c = close.exec(html);
+        if (!c)
+            break;
+        const end = c.index + c[0].length;
+        out.push({ index: o.index, text: html.slice(o.index, end), groups: [html.slice(gt + 1, c.index)] });
+        pos = end;
+    }
+    return out;
+}
+/** v41: matches of /<(button|a|label|td|th|p|li|h[1-6])\s([^>]*?)>([\s\S]*?)<\/\1>/gi, groups [tag, attrs, content]. */
+function capsElementMatches(html) {
+    const out = [];
+    const open = /<(button|a|label|td|th|p|li|h[1-6])\s/gi;
+    const closers = {};
+    const noCloserFrom = {};
+    let gtFrom = -1;
+    let gtAt = -1;
+    let pos = 0;
+    for (;;) {
+        open.lastIndex = pos;
+        const o = open.exec(html);
+        if (!o)
+            break;
+        const from = o.index + o[0].length;
+        if (!(gtFrom >= 0 && from >= gtFrom && from <= gtAt)) {
+            gtFrom = from;
+            gtAt = html.indexOf('>', from);
+        }
+        if (gtAt < 0)
+            break;
+        const tag = o[1].toLowerCase();
+        if (noCloserFrom[tag] !== undefined && gtAt + 1 >= noCloserFrom[tag]) {
+            pos = o.index + 1;
+            continue;
+        }
+        const close = closers[tag] ?? (closers[tag] = new RegExp(`</${tag}>`, 'gi'));
+        close.lastIndex = gtAt + 1;
+        const c = close.exec(html);
+        if (!c) {
+            noCloserFrom[tag] = gtAt + 1;
+            pos = o.index + 1;
+            continue;
+        }
+        const end = c.index + c[0].length;
+        out.push({ index: o.index, text: html.slice(o.index, end), groups: [o[1], html.slice(from, gtAt), html.slice(gtAt + 1, c.index)] });
+        pos = end;
+    }
+    return out;
+}
+/**
+ * /NAME[^"']*NEEDLE[^"']*["']/i.test(attrs), where `name` (global) matches
+ * the attribute name, `=` and its opening quote, and `needle` (global) holds
+ * no quote: true when NEEDLE sits wholly inside one quoted value that closes.
+ */
+function quotedAttrHas(attrs, name, needle) {
+    let pos = 0;
+    let needleFrom = -1;
+    let needleAt = -1;
+    for (;;) {
+        name.lastIndex = pos;
+        const n = name.exec(attrs);
+        if (!n)
+            return false;
+        const from = n.index + n[0].length;
+        let q = from;
+        while (q < attrs.length && attrs[q] !== '"' && attrs[q] !== "'")
+            q++;
+        if (q >= attrs.length)
+            return false;
+        if (!(needleFrom >= 0 && from >= needleFrom && from <= needleAt)) {
+            needle.lastIndex = from;
+            const m = needle.exec(attrs);
+            needleFrom = from;
+            needleAt = m ? m.index : Infinity;
+        }
+        if (needleAt < q)
+            return true;
+        pos = n.index + 1;
+    }
+}
+/** The first match of a global regex at or after `from`, remembered while later queries fall before it. */
+function nextMatchFinder(text, re) {
+    let memoFrom = -1;
+    let memoAt = -1;
+    return (from) => {
+        if (!(memoFrom >= 0 && from >= memoFrom && from <= memoAt)) {
+            re.lastIndex = from;
+            const m = re.exec(text);
+            memoFrom = from;
+            memoAt = m ? m.index : Infinity;
+        }
+        return memoAt;
+    };
+}
+/** Start positions of every match of a global regex, ascending. */
+function matchStarts(text, re) {
+    const out = [];
+    re.lastIndex = 0;
+    for (let m = re.exec(text); m; m = re.exec(text)) {
+        out.push(m.index);
+        if (m[0].length === 0)
+            re.lastIndex++;
+    }
+    return out;
+}
+/**
+ * Matches of START[^{]*\{[^}]*BODY (global): after each start, the rule body
+ * from the first `{` to the first `}` must hold BODY, and the match ends where
+ * BODY last matches in it (the greedy [^}]*). `next(from, lastEnd)` returns the
+ * first start at or after `from` whose prelude reaches a `{` (brace -1 when no
+ * later start can), or null; it is told where the previous match ended because
+ * some starts reach back before their first character. `lead` (global) finds
+ * where BODY can begin and `body` is BODY, sticky. Starts that share a body's
+ * `}` share its answer, so each body is read once. `first` stops at one match.
+ */
+function ruleBodyScan(css, next, lead, body, first) {
+    const out = [];
+    const leads = matchStarts(css, lead);
+    let ptr = 0;
+    let pos = 0;
+    let lastEnd = 0;
+    let deadUntil = -1;
+    for (;;) {
+        const st = next(pos, lastEnd);
+        if (!st || st.brace < 0)
+            break;
+        const b = st.brace;
+        if (b < deadUntil) {
+            pos = b + 1;
+            continue;
+        }
+        let c = css.indexOf('}', b + 1);
+        if (c < 0)
+            c = css.length;
+        deadUntil = c;
+        while (ptr < leads.length && leads[ptr] <= b)
+            ptr++;
+        let end = ptr;
+        while (end < leads.length && leads[end] <= c)
+            end++;
+        let hit = null;
+        for (let k = end - 1; k >= ptr && !hit; k--) {
+            body.lastIndex = leads[k];
+            hit = body.exec(css);
+        }
+        ptr = end;
+        if (!hit) {
+            pos = b + 1;
+            continue;
+        }
+        const stop = hit.index + hit[0].length;
+        out.push({ index: st.index, text: css.slice(st.index, stop), groups: hit.slice(1) });
+        if (first)
+            break;
+        pos = stop;
+        lastEnd = stop;
+    }
+    return out;
+}
+/** next() for ruleBodyScan when the start is a plain pattern (global) followed by [^{]*\{. */
+function bracedStarts(css, start) {
+    const brace = nextMatchFinder(css, /\{/g);
+    return (from) => {
+        start.lastIndex = from;
+        const m = start.exec(css);
+        if (!m)
+            return null;
+        const b = brace(m.index + m[0].length);
+        return { index: m.index, brace: b === Infinity ? -1 : b };
+    };
+}
+/** next() for v27's floor rule: input\s*(?:,[^{]*)?\{ */
+function inputFloorStarts(css) {
+    const start = /input/gi;
+    const brace = nextMatchFinder(css, /\{/g);
+    return (from) => {
+        for (let at = from;;) {
+            start.lastIndex = at;
+            const m = start.exec(css);
+            if (!m)
+                return null;
+            const p = wsEnd(css, m.index + 5);
+            if (css.charCodeAt(p) === 123)
+                return { index: m.index, brace: p };
+            if (css.charCodeAt(p) === 44) {
+                const b = brace(p + 1);
+                return { index: m.index, brace: b === Infinity ? -1 : b };
+            }
+            at = m.index + 1;
+        }
+    };
+}
+/** A LineTerminator code unit, where ^ matches under the m flag. */
+function isLineTerminator(c) {
+    return c === 10 || c === 13 || c === 0x2028 || c === 0x2029;
+}
+/**
+ * next() for v24's selector start (?:^|[,}\s])\s*(?:button|a\b|...) with the m
+ * flag: a keyword counts when the space before it begins on a line start, a
+ * space, a comma or a closing brace at or after the previous match's end.
+ */
+function touchTargetStarts(css) {
+    const keyword = /button|a\b|input|textarea|select|\[role\s*=\s*["']?button["']?\]|\.btn|\.button|\.chip|\.tab|\.nav-link/gi;
+    const brace = nextMatchFinder(css, /\{/g);
+    return (from, lastEnd) => {
+        for (let at = from;;) {
+            keyword.lastIndex = at;
+            const k = keyword.exec(css);
+            if (!k)
+                return null;
+            const q = k.index;
+            let w = q;
+            while (w > lastEnd && isJsSpace(css.charCodeAt(w - 1)))
+                w--;
+            let index = -1;
+            if (w - 1 >= lastEnd && (css.charCodeAt(w - 1) === 44 || css.charCodeAt(w - 1) === 125))
+                index = w - 1;
+            else if (w < q)
+                index = w;
+            else if (q >= lastEnd && (q === 0 || isLineTerminator(css.charCodeAt(q - 1))))
+                index = q;
+            if (index < 0) {
+                at = q + 1;
+                continue;
+            }
+            const b = brace(q + k[0].length);
+            return { index, brace: b === Infinity ? -1 : b };
+        }
+    };
+}
+/** next() for O-motion's breath keyframes: @keyframes\s+[^{]*breath[^{]*\{ */
+function breathKeyframeStarts(css) {
+    const start = /@keyframes/gi;
+    const brace = nextMatchFinder(css, /\{/g);
+    const breath = nextMatchFinder(css, /breath/gi);
+    return (from) => {
+        for (let at = from;;) {
+            start.lastIndex = at;
+            const m = start.exec(css);
+            if (!m)
+                return null;
+            const after = m.index + m[0].length;
+            if (!isJsSpace(css.charCodeAt(after))) {
+                at = m.index + 1;
+                continue;
+            }
+            const b = brace(after);
+            if (b === Infinity)
+                return { index: m.index, brace: -1 };
+            if (breath(after + 1) < b)
+                return { index: m.index, brace: b };
+            at = b + 1;
+        }
+    };
+}
+/**
+ * /START[^{]*X/i.test(css): X (global, no `{`) begins in the prelude between
+ * a start and the first `{` after it. Only the first start of each prelude
+ * needs reading; later ones see less of it.
+ */
+function preludeHas(css, start, x) {
+    const brace = nextMatchFinder(css, /\{/g);
+    const found = nextMatchFinder(css, x);
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            return false;
+        const after = m.index + m[0].length;
+        const b = brace(after);
+        if (found(after) < b)
+            return true;
+        if (b === Infinity)
+            return false;
+        pos = b + 1;
+    }
+}
+/**
+ * Matches of START[^{]*X[^{]*\{ (global): X's last match in the prelude before
+ * the first `{` after the start; the match runs to that `{`. `lead` (global)
+ * finds where X can begin, `x` is X, sticky.
+ */
+function preludeMatches(css, start, lead, x) {
+    const out = [];
+    const leads = matchStarts(css, lead);
+    let ptr = 0;
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const after = m.index + m[0].length;
+        const b = css.indexOf('{', after);
+        if (b < 0)
+            break;
+        while (ptr < leads.length && leads[ptr] < after)
+            ptr++;
+        let end = ptr;
+        while (end < leads.length && leads[end] < b)
+            end++;
+        let hit = null;
+        for (let k = end - 1; k >= ptr && !hit; k--) {
+            x.lastIndex = leads[k];
+            hit = x.exec(css);
+        }
+        ptr = end;
+        if (hit)
+            out.push({ index: m.index, text: css.slice(m.index, b + 1), groups: hit.slice(1) });
+        pos = b + 1;
+    }
+    return out;
+}
+/** css.replace(/@media[^{]*\{[^@]*?\}\s*\}/gi, '') */
+function withoutMediaBlocks(css) {
+    const start = /@media/gi;
+    const spans = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const b = css.indexOf('{', m.index + m[0].length);
+        if (b < 0)
+            break;
+        let end = -1;
+        for (let k = b + 1; k < css.length; k++) {
+            const ch = css.charCodeAt(k);
+            if (ch === 64)
+                break;
+            if (ch === 125) {
+                const t = wsEnd(css, k + 1);
+                if (css.charCodeAt(t) === 125) {
+                    end = t + 1;
+                    break;
+                }
+            }
+        }
+        if (end < 0) {
+            pos = b + 1;
+            continue;
+        }
+        spans.push(m.index, end);
+        pos = end;
+    }
+    return replaceSpans(css, spans, '');
+}
+/** css.replace(/@keyframes\s+[^{]+\{[^@]*?\}/gi, '') */
+function withoutKeyframesBlocks(css) {
+    const start = /@keyframes/gi;
+    const spans = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const after = m.index + m[0].length;
+        if (!isJsSpace(css.charCodeAt(after))) {
+            pos = m.index + 1;
+            continue;
+        }
+        const b = css.indexOf('{', after);
+        if (b < 0)
+            break;
+        if (b < after + 2) {
+            pos = m.index + 1;
+            continue;
+        }
+        let end = -1;
+        for (let k = b + 1; k < css.length; k++) {
+            const ch = css.charCodeAt(k);
+            if (ch === 64)
+                break;
+            if (ch === 125) {
+                end = k + 1;
+                break;
+            }
+        }
+        if (end < 0) {
+            pos = b + 1;
+            continue;
+        }
+        spans.push(m.index, end);
+        pos = end;
+    }
+    return replaceSpans(css, spans, '');
+}
+/** css.match(/::selection\s*\{[^}]*\}/gi) */
+function selectionRules(css) {
+    const start = /::selection/gi;
+    const out = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const b = wsEnd(css, m.index + m[0].length);
+        if (css.charCodeAt(b) !== 123) {
+            pos = m.index + 1;
+            continue;
+        }
+        const c = css.indexOf('}', b + 1);
+        if (c < 0)
+            break;
+        out.push(css.slice(m.index, c + 1));
+        pos = c + 1;
+    }
+    return out.length ? out : null;
+}
+/** The matches css.replace(/(font-size\s*:\s*)(var\([^;{}]*\))/gi, fn) hands fn: groups [lead, value]. */
+function fontSizeVarMatches(css) {
+    const start = /font-size/gi;
+    const varAt = /var\(/iy;
+    const out = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const colon = wsEnd(css, m.index + m[0].length);
+        if (css.charCodeAt(colon) !== 58) {
+            pos = m.index + 1;
+            continue;
+        }
+        const v = wsEnd(css, colon + 1);
+        varAt.lastIndex = v;
+        if (!varAt.test(css)) {
+            pos = m.index + 1;
+            continue;
+        }
+        let r = v + 4;
+        while (r < css.length) {
+            const ch = css.charCodeAt(r);
+            if (ch === 59 || ch === 123 || ch === 125)
+                break;
+            r++;
+        }
+        let close = r - 1;
+        while (close >= v + 4 && css.charCodeAt(close) !== 41)
+            close--;
+        if (close >= v + 4) {
+            out.push({ index: m.index, text: css.slice(m.index, close + 1), groups: [css.slice(m.index, v), css.slice(v, close + 1)] });
+        }
+        // Every later start before r ends at the same r and finds no ')' after this one.
+        pos = r;
+    }
+    return out;
+}
+/** Matches of /([^{}]+)\{([^{}]*)\}/g: groups [prelude, body]. */
+function cssRuleBlocks(css) {
+    const out = [];
+    const n = css.length;
+    const braceAt = (k) => {
+        const ch = css.charCodeAt(k);
+        return ch === 123 || ch === 125;
+    };
+    for (let pos = 0; pos < n;) {
+        let b = pos;
+        while (b < n && !braceAt(b))
+            b++;
+        if (b === n)
+            break;
+        if (b === pos || css.charCodeAt(b) === 125) {
+            pos = b + 1;
+            continue;
+        }
+        let c = b + 1;
+        while (c < n && !braceAt(c))
+            c++;
+        if (c === n)
+            break;
+        if (css.charCodeAt(c) === 123) {
+            pos = b + 1;
+            continue;
+        }
+        out.push({ index: pos, text: css.slice(pos, c + 1), groups: [css.slice(pos, b), css.slice(b + 1, c)] });
+        pos = c + 1;
+    }
+    return out;
+}
+/** Matches of /url\(\s*['"]?([^'")]+)['"]?\s*\)/gi: groups [path]. */
+function cssUrlMatches(css) {
+    const start = /url\(/gi;
+    const urlAt = /url\(/iy;
+    const out = [];
+    const n = css.length;
+    const isQuote = (c) => c === 34 || c === 39;
+    // First quote or ')' at or after `from`.
+    const stopAt = (from) => {
+        let k = from;
+        while (k < n) {
+            const ch = css.charCodeAt(k);
+            if (ch === 34 || ch === 39 || ch === 41)
+                break;
+            k++;
+        }
+        return k;
+    };
+    // ['"]?\s*\) at a quote or ')': the index after it, or -1.
+    const tailEnd = (r) => {
+        if (r >= n)
+            return -1;
+        if (css.charCodeAt(r) === 41)
+            return r + 1;
+        const t = wsEnd(css, r + 1);
+        return css.charCodeAt(t) === 41 ? t + 1 : -1;
+    };
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const p0 = m.index + m[0].length;
+        const p1 = wsEnd(css, p0);
+        let hit = -1;
+        let from = -1;
+        let to = -1;
+        // All the leading space, then the quote after it taken, then not taken.
+        if (p1 < n && isQuote(css.charCodeAt(p1))) {
+            const r = stopAt(p1 + 1);
+            const e = r > p1 + 1 ? tailEnd(r) : -1;
+            if (e >= 0) {
+                hit = e;
+                from = p1 + 1;
+                to = r;
+            }
+        }
+        if (hit < 0) {
+            const r = stopAt(p1);
+            const e = r > p1 ? tailEnd(r) : -1;
+            if (e >= 0) {
+                hit = e;
+                from = p1;
+                to = r;
+            }
+        }
+        // Less leading space: the path starts on a space and runs to the same stop.
+        if (hit < 0 && p1 > p0) {
+            const r = stopAt(p1 - 1);
+            const e = tailEnd(r);
+            if (e >= 0) {
+                hit = e;
+                from = p1 - 1;
+                to = r;
+            }
+        }
+        if (hit >= 0) {
+            out.push({ index: m.index, text: css.slice(m.index, hit), groups: [css.slice(from, to)] });
+            pos = hit;
+            continue;
+        }
+        // A later url( before the first quote or ')' after this one reads the same
+        // stop and fails the same way, unless only space separates it from a
+        // quote at that stop: that one can take the quote and must be tried.
+        const r1 = stopAt(p0);
+        if (r1 >= n)
+            break;
+        let w = r1;
+        while (w > p0 && isJsSpace(css.charCodeAt(w - 1)))
+            w--;
+        urlAt.lastIndex = w - 4;
+        pos = w - 4 > m.index && urlAt.test(css) ? w - 4 : r1;
+    }
+    return out;
+}
+/** css.match(/(?:^|\})[^{}]*\{[^}]*background-clip\s*:\s*text[^}]*\}/gi) || [] */
+function gradientClipRules(css) {
+    const found = nextMatchFinder(css, /background-clip\s*:\s*text/gi);
+    const out = [];
+    const n = css.length;
+    let pos = 0;
+    for (let first = true;;) {
+        let i;
+        let from;
+        if (first) {
+            first = false;
+            i = 0;
+            from = css.charCodeAt(0) === 125 ? 1 : 0;
+        }
+        else {
+            i = css.indexOf('}', pos);
+            if (i < 0)
+                break;
+            from = i + 1;
+        }
+        let b = from;
+        while (b < n && css.charCodeAt(b) !== 123 && css.charCodeAt(b) !== 125)
+            b++;
+        if (b >= n)
+            break;
+        if (css.charCodeAt(b) === 125) {
+            pos = b;
+            continue;
+        }
+        const c = css.indexOf('}', b + 1);
+        if (c < 0)
+            break;
+        if (found(b + 1) < c) {
+            out.push(css.slice(i, c + 1));
+            pos = c + 1;
+        }
+        else
+            pos = c;
+    }
+    return out;
+}
+/**
+ * block.match(/linear-gradient\(([\s\S]+)\)\s*;?\s*background-size|linear-gradient\(([^;]+)\)/i):
+ * groups [args before background-size, args before the first ';'].
+ */
+function linearGradientArgs(block) {
+    const start = /linear-gradient\(/gi;
+    const size = /background-size/iy;
+    const n = block.length;
+    // The last ')' followed by \s*;?\s*background-size anywhere in the block.
+    let tailParen = -1;
+    let tailStop = -1;
+    for (let p = block.lastIndexOf(')'); p >= 0; p = p > 0 ? block.lastIndexOf(')', p - 1) : -1) {
+        let t = wsEnd(block, p + 1);
+        if (block.charCodeAt(t) === 59)
+            t = wsEnd(block, t + 1);
+        size.lastIndex = t;
+        if (size.test(block)) {
+            tailParen = p;
+            tailStop = t + 15;
+            break;
+        }
+    }
+    let semiFor = -1;
+    let semi = -1;
+    let parenFor = -1;
+    let paren = -1;
+    for (let m = start.exec(block); m; m = start.exec(block)) {
+        const a = m.index + m[0].length;
+        if (tailParen >= a + 1) {
+            return { index: m.index, text: block.slice(m.index, tailStop), groups: [block.slice(a, tailParen), undefined] };
+        }
+        if (!(semiFor >= 0 && a >= semiFor && a <= semi)) {
+            semiFor = a;
+            semi = block.indexOf(';', a);
+            if (semi < 0)
+                semi = n;
+        }
+        // The last ')' before that ';' and after this opener: the same for every
+        // opener before the ';', so it is looked for once and only as far back as
+        // the first of them.
+        if (parenFor !== semi) {
+            parenFor = semi;
+            paren = semi - 1;
+            while (paren >= a + 1 && block.charCodeAt(paren) !== 41)
+                paren--;
+        }
+        if (paren >= a + 1) {
+            return { index: m.index, text: block.slice(m.index, paren + 1), groups: [undefined, block.slice(a, paren)] };
+        }
+    }
+    return null;
+}
+/** css.match(/grid-template-columns[^}]*repeat\s*\(\s*(?:auto-fit|auto-fill|\d+)/gi) || [] */
+function gridRepeatRules(css) {
+    const start = /grid-template-columns/gi;
+    const x = /repeat\s*\(\s*(?:auto-fit|auto-fill|\d+)/iy;
+    const leads = matchStarts(css, /repeat/gi);
+    const out = [];
+    let ptr = 0;
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const after = m.index + m[0].length;
+        let c = css.indexOf('}', after);
+        if (c < 0)
+            c = css.length;
+        while (ptr < leads.length && leads[ptr] < after)
+            ptr++;
+        let end = ptr;
+        while (end < leads.length && leads[end] < c)
+            end++;
+        let hit = null;
+        for (let k = end - 1; k >= ptr && !hit; k--) {
+            x.lastIndex = leads[k];
+            hit = x.exec(css);
+        }
+        ptr = end;
+        if (hit)
+            out.push(css.slice(m.index, hit.index + hit[0].length));
+        if (c >= css.length)
+            break;
+        pos = c + 1;
+    }
+    return out;
+}
+/**
+ * html.match(/(?:<button|<a[^>]*class[^>]*(?:btn|cta|primary|action))[^>]*>[\s\S]{0,200}(?:[\p{Emoji_Presentation}]|[\p{Emoji}]\uFE0F)/giu)
+ */
+function emojiCtaMatches(html) {
+    const n = html.length;
+    const start = /<button|<a/giu;
+    const cls = nextMatchFinder(html, /class/giu);
+    const word = nextMatchFinder(html, /btn|cta|primary|action/giu);
+    const gt = nextMatchFinder(html, />/g);
+    const emoji = /[\p{Emoji_Presentation}]|[\p{Emoji}]\uFE0F/gu;
+    const emojiAt = [];
+    const emojiEnd = [];
+    for (let e = emoji.exec(html); e; e = emoji.exec(html)) {
+        emojiAt.push(e.index);
+        emojiEnd.push(e.index + e[0].length);
+    }
+    // End of the match for the content after `>` at g: the last emoji that
+    // starts within 200 code points of it, or -1.
+    const tail = (g) => {
+        let w = g + 1;
+        for (let k = 0; k < 200 && w < n; k++) {
+            const c = html.charCodeAt(w);
+            w += c >= 0xd800 && c <= 0xdbff && w + 1 < n && html.charCodeAt(w + 1) >= 0xdc00 && html.charCodeAt(w + 1) <= 0xdfff ? 2 : 1;
+        }
+        let lo = 0;
+        let hi = emojiAt.length - 1;
+        let best = -1;
+        while (lo <= hi) {
+            const mid = (lo + hi) >> 1;
+            if (emojiAt[mid] <= w) {
+                best = mid;
+                lo = mid + 1;
+            }
+            else
+                hi = mid - 1;
+        }
+        return best >= 0 && emojiAt[best] >= g + 1 ? emojiEnd[best] : -1;
+    };
+    const out = [];
+    let tailFor = -1;
+    let tailStop = -1;
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(html);
+        if (!m)
+            break;
+        const g = gt(m.index + 1);
+        if (g === Infinity)
+            break;
+        if (tailFor !== g) {
+            tailFor = g;
+            tailStop = tail(g);
+        }
+        if (tailStop < 0) {
+            pos = g + 1;
+            continue;
+        }
+        let ok = m[0].length === 7;
+        if (!ok) {
+            const c = cls(m.index + 2);
+            ok = c < g && word(c + 5) < g;
+        }
+        if (!ok) {
+            pos = m.index + 1;
+            continue;
+        }
+        out.push(html.slice(m.index, tailStop));
+        pos = tailStop;
+    }
+    return out.length ? out : null;
+}
+/** key.replace(/(\.\d*?)0+(?=\D|$)/g, '$1') */
+function withoutTrailingDecimalZeros(key) {
+    const parts = [];
+    let last = 0;
+    for (let i = key.indexOf('.'); i >= 0;) {
+        let d = i + 1;
+        while (d < key.length && key.charCodeAt(d) >= 48 && key.charCodeAt(d) <= 57)
+            d++;
+        let z = d;
+        while (z > i + 1 && key.charCodeAt(z - 1) === 48)
+            z--;
+        if (z < d) {
+            parts.push(key.slice(last, z));
+            last = d;
+        }
+        i = key.indexOf('.', d);
+    }
+    parts.push(key.slice(last));
+    return parts.join('');
+}
+/** /prefers-reduced-motion[\s\S]{0,200}\*\s*\{[^}]*animation\s*:\s*none/i.test(css) */
+function hasBlanketMotionKill(css) {
+    const start = /prefers-reduced-motion/gi;
+    const kill = nextMatchFinder(css, /animation\s*:\s*none/gi);
+    const close = nextMatchFinder(css, /\}/g);
+    let checked = -1;
+    for (let m = start.exec(css); m; m = start.exec(css)) {
+        const from = m.index + m[0].length;
+        const to = Math.min(css.length - 1, from + 200);
+        // A `*` reads the same whichever start reaches it, so each is read once.
+        for (let q = Math.max(from, checked + 1); q <= to; q++) {
+            if (css.charCodeAt(q) !== 42)
+                continue;
+            const b = wsEnd(css, q + 1);
+            if (css.charCodeAt(b) !== 123)
+                continue;
+            if (kill(b + 1) < close(b + 1))
+                return true;
+        }
+        if (to > checked)
+            checked = to;
+    }
+    return false;
+}
+/** html.match(/<svg[^>]*viewBox=/gi) || [] */
+function svgViewBoxTags(html) {
+    const start = /<svg/gi;
+    const leads = matchStarts(html, /viewBox=/gi);
+    const gt = nextMatchFinder(html, />/g);
+    const out = [];
+    let ptr = 0;
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(html);
+        if (!m)
+            break;
+        const after = m.index + m[0].length;
+        const g = Math.min(gt(after), html.length);
+        while (ptr < leads.length && leads[ptr] < after)
+            ptr++;
+        let end = ptr;
+        while (end < leads.length && leads[end] < g)
+            end++;
+        if (end > ptr) {
+            const k = leads[end - 1];
+            out.push(html.slice(m.index, k + 8));
+            pos = k + 8;
+            ptr = end;
+            continue;
+        }
+        if (g >= html.length)
+            break;
+        pos = g + 1;
+    }
+    return out;
+}
+/** html.match(/<symbol[^>]*>/gi) || [] */
+function symbolTags(html) {
+    const start = /<symbol/gi;
+    const out = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(html);
+        if (!m)
+            break;
+        const g = html.indexOf('>', m.index + m[0].length);
+        if (g < 0)
+            break;
+        out.push(html.slice(m.index, g + 1));
+        pos = g + 1;
+    }
+    return out;
+}
+/** A [\w-] code unit (\w without the u flag). */
+function isNameChar(c) {
+    return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95 || c === 45;
+}
+/** The index after the run of [\w-] that starts at `i`. */
+function nameEnd(s, i) {
+    while (i < s.length && isNameChar(s.charCodeAt(i)))
+        i++;
+    return i;
+}
+/** css.match(/--[\w-]+\s*:/g) || [] */
+function customPropertyDecls(css) {
+    const out = [];
+    for (let pos = 0;;) {
+        const i = css.indexOf('--', pos);
+        if (i < 0)
+            break;
+        const r = nameEnd(css, i + 2);
+        if (r === i + 2) {
+            pos = i + 1;
+            continue;
+        }
+        const t = wsEnd(css, r);
+        if (css.charCodeAt(t) === 58) {
+            out.push(css.slice(i, t + 1));
+            pos = t + 1;
+            continue;
+        }
+        // Every later `--` inside the same name ends at the same r and fails too.
+        pos = r;
+    }
+    return out;
+}
+/** Matches of /--([\w-]+)\s*:\s*([^;]+?)(?:;|$)/g: groups [name, value]. */
+function customPropertyValues(block) {
+    const out = [];
+    const n = block.length;
+    for (let pos = 0;;) {
+        const i = block.indexOf('--', pos);
+        if (i < 0)
+            break;
+        const r = nameEnd(block, i + 2);
+        if (r === i + 2) {
+            pos = i + 1;
+            continue;
+        }
+        const colon = wsEnd(block, r);
+        if (block.charCodeAt(colon) !== 58) {
+            pos = r;
+            continue;
+        }
+        let v = wsEnd(block, colon + 1);
+        // ([^;]+?) needs one character: when the space runs up to a ';' or the
+        // end, the last space is that character.
+        if (v >= n || block.charCodeAt(v) === 59) {
+            if (v === colon + 1) {
+                pos = r;
+                continue;
+            }
+            v--;
+        }
+        let e = block.indexOf(';', v + 1);
+        if (e < 0)
+            e = n;
+        const stop = e < n ? e + 1 : n;
+        out.push({ index: i, text: block.slice(i, stop), groups: [block.slice(i + 2, r), block.slice(v, e)] });
+        pos = stop;
+    }
+    return out;
+}
+/** /--(?:color|surface|accent|action|feedback)[\w-]*\s*:\s*var\(--/i.test(css) */
+function hasTokenLayering(css) {
+    const start = /--(?:color|surface|accent|action|feedback)/gi;
+    const varAt = /var\(--/iy;
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            return false;
+        const r = nameEnd(css, m.index + m[0].length);
+        const t = wsEnd(css, r);
+        if (css.charCodeAt(t) === 58) {
+            varAt.lastIndex = wsEnd(css, t + 1);
+            if (varAt.test(css))
+                return true;
+        }
+        // Every later start inside the same name reaches the same r.
+        pos = Math.max(r, m.index + 1);
+    }
+}
+/** `text` with each [start, end) span replaced by fn(the spanned text). */
+function replaceSpansWith(text, spans, fn) {
+    if (spans.length === 0)
+        return text;
+    const parts = [];
+    let last = 0;
+    for (let k = 0; k < spans.length; k += 2) {
+        parts.push(text.slice(last, spans[k]), fn(text.slice(spans[k], spans[k + 1])));
+        last = spans[k + 1];
+    }
+    parts.push(text.slice(last));
+    return parts.join('');
+}
+/** Spans of /\[[^\]]*\]/g. */
+function bracketSpans(text) {
+    const spans = [];
+    for (let pos = 0;;) {
+        const i = text.indexOf('[', pos);
+        if (i < 0)
+            break;
+        const j = text.indexOf(']', i + 1);
+        if (j < 0)
+            break;
+        spans.push(i, j + 1);
+        pos = j + 1;
+    }
+    return spans;
+}
+/** text.match(/\[[^\]]*\]|\.[\w-]+/g) */
+function attrAndClassParts(text) {
+    const out = [];
+    const lastClose = text.lastIndexOf(']');
+    for (let pos = 0; pos < text.length;) {
+        const ch = text.charCodeAt(pos);
+        if (ch === 91 && lastClose > pos) {
+            const j = text.indexOf(']', pos + 1);
+            out.push(text.slice(pos, j + 1));
+            pos = j + 1;
+            continue;
+        }
+        if (ch === 46) {
+            const r = nameEnd(text, pos + 1);
+            if (r > pos + 1) {
+                out.push(text.slice(pos, r));
+                pos = r;
+                continue;
+            }
+        }
+        pos++;
+    }
+    return out.length ? out : null;
+}
+/** v45: /^\[[\w-]*(?:motion|anim)[\w-]*(?:[~|^$*]?=[^\]]*)?\]$/i.test(s) */
+function isMotionToggleAttr(s) {
+    const n = s.length;
+    if (n < 2 || s.charCodeAt(0) !== 91 || s.charCodeAt(n - 1) !== 93)
+        return false;
+    const r = nameEnd(s, 1);
+    if (!/motion|anim/i.test(s.slice(1, r)))
+        return false;
+    if (r === n - 1)
+        return true;
+    let k = r;
+    if ('~|^$*'.indexOf(s[k]) >= 0)
+        k++;
+    if (s.charCodeAt(k) !== 61)
+        return false;
+    return s.indexOf(']', k + 1) === n - 1;
+}
+/** Where `\s*!\s*important\s*$` (case-insensitive) begins in `value`, or -1. */
+function importantSuffixStart(value) {
+    let e = value.length;
+    while (e > 0 && isJsSpace(value.charCodeAt(e - 1)))
+        e--;
+    if (e < 9 || !/^important$/i.test(value.slice(e - 9, e)))
+        return -1;
+    let k = e - 9;
+    while (k > 0 && isJsSpace(value.charCodeAt(k - 1)))
+        k--;
+    if (k === 0 || value.charCodeAt(k - 1) !== 33)
+        return -1;
+    k--;
+    while (k > 0 && isJsSpace(value.charCodeAt(k - 1)))
+        k--;
+    return k;
+}
+/** A [0-9] code unit. */
+function isDigit(c) {
+    return c >= 48 && c <= 57;
+}
+/** color-mix: /^([\s\S]*?)\s+(\d*\.?\d+)%$/.exec(p) */
+function percentAfter(p) {
+    const n = p.length;
+    if (n === 0 || p.charCodeAt(n - 1) !== 37)
+        return null;
+    let q = n - 1;
+    while (q > 0 && (isDigit(p.charCodeAt(q - 1)) || p.charCodeAt(q - 1) === 46))
+        q--;
+    if (!/^(?:\d+(?:\.\d+)?|\.\d+)$/.test(p.slice(q, n - 1)))
+        return null;
+    if (q === 0 || !isJsSpace(p.charCodeAt(q - 1)))
+        return null;
+    let w = q - 1;
+    while (w > 0 && isJsSpace(p.charCodeAt(w - 1)))
+        w--;
+    return [p, p.slice(0, w), p.slice(q, n - 1)];
+}
+/**
+ * Relative colour syntax:
+ * /^from\s+([\s\S]+?)\s+(r\s+g\s+b|h\s+s\s+l|l\s+c\s+h|l\s+a\s+b)\s*(?:\/\s*([\s\S]+))?$/.exec(args)
+ */
+function relativeColorMatch(args) {
+    if (!args.startsWith('from') || !isJsSpace(args.charCodeAt(4)))
+        return null;
+    const channels = /(r\s+g\s+b|h\s+s\s+l|l\s+c\s+h|l\s+a\s+b)\s*(?:\/\s*([\s\S]+))?$/y;
+    const tail = (k) => {
+        channels.lastIndex = k;
+        return channels.exec(args);
+    };
+    const start = wsEnd(args, 4);
+    // The base is lazy: it ends at the first run of space after its first
+    // character that the channel keywords and the rest of the value follow.
+    for (let k = start + 1; k < args.length; k++) {
+        if (!isJsSpace(args.charCodeAt(k)))
+            continue;
+        const w = wsEnd(args, k);
+        const t = tail(w);
+        if (t)
+            return [args, args.slice(start, k), t[1], t[2]];
+        k = w;
+    }
+    // With less of the leading space taken, the base can be one space whose
+    // following space leads straight to the keywords.
+    if (start - 4 >= 3) {
+        const t = tail(start);
+        if (t)
+            return [args, args.slice(start - 2, start - 1), t[1], t[2]];
+    }
+    return null;
+}
+/** html.match(/<input\b[^>]*>/gi) || [] */
+function inputTags(html) {
+    const start = /<input\b/gi;
+    const out = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(html);
+        if (!m)
+            break;
+        const g = html.indexOf('>', m.index + m[0].length);
+        if (g < 0)
+            break;
+        out.push(html.slice(m.index, g + 1));
+        pos = g + 1;
+    }
+    return out;
+}
+/** /<title\b[^>]*>[^<]+<\/title>/i.test(html) */
+function hasTitleText(html) {
+    const start = /<title\b/gi;
+    const close = /<\/title>/iy;
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(html);
+        if (!m)
+            return false;
+        const g = html.indexOf('>', m.index + m[0].length);
+        if (g < 0)
+            return false;
+        const lt = html.indexOf('<', g + 1);
+        if (lt < 0)
+            return false;
+        if (lt > g + 1) {
+            close.lastIndex = lt;
+            if (close.test(html))
+                return true;
+        }
+        // Every start before g reaches the same `>` and the same `<` after it.
+        pos = g + 1;
+    }
+}
+/**
+ * /TAG[^>]*ATTR[^"']*WORD/i.test(html): `open` (global) matches the tag's
+ * start, `attr` (global) an attribute name with its `=` and opening quote, and
+ * `word` (global, holding no quote) what the value must contain before its
+ * closing quote.
+ */
+function tagAttrValueHas(html, open, attr, word) {
+    const attrs = [];
+    const values = [];
+    attr.lastIndex = 0;
+    for (let a = attr.exec(html); a; a = attr.exec(html)) {
+        attrs.push(a.index);
+        values.push(a.index + a[0].length);
+    }
+    const gt = nextMatchFinder(html, />/g);
+    const found = nextMatchFinder(html, word);
+    const n = html.length;
+    let ptr = 0;
+    for (let pos = 0;;) {
+        open.lastIndex = pos;
+        const m = open.exec(html);
+        if (!m)
+            return false;
+        const after = m.index + m[0].length;
+        const g = Math.min(gt(after), n);
+        // Each attribute in the tag is read once: what follows it does not
+        // depend on which start reached it.
+        while (ptr < attrs.length && attrs[ptr] < after)
+            ptr++;
+        for (; ptr < attrs.length && attrs[ptr] < g; ptr++) {
+            const v = values[ptr];
+            let q = v;
+            while (q < n && html.charCodeAt(q) !== 34 && html.charCodeAt(q) !== 39)
+                q++;
+            if (found(v) < q)
+                return true;
+        }
+        if (g >= n)
+            return false;
+        pos = g + 1;
+    }
+}
+/** The index of the first entry of an ascending list at or after `x` (the length when none). */
+function lowerBound(list, x) {
+    let lo = 0;
+    let hi = list.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (list[mid] < x)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+/** Matches of /:root(?:\s*,\s*:host)?\s*\{([^}]*)\}/g: groups [body]. */
+function rootTokenBlocks(css) {
+    const start = /:root/g;
+    const out = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const p = m.index + m[0].length;
+        let b = -1;
+        // The optional ", :host": whitespace, a comma, whitespace, ":host".
+        const comma = wsEnd(css, p);
+        if (css.charCodeAt(comma) === 44) {
+            const h = wsEnd(css, comma + 1);
+            if (css.startsWith(':host', h)) {
+                const q = wsEnd(css, h + 5);
+                if (css.charCodeAt(q) === 123)
+                    b = q;
+            }
+        }
+        if (b < 0) {
+            const q = wsEnd(css, p);
+            if (css.charCodeAt(q) === 123)
+                b = q;
+        }
+        if (b < 0) {
+            pos = m.index + 1;
+            continue;
+        }
+        const c = css.indexOf('}', b + 1);
+        if (c < 0)
+            break;
+        out.push({ index: m.index, text: css.slice(m.index, c + 1), groups: [css.slice(b + 1, c)] });
+        pos = c + 1;
+    }
+    return out;
+}
+/** v05: /@view-transition\s*\{[^}]*navigation\s*:\s*auto/i.test(body) */
+function hasViewTransitionNavigation(body) {
+    const start = /@view-transition/gi;
+    const found = nextMatchFinder(body, /navigation\s*:\s*auto/gi);
+    const close = nextMatchFinder(body, /\}/g);
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(body);
+        if (!m)
+            return false;
+        const b = wsEnd(body, m.index + m[0].length);
+        if (body.charCodeAt(b) !== 123) {
+            pos = m.index + 1;
+            continue;
+        }
+        const c = close(b + 1);
+        if (found(b + 1) < c)
+            return true;
+        if (c === Infinity)
+            return false;
+        // Every later start before c reads the same body, or less of it.
+        pos = c + 1;
+    }
+}
+/**
+ * v34: /<script\s+type\s*=\s*["']application\/ld\+json["'][\s\S]*?"@type"\s*:\s*"[^"]*\b(?:ai|softwareapplication)\b[^"]*"[\s\S]*?(?:"applicationCategory"\s*:\s*"[^"]*ai[^"]*"|"[^"]*ai[^"]*")/i.test(html)
+ * Only the first opener and the first matching @type matter: later ones see
+ * less of the page. The applicationCategory form is one of the quoted
+ * strings holding "ai" that the second form accepts.
+ */
+function hasAiJsonLd(html) {
+    const open = /<script\s+type\s*=\s*["']application\/ld\+json["']/i.exec(html);
+    if (!open)
+        return false;
+    const type = /"@type"\s*:\s*"/gi;
+    const word = nextMatchFinder(html, /\b(?:ai|softwareapplication)\b/gi);
+    type.lastIndex = open.index + open[0].length;
+    for (let t = type.exec(html); t; t = type.exec(html)) {
+        const v = t.index + t[0].length;
+        const q = html.indexOf('"', v);
+        if (q < 0)
+            return false;
+        if (word(v) < q) {
+            for (let p = html.indexOf('"', q + 1); p >= 0;) {
+                const e = html.indexOf('"', p + 1);
+                if (e < 0)
+                    return false;
+                if (/ai/i.test(html.slice(p + 1, e)))
+                    return true;
+                p = e;
+            }
+            return false;
+        }
+        type.lastIndex = q;
+    }
+    return false;
+}
+/** v10: /transition\s*:[^;]*transform[^;]*(ease-out|cubic-bezier\([^)]*0[, ])/i.test(css) */
+function hasTransformEaseTransition(css) {
+    const start = /transition\s*:/gi;
+    const transform = nextMatchFinder(css, /transform/gi);
+    const ease = nextMatchFinder(css, /ease-out/gi);
+    const paren = nextMatchFinder(css, /\)/g);
+    const beziers = matchStarts(css, /cubic-bezier\(/gi);
+    const zeros = matchStarts(css, /0[, ]/g);
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            return false;
+        const p = m.index + m[0].length;
+        let r = css.indexOf(';', p);
+        if (r < 0)
+            r = css.length;
+        const t = transform(p);
+        if (t < r) {
+            const from = t + 9;
+            if (ease(from) < r)
+                return true;
+            // A cubic-bezier( that starts before r and holds a 0 followed by a
+            // comma or a space before its first ')'.
+            for (let k = lowerBound(beziers, from); k < beziers.length && beziers[k] < r; k++) {
+                const inner = beziers[k] + 13;
+                const z = lowerBound(zeros, inner);
+                if (z < zeros.length && zeros[z] + 1 < paren(inner))
+                    return true;
+            }
+        }
+        // Every later start before r reads the same declaration, or less of it.
+        if (r >= css.length)
+            return false;
+        pos = r + 1;
+    }
+}
+/** S3: css.match(/(?:background(?:-image)?\s*:[^;]*linear-gradient[^;]*(?:#?(?:615fff|8e51ff|4f39f6|7f22fe|a855f7|9333ea|7c3aed|6d28d9|5b21b6|4c1d95)))/gi) */
+function purpleGradientDecls(css) {
+    const start = /background(?:-image)?\s*:/gi;
+    const gradient = nextMatchFinder(css, /linear-gradient/gi);
+    const hueRe = /615fff|8e51ff|4f39f6|7f22fe|a855f7|9333ea|7c3aed|6d28d9|5b21b6|4c1d95/gi;
+    // Every place a hue starts, overlapping ones included (a855f7f22fe holds two).
+    const hues = [];
+    for (let h = hueRe.exec(css); h; h = hueRe.exec(css)) {
+        hues.push(h.index);
+        hueRe.lastIndex = h.index + 1;
+    }
+    const out = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const p = m.index + m[0].length;
+        let r = css.indexOf(';', p);
+        if (r < 0)
+            r = css.length;
+        const g = gradient(p);
+        if (g < r) {
+            // The last hue before r, if it starts after the gradient's name.
+            const k = lowerBound(hues, r) - 1;
+            if (k >= 0 && hues[k] >= g + 15)
+                out.push(css.slice(m.index, hues[k] + 6));
+        }
+        // Every later start before r finds no hue after this one.
+        if (r >= css.length)
+            break;
+        pos = r + 1;
+    }
+    return out.length ? out : null;
+}
+/** S4: stop.match(/rgba?\(([^)]+)\)/i) */
+function rgbArgs(stop) {
+    const start = /rgba?\(/gi;
+    for (let m = start.exec(stop); m; m = start.exec(stop)) {
+        const p = m.index + m[0].length;
+        const c = stop.indexOf(')', p);
+        if (c < 0)
+            return null;
+        if (c > p)
+            return [stop.slice(m.index, c + 1), stop.slice(p, c)];
+    }
+    return null;
+}
+/** A tag-name code unit for [a-z0-9-] under the i flag. */
+function isTagNameChar(c) {
+    return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 45;
+}
+/** A \w code unit (no u flag). */
+function isWordChar(c) {
+    return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;
+}
+/** The first entry of an ascending list at or after `x`, or -1. */
+function firstAtOrAfter(list, x) {
+    let lo = 0;
+    let hi = list.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (list[mid] < x)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo < list.length ? list[lo] : -1;
+}
+/**
+ * v38: inner.replace(/<([a-z][a-z0-9-]*)\b[^>]*\baria-hidden\s*=\s*["']?true["']?[^>]*>[\s\S]*?<\/\1>/gi, '')
+ * The closing tag must repeat the name, so the names of the closing tags are
+ * kept in a trie and each opener's name is walked through it once.
+ */
+function withoutAriaHiddenElements(inner) {
+    const n = inner.length;
+    const root = { kids: new Map(), at: [] };
+    const closeRe = /<\/([a-z0-9-]+)>/gi;
+    for (let c = closeRe.exec(inner); c; c = closeRe.exec(inner)) {
+        let node = root;
+        const name = c[1].toLowerCase();
+        for (let k = 0; k < name.length; k++) {
+            const code = name.charCodeAt(k);
+            let next = node.kids.get(code);
+            if (!next) {
+                next = { kids: new Map(), at: [] };
+                node.kids.set(code, next);
+            }
+            node = next;
+        }
+        node.at.push(c.index);
+    }
+    const hidden = matchStarts(inner, /\baria-hidden\s*=\s*["']?true/gi);
+    const gt = nextMatchFinder(inner, />/g);
+    const start = /<[a-z]/gi;
+    const spans = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(inner);
+        if (!m)
+            break;
+        const i = m.index;
+        const g = gt(i + 1);
+        if (g === Infinity)
+            break;
+        // Name lengths whose name is also a closing tag's name, longest last.
+        const lens = [];
+        const nodes = [];
+        let node = root;
+        for (let e = i + 1; e < n && isTagNameChar(inner.charCodeAt(e)); e++) {
+            const code = inner.charCodeAt(e);
+            node = node.kids.get(code >= 65 && code <= 90 ? code + 32 : code);
+            if (!node)
+                break;
+            if (node.at.length) {
+                lens.push(e + 1 - (i + 1));
+                nodes.push(node);
+            }
+        }
+        let stop = -1;
+        for (let k = lens.length - 1; k >= 0 && stop < 0; k--) {
+            const ne = i + 1 + lens[k];
+            const before = isWordChar(inner.charCodeAt(ne - 1));
+            const after = ne < n && isWordChar(inner.charCodeAt(ne));
+            if (before === after)
+                continue;
+            const a = firstAtOrAfter(hidden, ne);
+            if (a < 0 || a >= g)
+                continue;
+            const c = firstAtOrAfter(nodes[k].at, g + 1);
+            if (c < 0)
+                continue;
+            stop = c + 3 + lens[k];
+        }
+        if (stop >= 0) {
+            spans.push(i, stop);
+            pos = stop;
+        }
+        else
+            pos = i + 1;
+    }
+    return replaceSpans(inner, spans, '');
+}
+/** text.replace(/<kbd\b[^>]*>(?:(?!<kbd\b)[\s\S])*?<\/kbd>/gi, ' ') */
+function withoutKbdElements(text) {
+    const start = /<kbd\b/gi;
+    const gt = nextMatchFinder(text, />/g);
+    const opener = nextMatchFinder(text, /<kbd\b/gi);
+    const closer = nextMatchFinder(text, /<\/kbd>/gi);
+    const spans = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(text);
+        if (!m)
+            break;
+        const g = gt(m.index + m[0].length);
+        if (g === Infinity)
+            break;
+        const c = closer(g + 1);
+        if (c === Infinity)
+            break;
+        // A nested <kbd> opens first: no start before this `>` matches; the
+        // nested one is tried in turn.
+        if (opener(g + 1) < c) {
+            pos = g + 1;
+            continue;
+        }
+        spans.push(m.index, c + 6);
+        pos = c + 6;
+    }
+    return replaceSpans(text, spans, ' ');
+}
+/** s.replace(/[\s]*[\u2303\u2318\u2325\u21E7\u21E7\u2387].*$/i, '') */
+function withoutGlyphShortcut(s) {
+    let lt = -1;
+    for (let k = s.length - 1; k >= 0; k--) {
+        if (isLineTerminator(s.charCodeAt(k))) {
+            lt = k;
+            break;
+        }
+    }
+    for (let k = lt + 1; k < s.length; k++) {
+        const c = s.charCodeAt(k);
+        if (c === 0x2303 || c === 0x2318 || c === 0x2325 || c === 0x21e7 || c === 0x2387) {
+            let w = k;
+            while (w > 0 && isJsSpace(s.charCodeAt(w - 1)))
+                w--;
+            return s.slice(0, w);
+        }
+    }
+    return s;
+}
+/** s.replace(/[\s]*(?:Ctrl|Cmd|Shift|Alt|Option|Command)(?:\+[A-Za-z0-9+\-]*|[A-Z0-9]+)?$/, '') */
+function withoutTextShortcut(s) {
+    const n = s.length;
+    let plusRun = n;
+    while (plusRun > 0) {
+        const c = s.charCodeAt(plusRun - 1);
+        if (!(isDigit(c) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 43 || c === 45))
+            break;
+        plusRun--;
+    }
+    let upperRun = n;
+    while (upperRun > 0) {
+        const c = s.charCodeAt(upperRun - 1);
+        if (!(isDigit(c) || (c >= 65 && c <= 90)))
+            break;
+        upperRun--;
+    }
+    const mod = /Ctrl|Cmd|Shift|Alt|Option|Command/g;
+    for (let m = mod.exec(s); m; m = mod.exec(s)) {
+        const t = m.index + m[0].length;
+        if (t === n || (s.charCodeAt(t) === 43 && t + 1 >= plusRun) || t >= upperRun) {
+            let w = m.index;
+            while (w > 0 && isJsSpace(s.charCodeAt(w - 1)))
+                w--;
+            return s.slice(0, w);
+        }
+    }
+    return s;
+}
+/** s.replace(/(?:\s*\+)+$/, '') */
+function withoutTrailingPluses(s) {
+    if (s.charCodeAt(s.length - 1) !== 43)
+        return s;
+    let k = s.length;
+    while (k > 0 && (s.charCodeAt(k - 1) === 43 || isJsSpace(s.charCodeAt(k - 1))))
+        k--;
+    return s.slice(0, k);
+}
+/** S2: /(?:transparent|rgba\([^)]+\)|color-mix\([^)]*\)|var\([^)]*\)|#[0-9a-fA-F]{3,8})\s+1px(?:\s*,)/.test(text) */
+function hasColorThenHairline(text) {
+    const close = nextMatchFinder(text, /\)/g);
+    let tailAt = -1;
+    let tailOk = false;
+    const tail = (e) => {
+        if (e !== tailAt) {
+            tailAt = e;
+            const t = wsEnd(text, e);
+            tailOk = t > e && text.startsWith('1px', t) && text.charCodeAt(wsEnd(text, t + 3)) === 44;
+        }
+        return tailOk;
+    };
+    const head = /transparent|rgba\(|color-mix\(|var\(|#/g;
+    for (let m = head.exec(text); m; m = head.exec(text)) {
+        const i = m.index;
+        const after = i + m[0].length;
+        // `transparent` can overlap itself: try the very next position too.
+        head.lastIndex = i + 1;
+        if (m[0] === 'transparent') {
+            if (tail(after))
+                return true;
+        }
+        else if (m[0] === '#') {
+            let h = after;
+            while (h < text.length && /[0-9a-fA-F]/.test(text[h]))
+                h++;
+            if (h - after >= 3 && h - after <= 8 && tail(h))
+                return true;
+        }
+        else {
+            const p = close(after);
+            if (p === Infinity)
+                continue;
+            if (m[0] === 'rgba(' && p === after)
+                continue;
+            if (tail(p + 1))
+                return true;
+        }
+    }
+    return false;
+}
+/** S2: /\s+1px\s*,\s*(?:transparent|rgba\([^)]+\)|color-mix\([^)]*\)|var\([^)]*\))/.test(text) */
+function hasHairlineThenColor(text) {
+    const lastClose = text.lastIndexOf(')');
+    for (let at = text.indexOf('1px'); at >= 0; at = text.indexOf('1px', at + 1)) {
+        if (at === 0 || !isJsSpace(text.charCodeAt(at - 1)))
+            continue;
+        let t = wsEnd(text, at + 3);
+        if (text.charCodeAt(t) !== 44)
+            continue;
+        t = wsEnd(text, t + 1);
+        if (text.startsWith('transparent', t))
+            return true;
+        if (text.startsWith('rgba(', t) && text.charCodeAt(t + 5) !== 41 && lastClose > t + 5)
+            return true;
+        if (text.startsWith('color-mix(', t) && lastClose >= t + 10)
+            return true;
+        if (text.startsWith('var(', t) && lastClose >= t + 4)
+            return true;
+    }
+    return false;
+}
+/** S2: /\/\s*[^,/]*(?:^|\s)1px(?:$|[\s,])/.test(value) */
+function hasSlashThenHairline(value) {
+    let lastSep = -1;
+    for (let k = 0; k < value.length; k++) {
+        const c = value.charCodeAt(k);
+        if (c === 44 || c === 47) {
+            lastSep = k;
+            continue;
+        }
+        if (c !== 49 || k === 0 || !value.startsWith('1px', k) || !isJsSpace(value.charCodeAt(k - 1)))
+            continue;
+        const next = value.charCodeAt(k + 3);
+        if ((k + 3 === value.length || isJsSpace(next) || next === 44) && lastSep >= 0 && value.charCodeAt(lastSep) === 47)
+            return true;
+    }
+    return false;
+}
+/** css.match(/linear\(\s*[^)]{20,}\)/gi) || [] */
+function longLinearEasings(css) {
+    const start = /linear\(/gi;
+    const out = [];
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const after = m.index + m[0].length;
+        const c = css.indexOf(')', after);
+        if (c < 0)
+            break;
+        if (c - after >= 20)
+            out.push(css.slice(m.index, c + 1));
+        // Every start before c reads the same ')' with less between.
+        pos = c + 1;
+    }
+    return out;
+}
+/**
+ * Group 1 of each match of
+ * /<link[^>]*rel=["']?stylesheet["']?[^>]*href=["']([^"']+)["']/gi:
+ * the last quoted href in the tag after its first rel=stylesheet.
+ */
+function stylesheetLinkMatches(html) {
+    const start = /<link/gi;
+    const rel = nextMatchFinder(html, /rel=["']?stylesheet/gi);
+    const hrefs = matchStarts(html, /href=["']/gi);
+    const gt = nextMatchFinder(html, />/g);
+    const n = html.length;
+    const isQuote = (c) => c === 34 || c === 39;
+    let lastQuote = n - 1;
+    while (lastQuote >= 0 && !isQuote(html.charCodeAt(lastQuote)))
+        lastQuote--;
+    const out = [];
+    let ptr = 0;
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(html);
+        if (!m)
+            break;
+        const after = m.index + m[0].length;
+        const g = Math.min(gt(after), n);
+        while (ptr < hrefs.length && hrefs[ptr] < after)
+            ptr++;
+        let end = ptr;
+        while (end < hrefs.length && hrefs[end] < g)
+            end++;
+        // The last href=" in the tag whose value is non-empty and closes.
+        let h = -1;
+        for (let k = end - 1; k >= ptr && h < 0; k--) {
+            const v = hrefs[k] + 6;
+            if (v < n && !isQuote(html.charCodeAt(v)) && lastQuote > v)
+                h = hrefs[k];
+        }
+        const r = rel(after);
+        if (h >= 0 && r < g && r + (isQuote(html.charCodeAt(r + 4)) ? 15 : 14) <= h) {
+            let q = h + 7;
+            while (!isQuote(html.charCodeAt(q)))
+                q++;
+            out.push({ index: m.index, text: html.slice(m.index, q + 1), groups: [html.slice(h + 6, q)] });
+            pos = q + 1;
+            continue;
+        }
+        // Every start before g sees less of the same tag.
+        if (g >= n)
+            break;
+        pos = g + 1;
+    }
+    return out;
+}
+/**
+ * For each `{` in `opens`, the index of the `}` that brings the depth back to
+ * zero from it, or -1: what a depth-counting walk from that brace finds, for
+ * every brace in one pass.
+ */
+function closingBraces(code, opens) {
+    const out = new Map();
+    const stack = [];
+    for (let k = 0; k < code.length; k++) {
+        const ch = code.charCodeAt(k);
+        if (ch === 123)
+            stack.push(k);
+        else if (ch === 125 && stack.length) {
+            const open = stack.pop();
+            if (opens.has(open))
+                out.set(open, k);
+        }
+    }
+    return out;
+}
+// ── The call sites, one helper each, so the test runs exactly what they run ──
+/** /<button[^>]*>([\s\S]*?)<\/button>/gi (v38, v39). */
+function buttonElements(html) {
+    return elementMatches(html, /<button/gi, /<\/button>/gi);
+}
+/** /<label[^>]*>([\s\S]*?)<\/label>/gi (v39). */
+function labelElements(html) {
+    return elementMatches(html, /<label/gi, /<\/label>/gi);
+}
+/** /<a[^>]*>([\s\S]*?)<\/a>/gi (v40). */
+function anchorElements(html) {
+    return elementMatches(html, /<a/gi, /<\/a>/gi);
+}
+/** /<style[^>]*>([\s\S]*?)<\/style>/gi (inline stylesheets). */
+function styleElements(html) {
+    return elementMatches(html, /<style/gi, /<\/style>/gi);
+}
+/** /<(?:a|div|span)[^>]*role=["']button["'][^>]*>([\s\S]*?)<\/(?:a|div|span)>/gi (v38). */
+function roleButtonElements(html) {
+    return roleElementMatches(html, /<(?:a|div|span)/gi, /role=["']button["']/gi, /<\/(?:a|div|span)>/gi);
+}
+/** /<[a-z]+[^>]*role=["']tab["'][^>]*>([\s\S]*?)<\/[a-z]+>/gi (v39). */
+function roleTabElements(html) {
+    return roleElementMatches(html, /<[a-z]/gi, /role=["']tab["']/gi, /<\/[a-z]+>/gi);
+}
+/** v41: /class=["'][^"']*(eyebrow|eyebro|meta-label)[^"']*["']/i.test(attrs) */
+function hasEyebrowClass(attrs) {
+    return quotedAttrHas(attrs, /class=["']/gi, /eyebro|meta-label/gi);
+}
+/** v41: /style=["'][^"']*text-transform:\s*uppercase[^"']*["']/i.test(attrs) */
+function hasUppercaseStyle(attrs) {
+    return quotedAttrHas(attrs, /style=["']/gi, /text-transform:\s*uppercase/gi);
+}
+/** v17: /(?:h1|h2|h3|h4|h5|h6|\.h\d|heading|title)[^{]*\{[^}]*line-height\s*:\s*([0-9.]+)/gi */
+function headingLineHeights(css) {
+    return ruleBodyScan(css, bracedStarts(css, /h1|h2|h3|h4|h5|h6|\.h\d|heading|title/gi), /line-height/gi, /line-height\s*:\s*([0-9.]+)/iy, false);
+}
+/** v17: /(?:body|p|article|\.body|\.prose|\.copy)[^{]*\{[^}]*line-height\s*:\s*([0-9.]+)/gi */
+function bodyLineHeights(css) {
+    return ruleBodyScan(css, bracedStarts(css, /body|p|article|\.body|\.prose|\.copy/gi), /line-height/gi, /line-height\s*:\s*([0-9.]+)/iy, false);
+}
+/**
+ * v24: /(?:^|[,}\s])\s*(?:button|a\b|input|textarea|select|\[role\s*=\s*["']?button["']?\]|\.btn|\.button|\.chip|\.tab|\.nav-link)\s*[^{]*\{[^}]*(?:min-height|min-width)\s*:\s*(\d+(?:\.\d+)?)(px|rem)/gim
+ */
+function touchTargetSizes(css) {
+    return ruleBodyScan(css, touchTargetStarts(css), /min-(?:height|width)/gi, /(?:min-height|min-width)\s*:\s*(\d+(?:\.\d+)?)(px|rem)/iy, false);
+}
+/** v27: /(?:input|textarea|select|\.input|\.field)[^{]*\{[^}]*font-size\s*:\s*(\d+(?:\.\d+)?)(px|rem)/gi */
+function fieldFontSizes(sheet) {
+    return ruleBodyScan(sheet, bracedStarts(sheet, /input|textarea|select|\.input|\.field/gi), /font-size/gi, /font-size\s*:\s*(\d+(?:\.\d+)?)(px|rem)/iy, false);
+}
+/** v27: /input\s*(?:,[^{]*)?\{[^}]*font-size\s*:\s*(?:1rem|16px|1\.0(?:\d+)?rem|[2-9]\dpx)/gi */
+function fieldFontFloors(sheet) {
+    return ruleBodyScan(sheet, inputFloorStarts(sheet), /font-size/gi, /font-size\s*:\s*(?:1rem|16px|1\.0(?:\d+)?rem|[2-9]\dpx)/iy, false);
+}
+/** v09: /:focus[^{]*\{[^}]*outline\s*:\s*(none|0)\s*[;}]/i.test(css) */
+function focusStripsOutline(css) {
+    return ruleBodyScan(css, bracedStarts(css, /:focus/gi), /outline/gi, /outline\s*:\s*(none|0)\s*[;}]/iy, true).length > 0;
+}
+/** v09: /:focus[^{]*\{[^}]*(box-shadow|outline\s*:\s*[^n0])/i.test(css) */
+function focusHasRing(css) {
+    return ruleBodyScan(css, bracedStarts(css, /:focus/gi), /box-shadow|outline/gi, /(box-shadow|outline\s*:\s*[^n0])/iy, true).length > 0;
+}
+/** v08: /@keyframes\s+[^{]*breath[^{]*\{[^}]*opacity\s*:/i.test(css) */
+function hasBreathKeyframes(css) {
+    return ruleBodyScan(css, breathKeyframeStarts(css), /opacity/gi, /opacity\s*:/iy, true).length > 0;
+}
+/** v08: /@media[^{]*(?:hover\s*:\s*hover|pointer\s*:\s*fine)/i.test(css) */
+function mediaQueryHasHoverGuard(css) {
+    return preludeHas(css, /@media/gi, /hover\s*:\s*hover|pointer\s*:\s*fine/gi);
+}
+/** v35: /@media[^{]*forced-colors\s*:\s*active/i.test(css) */
+function mediaQueryHasForcedColors(css) {
+    return preludeHas(css, /@media/gi, /forced-colors\s*:\s*active/gi);
+}
+/** v35: /@media[^{]*-ms-high-contrast/i.test(css) */
+function mediaQueryHasHighContrast(css) {
+    return preludeHas(css, /@media/gi, /-ms-high-contrast/gi);
+}
+/** O4: /@media[^{]*prefers-reduced-motion/i.test(css) */
+function mediaQueryHasReducedMotion(css) {
+    return preludeHas(css, /@media/gi, /prefers-reduced-motion/gi);
+}
+/** v05: /@media[^{]*prefers-reduced-motion\s*:\s*(reduce|no-preference)\b[^{]*\{/gi */
+function reducedMotionQueries(code) {
+    return preludeMatches(code, /@media/gi, /prefers-reduced-motion/gi, /prefers-reduced-motion\s*:\s*(reduce|no-preference)\b/iy);
+}
+/** color-mix: /^(\d*\.?\d+)%\s+([\s\S]*)$/.exec(p), the number without the ambiguous \d*\.?\d+ */
+function percentBefore(p) {
+    return /^(\d+(?:\.\d+)?|\.\d+)%\s+([\s\S]*)$/.exec(p);
+}
+/** v45: /^(?:0*\.?0*|0*(?:\.0+)?%)$/.test(v), without the ambiguous 0*\.?0* */
+function isZeroOpacity(v) {
+    return /^(?:0*(?:\.0*)?|0*(?:\.0+)?%)$/.test(v);
+}
+/** O1: the cubic-bezier() matches, each number written without the ambiguous \d*\.?\d+ */
+function cubicBezierMatches(css) {
+    const re = /cubic-bezier\(\s*(-?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*(-?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*(-?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*(-?(?:\d+(?:\.\d+)?|\.\d+))\s*\)/gi;
+    const out = [];
+    for (let m = re.exec(css); m; m = re.exec(css))
+        out.push({ index: m.index, text: m[0], groups: m.slice(1) });
+    return out;
+}
+/** v34: /<script\b[^>]*src\s*=\s*["'][^"']*\b(?:chatbot|ai-widget|dialogflow)\b/i.test(html) */
+function hasAiWidgetScript(html) {
+    return tagAttrValueHas(html, /<script\b/gi, /src\s*=\s*["']/gi, /\b(?:chatbot|ai-widget|dialogflow)\b/gi);
+}
+/** v34: /<script\b[^>]*src\s*=\s*["'][^"']*\b(?:assistant|claude|gemini|rasa|intercom|drift|tawk|crisp|livechat|conversational)\b/i.test(html) */
+function hasChatScript(html) {
+    return tagAttrValueHas(html, /<script\b/gi, /src\s*=\s*["']/gi, /\b(?:assistant|claude|gemini|rasa|intercom|drift|tawk|crisp|livechat|conversational)\b/gi);
+}
+/** v34: /<(?:iframe|div|section|aside)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:chatbot|chat-bot|ai-assistant|ai_chat)\b/i.test(html) */
+function hasAiChatContainer(html) {
+    return tagAttrValueHas(html, /<(?:iframe|div|section|aside)\b/gi, /(?:class|id)\s*=\s*["']/gi, /\b(?:chatbot|chat-bot|ai-assistant|ai_chat)\b/gi);
+}
+/** v34: /<(?:input|textarea|form)\b[^>]*(?:placeholder|aria-label)\s*=\s*["'][^"']*\b(?:ask\s+ai|message\s+ai|chat\s+with\s+ai|ai\s+assistant)\b/i.test(html) */
+function hasAiInput(html) {
+    return tagAttrValueHas(html, /<(?:input|textarea|form)\b/gi, /(?:placeholder|aria-label)\s*=\s*["']/gi, /\b(?:ask\s+ai|message\s+ai|chat\s+with\s+ai|ai\s+assistant)\b/gi);
+}
+/** v34: /<(?:iframe|div|section|aside)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:assistant-widget|intercom|drift|zendesk-chat|tawk(?:\.to)?|crisp\.chat|livechat|chat-widget|chat-container)\b/i.test(html) */
+function hasChatWidgetContainer(html) {
+    return tagAttrValueHas(html, /<(?:iframe|div|section|aside)\b/gi, /(?:class|id)\s*=\s*["']/gi, /\b(?:assistant-widget|intercom|drift|zendesk-chat|tawk(?:\.to)?|crisp\.chat|livechat|chat-widget|chat-container)\b/gi);
+}
+/** v34: /<(?:iframe|div|section)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:contact-widget|smart-search|virtual-agent|message-us|help-widget)\b/i.test(html) */
+function hasAmbiguousWidget(html) {
+    return tagAttrValueHas(html, /<(?:iframe|div|section)\b/gi, /(?:class|id)\s*=\s*["']/gi, /\b(?:contact-widget|smart-search|virtual-agent|message-us|help-widget)\b/gi);
+}
+/** v34: /<meta\s+name\s*=\s*["']generator["'][^>]*content\s*=\s*["'][^"']*\b(?:ai|gpt|claude|gemini|llm|generated|artificial\s+intelligence)\b/i.test(html) */
+function hasAiGeneratorMeta(html) {
+    return tagAttrValueHas(html, /<meta\s+name\s*=\s*["']generator["']/gi, /content\s*=\s*["']/gi, /\b(?:ai|gpt|claude|gemini|llm|generated|artificial\s+intelligence)\b/gi);
+}
+/** text.replace(/\[[^\]]*\]/g, fn) */
+function replaceBrackets(text, fn) {
+    return replaceSpansWith(text, bracketSpans(text), fn);
+}
+/**
+ * S8: html with <script>, <style> and <template> elements and comments each
+ * replaced by a space (/<script\b[\s\S]*?<\/script\s*>/gi and the like).
+ */
+function withoutNonVisibleMarkup(html) {
+    const a = replaceSpans(html, lazyBlockSpans(html, /<script\b/gi, /<\/script\s*>/gi), ' ');
+    const b = replaceSpans(a, lazyBlockSpans(a, /<style\b/gi, /<\/style\s*>/gi), ' ');
+    const c = replaceSpans(b, lazyBlockSpans(b, /<template\b/gi, /<\/template\s*>/gi), ' ');
+    return replaceSpans(c, lazyBlockSpans(c, /<!--/g, /-->/g), ' ');
+}
+/**
+ * S2: does some linear-gradient() in the value carry two or more colour stops?
+ * The lower-cased copy is made once; it was remade for every gradient read.
+ */
+function hasMultiStopGradient(value) {
+    const lower = value.toLowerCase();
+    let from = 0;
+    for (;;) {
+        const at = lower.indexOf('linear-gradient(', from);
+        if (at < 0)
+            return false;
+        let depth = 0;
+        let end = -1;
+        for (let i = at + 15; i < value.length; i++) {
+            if (value[i] === '(')
+                depth++;
+            else if (value[i] === ')' && --depth === 0) {
+                end = i;
+                break;
+            }
+        }
+        if (end < 0)
+            return false;
+        const args = splitCssTopLevel(value.slice(at + 16, end), ',');
+        const stops = /^(?:to\s|[-+]?[\d.]+(?:deg|turn|rad|grad)\b)/i.test(args[0] ?? '') ? args.slice(1) : args;
+        if (stops.length >= 2)
+            return true;
+        from = end;
+    }
+}
 // ── CSS extraction + token parsing ──────────────────────────────────────────
 function extractCssLinks(html, baseUrl) {
     const links = [];
-    const styleRe = /<style[^>]*>([\s\S]*?)<\/style>/gi;
-    let m;
-    while ((m = styleRe.exec(html)) !== null)
-        links.push(m[1]);
-    const linkRe = /<link[^>]*rel=["']?stylesheet["']?[^>]*href=["']([^"']+)["']/gi;
-    while ((m = linkRe.exec(html)) !== null) {
+    for (const m of styleElements(html))
+        links.push(m.groups[0]);
+    for (const m of stylesheetLinkMatches(html)) {
         try {
-            links.push(new URL(m[1], baseUrl).href);
+            links.push(new URL(m.groups[0], baseUrl).href);
         }
         catch { /* skip */ }
     }
@@ -325,18 +2354,13 @@ async function fetchPageResilient(targetUrl) {
     return { ok: true, html, css: cssParts.join('\n') };
 }
 function extractRootTokens(css) {
-    const stripped = css.replace(/@media[^{]*\{[^@]*?\}\s*\}/gi, '');
+    const stripped = withoutMediaBlocks(css);
     const tokens = {};
     // `:root, :host { ... }` is the block Tailwind v4 writes its theme into;
     // until engine 1.3.0 only `:root {` was read, so those tokens were missed.
-    const rootRe = /:root(?:\s*,\s*:host)?\s*\{([^}]*)\}/g;
-    let m;
-    while ((m = rootRe.exec(stripped)) !== null) {
-        const block = m[1];
-        const propRe = /--([\w-]+)\s*:\s*([^;]+?)(?:;|$)/g;
-        let p;
-        while ((p = propRe.exec(block)) !== null) {
-            tokens[`--${p[1]}`] = p[2].trim();
+    for (const m of rootTokenBlocks(stripped)) {
+        for (const p of customPropertyValues(m.groups[0])) {
+            tokens[`--${p.groups[0]}`] = p.groups[1].trim();
         }
     }
     return tokens;
@@ -699,7 +2723,7 @@ function checkTabularNums(css) {
  * fixture broken-reduced-motion-inverted pins that case.
  */
 function optsIntoMotion(body) {
-    if (/@view-transition\s*\{[^}]*navigation\s*:\s*auto/i.test(body))
+    if (hasViewTransitionNavigation(body))
         return true;
     const declRe = /(?:^|[{;\s])(animation|animation-name|animation-duration|transition|transition-property|transition-duration|scroll-behavior|view-transition-name)\s*:\s*([^;{}]+)/gi;
     let m;
@@ -713,7 +2737,7 @@ function optsIntoMotion(body) {
         }
         if (/^(?:none|initial|unset|revert|revert-layer|0|0s|0ms)$/.test(value))
             continue;
-        const times = [...value.matchAll(/(?:^|[\s,(])(\d*\.?\d+)(ms|s)\b/g)].map((t) => parseFloat(t[1]) * (t[2] === 's' ? 1000 : 1));
+        const times = [...value.matchAll(/(?:^|[\s,(])(\d+(?:\.\d+)?|\.\d+)(ms|s)\b/g)].map((t) => parseFloat(t[1]) * (t[2] === 's' ? 1000 : 1));
         if (times.length > 0 && times.every((t) => t <= 10))
             continue;
         return true;
@@ -727,7 +2751,7 @@ function checkReducedMotion(css) {
     // prose mentioning prefers-reduced-motion — satisfied the old check. The
     // calibration corpus caught exactly that: the previous regex matched the
     // string anywhere, including inside /* */.
-    const code = css.replace(/\/\*[\s\S]*?\*\//g, '');
+    const code = withoutCssComments(css, '');
     // Match the media query and read its VALUE. Two shapes honour reduced motion:
     //   * `reduce` with a non-empty body: motion is switched off for those users.
     //   * `no-preference` with a body that opts INTO motion (optsIntoMotion): the
@@ -737,33 +2761,29 @@ function checkReducedMotion(css) {
     // pattern. A bare substring match on the feature name stays wrong in both
     // directions: an empty block, or a `no-preference` block that only switches
     // motion off, honours nothing and still WARNs.
-    const mqRe = /@media[^{]*prefers-reduced-motion\s*:\s*(reduce|no-preference)\b[^{]*\{/gi;
-    let match;
+    const queries = reducedMotionQueries(code);
     let sawReduce = false;
     let sawMotionOptIn = false;
     let sawNoPreference = false;
-    while ((match = mqRe.exec(code)) !== null) {
-        const value = match[1].toLowerCase();
-        // Capture the block body by brace-matching from the opening brace.
-        const open = match.index + match[0].length - 1;
-        let depth = 0;
-        let close = -1;
-        for (let i = open; i < code.length; i++) {
-            if (code[i] === '{')
-                depth++;
-            else if (code[i] === '}') {
-                depth--;
-                if (depth === 0) {
-                    close = i;
-                    break;
-                }
-            }
-        }
+    // Each block body ends at the brace that brings the depth back to zero,
+    // found for every query in one pass (engine 1.5.1; a walk per query read
+    // nested queries' bodies over and over).
+    const closes = closingBraces(code, new Set(queries.map((q) => q.index + q.text.length - 1)));
+    // A no-preference block inside one already read opts into motion only if
+    // that one does, so it is not read again.
+    let readUntil = -1;
+    for (const match of queries) {
+        const value = match.groups[0].toLowerCase();
+        const open = match.index + match.text.length - 1;
+        const close = closes.get(open) ?? -1;
         const body = close > open ? code.slice(open + 1, close).trim() : '';
         if (value === 'no-preference') {
             sawNoPreference = true;
-            if (optsIntoMotion(body))
-                sawMotionOptIn = true;
+            if (!sawMotionOptIn && close > readUntil) {
+                if (optsIntoMotion(body))
+                    sawMotionOptIn = true;
+                readUntil = close;
+            }
             continue;
         }
         // A `reduce` query that declares no rules reduces nothing.
@@ -792,9 +2812,9 @@ function checkSemanticHtmlFoundation(html) {
     // <meta name="description">, and a <main>/<header>/<nav> landmark. These are
     // Lighthouse a11y basics (document-title weight 4.1, heading-order 0.8) and
     // apply to every site. The check name/id stays v07 for continuity.
-    const visibleHtml = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '');
+    const visibleHtml = withoutScriptsAndStyles(html);
     const h1Count = (visibleHtml.match(/<h1\b/gi) || []).length;
-    const hasTitle = /<title\b[^>]*>[^<]+<\/title>/i.test(html);
+    const hasTitle = hasTitleText(html);
     const hasMetaDesc = /<meta\s+name=["']description["']/i.test(html);
     const hasLandmark = /<(main|header|nav)\b/i.test(visibleHtml);
     const signals = [];
@@ -830,7 +2850,7 @@ function checkSemanticHtmlFoundation(html) {
 function checkPressScale(css) {
     // Strip @keyframes blocks — scale(0) inside a ripple/particle keyframe is a
     // legitimate animation starting point, not a press scale.
-    const stripped = css.replace(/@keyframes\s+[^{]+\{[^@]*?\}/gi, '');
+    const stripped = withoutKeyframesBlocks(css);
     // Collect all press-scale candidates: scale() < 1 found in CSS rule blocks
     // (not keyframes). We split by '}' to get individual rule blocks so we can
     // inspect the selector context for each scale() value.
@@ -888,15 +2908,8 @@ function checkPressScale(css) {
 // v17 — REAL line-height by role check. Scans for heading-tight (1.0-1.15)
 // and body-relaxed (1.4-1.7) line-heights. Contract: headings 1.08, body 1.55.
 function checkLineHeightByRole(css) {
-    const headingRe = /(?:h1|h2|h3|h4|h5|h6|\.h\d|heading|title)[^{]*\{[^}]*line-height\s*:\s*([0-9.]+)/gi;
-    const bodyRe = /(?:body|p|article|\.body|\.prose|\.copy)[^{]*\{[^}]*line-height\s*:\s*([0-9.]+)/gi;
-    const headingLhs = [];
-    const bodyLhs = [];
-    let m;
-    while ((m = headingRe.exec(css)) !== null)
-        headingLhs.push(parseFloat(m[1]));
-    while ((m = bodyRe.exec(css)) !== null)
-        bodyLhs.push(parseFloat(m[1]));
+    const headingLhs = headingLineHeights(css).map((m) => parseFloat(m.groups[0]));
+    const bodyLhs = bodyLineHeights(css).map((m) => parseFloat(m.groups[0]));
     const headingOk = headingLhs.some(lh => lh >= 1.0 && lh <= 1.15);
     const bodyOk = bodyLhs.some(lh => lh >= 1.4 && lh <= 1.7);
     if (headingOk && bodyOk)
@@ -914,7 +2927,7 @@ function checkLineHeightByRole(css) {
 // var(--signal) reference (or any non-default color). Browser default is
 // #000/#fff text on #0000ff blue background — any custom rule beats that.
 function checkSelectionStyled(css) {
-    const selMatch = css.match(/::selection\s*\{[^}]*\}/gi);
+    const selMatch = selectionRules(css);
     if (!selMatch || selMatch.length === 0)
         return { id: 'v20', item: '::selection styled with var(--signal) instead of the browser default', category: 'cadence', status: 'WARN', detail: 'no ::selection rule found: browser default will show' };
     const usesSignal = selMatch.some(r => /var\(\s*--signal/i.test(r));
@@ -971,12 +2984,10 @@ function checkSkipInk(css) {
 // Full verification needs a browser (getBoundingClientRect on rendered elements).
 function checkTouchTargets(css) {
     // Look for min-height/min-width ≥ 44px on button, a, input, [role=button] selectors.
-    const interactiveRe = /(?:^|[,}\s])\s*(?:button|a\b|input|textarea|select|\[role\s*=\s*["']?button["']?\]|\.btn|\.button|\.chip|\.tab|\.nav-link)\s*[^{]*\{[^}]*(?:min-height|min-width)\s*:\s*(\d+(?:\.\d+)?)(px|rem)/gim;
     const targets = [];
-    let m;
-    while ((m = interactiveRe.exec(css)) !== null) {
-        const val = parseFloat(m[1]);
-        const unit = m[2].toLowerCase();
+    for (const m of touchTargetSizes(css)) {
+        const val = parseFloat(m.groups[0]);
+        const unit = m.groups[1].toLowerCase();
         const px = unit === 'rem' ? val * 16 : val;
         targets.push(px);
     }
@@ -990,7 +3001,7 @@ function checkTouchTargets(css) {
 // v25 — Heading hierarchy: single h1, no skipped levels (h1→h3 jump = fail).
 // Scans HTML for heading order. design-auditor + Lighthouse heading-order check.
 function checkHeadingHierarchy(html) {
-    const visibleHtml = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '');
+    const visibleHtml = withoutScriptsAndStyles(html);
     const headings = [...visibleHtml.matchAll(/<h([1-6])\b/gi)];
     if (headings.length === 0)
         return { id: 'v25', item: 'Heading hierarchy: single h1, no skipped levels', category: 'accessibility', status: 'WARN', detail: 'no heading elements found: page may lack structure' };
@@ -1129,7 +3140,7 @@ function checkFontFamilyCount(css, tokens) {
  * ".field label" and "user-select" are not fields.
  */
 function isFieldSelector(selector) {
-    const clean = selector.replace(/\/\*[\s\S]*?\*\//g, ' ');
+    const clean = withoutCssComments(selector, ' ');
     return splitCssTopLevel(clean, ',').some((part) => {
         const compounds = part.trim().split(/\s*[>+~]\s*|\s+/);
         const subject = compounds[compounds.length - 1] || '';
@@ -1140,22 +3151,60 @@ function isFieldSelector(selector) {
     });
 }
 /**
- * v27 helper (engine 1.4.1): the selector of the rule whose body holds the
- * declaration at `offset`, read backwards from that body's opening brace to
- * the previous closing brace, opening brace or semicolon. Null when the offset
- * is not inside a rule body (a stray declaration, or a brace closed in
- * between). Linear: a few lastIndexOf scans per call, no whole-sheet regex.
+ * v27 helper (engine 1.4.1): the rule whose body holds the declaration at an
+ * offset, its selector read backwards from that body's opening brace to the
+ * previous closing brace, opening brace or semicolon. The finder returns
+ * [start, open], the selector being css.slice(start, open), or null when the
+ * offset is not inside a rule body (a stray declaration, or a brace closed in
+ * between).
+ *
+ * Engine 1.5.1: the finder lists the sheet's braces and semicolons once and
+ * answers each offset by binary search. Before, each declaration ran three
+ * lastIndexOf scans, each reading back to the last character of its kind, so
+ * a sheet with no semicolons was read back to its start once per declaration
+ * and cost the square of its length. Each answer is the one those scans gave.
  */
-function ruleSelectorAt(css, offset) {
-    const open = css.lastIndexOf('{', offset);
-    if (open < 0 || css.lastIndexOf('}', offset) > open)
-        return null;
-    const start = Math.max(css.lastIndexOf('}', open - 1), css.lastIndexOf('{', open - 1), css.lastIndexOf(';', open - 1)) + 1;
-    return css.slice(start, open);
+function ruleSelectorFinder(css) {
+    const opens = [];
+    const closes = [];
+    const marks = [];
+    for (let i = 0; i < css.length; i++) {
+        const c = css.charCodeAt(i);
+        if (c === 123) {
+            opens.push(i);
+            marks.push(i);
+        }
+        else if (c === 125) {
+            closes.push(i);
+            marks.push(i);
+        }
+        else if (c === 59)
+            marks.push(i);
+    }
+    // The last entry at or before x in an ascending list, or -1.
+    const atOrBefore = (list, x) => {
+        let lo = 0;
+        let hi = list.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (list[mid] <= x)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return lo > 0 ? list[lo - 1] : -1;
+    };
+    return (offset) => {
+        const at = Math.max(0, offset);
+        const open = atOrBefore(opens, at);
+        if (open < 0 || atOrBefore(closes, at) > open)
+            return null;
+        return [atOrBefore(marks, open - 1) + 1, open];
+    };
 }
 /**
- * v27 helper (engine 1.4.1): does the font-size declaration at `offset` sit in
- * a rule whose own selector names a field keyword (input, textarea, select,
+ * v27 helper (engine 1.4.1): for an offset, does the font-size declaration
+ * there sit in a rule whose own selector names a field keyword (input, textarea, select,
  * .input, .field), the same words the literal scan looks for? v27's literal
  * regexes find a keyword and then the next rule body, and their `[^{]*` runs
  * across a closing brace. So the word "select" in `.chip { user-select: none }`
@@ -1168,9 +3217,22 @@ function ruleSelectorAt(css, offset) {
  * isFieldSelector test dropped real fields (a 14px textarea, a 16px search
  * input's floor).
  */
-function inFieldRule(css, offset) {
-    const selector = ruleSelectorAt(css, offset);
-    return selector !== null && /input|textarea|select|\.field/i.test(selector.replace(/\/\*[\s\S]*?\*\//g, ' '));
+function fieldRuleFinder(css) {
+    const ruleAt = ruleSelectorFinder(css);
+    let seen = -1;
+    let verdict = false;
+    return (offset) => {
+        const rule = ruleAt(offset);
+        if (rule === null)
+            return false;
+        // The declarations of one rule share its verdict (engine 1.5.1: each one
+        // read the selector again).
+        if (rule[1] !== seen) {
+            seen = rule[1];
+            verdict = /input|textarea|select|\.field/i.test(withoutCssComments(css.slice(rule[0], rule[1]), ' '));
+        }
+        return verdict;
+    };
 }
 /**
  * v27 helper (engine 1.3.1): in each rule whose selector styles a field
@@ -1184,22 +3246,45 @@ function inFieldRule(css, offset) {
  * a card caption) as an input below 16px. Only values that start with var(
  * are touched; calc(), clamp() and min()/max() stay as written, as before.
  *
- * The scan is anchored on each `font-size: var(` and reads its rule's selector
- * backwards from the opening brace, so its cost is linear in the sheet. A
+ * The scan is anchored on each `font-size: var(` and finds its rule's selector
+ * through ruleSelectorFinder, so its cost is linear in the sheet. A
  * whole-sheet rule regex (`([^{}]*)\{([^{}]*)\}`) is quadratic on a long
  * @media prelude: measured at +4.5 s on five 43 KB preludes.
  */
 function resolveFontSizeVars(css, tokens) {
     if (css.indexOf('var(') < 0)
         return css;
-    return css.replace(/(font-size\s*:\s*)(var\([^;{}]*\))/gi, (decl, lead, value, offset) => {
+    const parts = [];
+    const ruleAt = ruleSelectorFinder(css);
+    let seen = -1;
+    let styled = false;
+    let last = 0;
+    for (const m of fontSizeVarMatches(css)) {
+        const decl = m.text;
+        const lead = m.groups[0];
+        const value = m.groups[1];
+        const offset = m.index;
+        parts.push(css.slice(last, offset));
+        last = offset + decl.length;
         // Not inside a rule body (a stray declaration, or a brace closed between).
-        const selector = ruleSelectorAt(css, offset);
-        if (selector === null || !isFieldSelector(selector))
-            return decl;
+        const rule = ruleAt(offset);
+        if (rule === null) {
+            parts.push(decl);
+            continue;
+        }
+        if (rule[1] !== seen) {
+            seen = rule[1];
+            styled = isFieldSelector(css.slice(rule[0], rule[1]));
+        }
+        if (!styled) {
+            parts.push(decl);
+            continue;
+        }
         const sub = substituteCssVars(value, [tokens]);
-        return sub === null ? decl : lead + sub.trim();
-    });
+        parts.push(sub === null ? decl : lead + sub.trim());
+    }
+    parts.push(css.slice(last));
+    return parts.join('');
 }
 /**
  * v27 helper: does the delivered markup carry a field iOS Safari zooms into on
@@ -1208,10 +3293,10 @@ function resolveFontSizeVars(css, tokens) {
  * image, file, range and color. An <input> with no type is a text field.
  */
 function hasZoomableField(html) {
-    const visible = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '');
+    const visible = withoutScriptsAndStyles(html);
     if (/<(?:textarea|select)\b/i.test(visible))
         return true;
-    const inputs = visible.match(/<input\b[^>]*>/gi) || [];
+    const inputs = inputTags(visible);
     return inputs.some((tag) => {
         const type = /\stype\s*=\s*["']?([a-z-]+)/i.exec(tag);
         return !type || !/^(?:hidden|checkbox|radio|submit|button|reset|image|file|range|color)$/i.test(type[1]);
@@ -1236,16 +3321,15 @@ function hasZoomableField(html) {
 // cannot resolve is left as written, so it reads as it did before.
 function checkInputFontFloor(css, html, tokens = {}) {
     const sheet = resolveFontSizeVars(css, tokens);
+    const inFieldRule = fieldRuleFinder(sheet);
     // Find input/textarea/select rules with font-size < 16px or < 1rem.
-    const inputRe = /(?:input|textarea|select|\.input|\.field)[^{]*\{[^}]*font-size\s*:\s*(\d+(?:\.\d+)?)(px|rem)/gi;
     const below = [];
-    let m;
-    while ((m = inputRe.exec(sheet)) !== null) {
+    for (const m of fieldFontSizes(sheet)) {
         // Engine 1.4.1: only a declaration whose own rule styles a field counts.
-        if (!inFieldRule(sheet, m.index + m[0].lastIndexOf('font-size')))
+        if (!inFieldRule(m.index + m.text.lastIndexOf('font-size')))
             continue;
-        const val = parseFloat(m[1]);
-        const unit = m[2].toLowerCase();
+        const val = parseFloat(m.groups[0]);
+        const unit = m.groups[1].toLowerCase();
         const px = unit === 'rem' ? val * 16 : val;
         if (px < 16)
             below.push(`${val}${unit} (${px}px)`);
@@ -1255,11 +3339,11 @@ function checkInputFontFloor(css, html, tokens = {}) {
         // The strict form `input\s*\{` matches standalone rules; the grouped form
         // `input,...,{` matches selectors merged by CSS minifiers (e.g. `input,textarea,select{font-size:1rem}`).
         // Engine 1.4.1: the floor rule must itself style a field, as above.
-        const floorRe = /input\s*(?:,[^{]*)?\{[^}]*font-size\s*:\s*(?:1rem|16px|1\.0(?:\d+)?rem|[2-9]\dpx)/gi;
         let hasGlobalFloor = false;
-        let f;
-        while (!hasGlobalFloor && (f = floorRe.exec(sheet)) !== null) {
-            hasGlobalFloor = inFieldRule(sheet, f.index + f[0].lastIndexOf('font-size'));
+        for (const f of fieldFontFloors(sheet)) {
+            if (hasGlobalFloor)
+                break;
+            hasGlobalFloor = inFieldRule(f.index + f.text.lastIndexOf('font-size'));
         }
         if (hasGlobalFloor)
             return { id: 'v27', item: 'Input font-size ≥16px (prevents iOS Safari auto-zoom)', category: 'accessibility', status: 'PASS', detail: 'input font-size floor detected' };
@@ -1281,14 +3365,12 @@ function checkReadingWidth(css) {
     // contains a prose-ish word (e.g. `.prose-grid`).
     const STRUCTURAL_SELECTOR = /grid|table|row|col\b|flex|swatch|chip|badge|tab\b|nav\b|toolbar|chart|canvas|pre\b|code\b|kbd/i;
     // Walk every rule block, capturing selector + declarations together.
-    const ruleRe = /([^{}]+)\{([^{}]*)\}/g;
     const proseInRange = [];
     const proseOutOfRange = [];
     const nonProse = [];
-    let m;
-    while ((m = ruleRe.exec(css)) !== null) {
-        const selector = m[1].replace(/\/\*[\s\S]*?\*\//g, '').trim();
-        const body = m[2];
+    for (const m of cssRuleBlocks(css)) {
+        const selector = withoutCssComments(m.groups[0], '').trim();
+        const body = m.groups[1];
         // Skip at-rule preludes (`@media (...)`, `@supports (...)`) — the block
         // body is walked on the next iteration when the inner rule is seen. A
         // media query wrapping prose rules should not itself be classified.
@@ -1607,6 +3689,16 @@ function parseCssRules(css) {
     lastCssParse = { css, result };
     return result;
 }
+// Engine 1.5.1: limits that only a malformed or hostile sheet reaches. The
+// leaderboard cohort, measured 2026-10-15, nests at most 6 levels deep and
+// leaves at most one block open at the end of a page's CSS. A brace that
+// would open a level deeper than CSS_MAX_NESTING is read as text of the block
+// it sits in. At the end of the sheet at most CSS_MAX_OPEN_AT_END blocks left
+// open are closed and read, innermost first: each one reads to the end of the
+// sheet, so every further one was another full copy of the rest of it, and a
+// short sheet that left many blocks open cost seconds.
+const CSS_MAX_NESTING = 16;
+const CSS_MAX_OPEN_AT_END = 4;
 function parseCssRulesUncached(css) {
     const src = stripCssComments(css);
     const n = src.length;
@@ -1616,6 +3708,7 @@ function parseCssRulesUncached(css) {
     let order = 0;
     let start = 0;
     let paren = 0;
+    let overflow = 0;
     const close = (f, end) => {
         f.parts.push(src.slice(f.segStart, end));
         const decls = f.parts.join(' ').trim();
@@ -1674,6 +3767,12 @@ function parseCssRulesUncached(css) {
         }
         if (c === 123) {
             paren = 0;
+            if (stack.length >= CSS_MAX_NESTING) {
+                overflow++;
+                start = i + 1;
+                i++;
+                continue;
+            }
             const prelude = src.slice(start, i).trim();
             const parent = stack.length ? stack[stack.length - 1] : null;
             if (parent)
@@ -1714,6 +3813,12 @@ function parseCssRulesUncached(css) {
         }
         if (c === 125) {
             paren = 0;
+            if (overflow > 0) {
+                overflow--;
+                start = i + 1;
+                i++;
+                continue;
+            }
             const f = stack.pop();
             if (f) {
                 close(f, i);
@@ -1727,9 +3832,9 @@ function parseCssRulesUncached(css) {
         }
         i++;
     }
-    while (stack.length) {
+    for (let closed = 0; stack.length; closed++) {
         const f = stack.pop();
-        if (f)
+        if (f && closed < CSS_MAX_OPEN_AT_END)
             close(f, n);
     }
     return { rules, keyframes };
@@ -1744,9 +3849,10 @@ function parseCssDecls(decls) {
         if (!/^-{0,2}[a-zA-Z_][\w-]*$/.test(name))
             continue;
         let value = raw.slice(colon + 1).trim();
-        const important = /!\s*important\s*$/i.test(value);
+        const cut = importantSuffixStart(value);
+        const important = cut >= 0;
         if (important)
-            value = value.replace(/\s*!\s*important\s*$/i, '').trim();
+            value = value.slice(0, cut).trim();
         out.push({ prop: name.startsWith('--') ? name : name.toLowerCase(), value, important });
     }
     return out;
@@ -1837,7 +3943,7 @@ function cssNumber(token, percentScale) {
     const t = token.trim().toLowerCase();
     if (t === 'none')
         return 0;
-    const m = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?)(%|deg|turn|rad|grad)?$/.exec(t);
+    const m = /^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)(%|deg|turn|rad|grad)?$/.exec(t);
     if (!m)
         return null;
     const x = parseFloat(m[1]);
@@ -1919,8 +4025,8 @@ function parseCssColor(input, dark, depth = 0) {
         if (!['srgb', 'oklab', 'oklch'].includes(space))
             return null;
         const side = (p) => {
-            const after = /^([\s\S]*?)\s+(\d*\.?\d+)%$/.exec(p);
-            const before = /^(\d*\.?\d+)%\s+([\s\S]*)$/.exec(p);
+            const after = percentAfter(p);
+            const before = percentBefore(p);
             if (after)
                 return { color: after[1], pct: parseFloat(after[2]) / 100 };
             if (before)
@@ -1986,7 +4092,7 @@ function parseCssColor(input, dark, depth = 0) {
         const mult = Math.min(1, sum);
         return [Math.round(rgb[0]), Math.round(rgb[1]), Math.round(rgb[2]), Math.round(alpha * mult * 255) / 255];
     }
-    const rel = /^from\s+([\s\S]+?)\s+(r\s+g\s+b|h\s+s\s+l|l\s+c\s+h|l\s+a\s+b)\s*(?:\/\s*([\s\S]+))?$/.exec(args);
+    const rel = relativeColorMatch(args);
     if (rel) {
         const base = parseCssColor(rel[1], dark, depth + 1);
         if (!base)
@@ -2132,8 +4238,7 @@ function themeSelectorKeys(selector) {
 }
 /** A selector part with its theme attributes and classes removed. */
 function withoutThemeKeys(part) {
-    return part
-        .replace(/\[[^\]]*\]/g, (a) => (themeSelectorKeys(a).length ? '' : a))
+    return replaceBrackets(part, (a) => (themeSelectorKeys(a).length ? '' : a))
         .replace(V44_THEME_CLASS, '')
         .trim();
 }
@@ -2267,7 +4372,7 @@ function checkStatusTextContrast(css) {
             const mediaKey = `@media (prefers-color-scheme: ${scheme})`;
             const theme = t === 'root'
                 ? (scheme ? ensure(mediaKey, [], mediaKey) : root)
-                : ensure(t, t.match(/\[[^\]]*\]|\.[\w-]+/g) ?? [], null);
+                : ensure(t, attrAndClassParts(t) ?? [], null);
             if (t === 'root' && scheme)
                 theme.dark = scheme === 'dark';
             for (const d of decls) {
@@ -2799,7 +4904,7 @@ function compareSpecificity(a, b) {
 }
 /** One time value in ms, null when it is not a literal time. */
 function cssTimeMs(token) {
-    const m = /^(-?(?:\d+\.?\d*|\.\d+))(ms|s)$/i.exec(token.trim());
+    const m = /^(-?(?:\d+(?:\.\d*)?|\.\d+))(ms|s)$/i.exec(token.trim());
     return m ? parseFloat(m[1]) * (m[2].toLowerCase() === 's' ? 1000 : 1) : null;
 }
 /** :is() and :where() in a selector, expanded into their alternatives (bounded). */
@@ -2861,7 +4966,6 @@ const V45_USER_ACTION = /^:(?:hover|focus|focus-within|focus-visible|active|targ
 // ([data-motion=paused], [data-reduced-motion]), or a class that is one
 // (.reduce-motion, .no-motion, .motion-paused, .animations-off). Component
 // classes that only end in "paused" (a marquee's .logobar--paused) are not.
-const V45_TOGGLE_ATTR = /^\[[\w-]*(?:motion|anim)[\w-]*(?:[~|^$*]?=[^\]]*)?\]$/i;
 const V45_TOGGLE_CLASS = /^\.(?:is-|has-|prefers-)?(?:reduced?-motion|no-motion|motion-(?:off|paused|reduced?|none)|paused-motion|(?:no-)?animations?(?:-(?:off|paused|disabled|none))?|(?:pause|stop)-animations?|still)$/i;
 /**
  * Whether a compound before `*` reaches the whole document: html, :root or
@@ -2879,7 +4983,7 @@ function isDocumentScope(compound) {
     if (type)
         return /^(?:html|body|:root)$/i.test(type);
     return simple.every((s) => s.startsWith('.') || s.startsWith('['))
-        && simple.some((s) => V45_TOGGLE_ATTR.test(s) || V45_TOGGLE_CLASS.test(s));
+        && simple.some((s) => isMotionToggleAttr(s) || V45_TOGGLE_CLASS.test(s));
 }
 // v46 — Type sizes come from the scale (engine 1.4.0).
 //
@@ -2905,7 +5009,7 @@ const V46_ITEM = 'Type sizes come from the scale';
 const V46_TOLERANCE = 0.025;
 const V46_FLUID = /(?:^|[^a-z-])(?:[sld]?v[wh]|v[ib]|vmin|vmax|cq[iwhb]|cqmin|cqmax)\b/i;
 function v46StaticPx(value) {
-    const m = value.trim().match(/^(\d*\.?\d+)(rem|px)$/i);
+    const m = value.trim().match(/^(\d+(?:\.\d+)?|\.\d+)(rem|px)$/i);
     if (!m)
         return null;
     return parseFloat(m[1]) * (m[2].toLowerCase() === 'rem' ? 16 : 1);
@@ -2947,12 +5051,176 @@ function v46FluidFloor(value) {
     const statics = args.filter((a) => a !== null);
     return statics.length ? Math.max(...statics) : null;
 }
-function v46Selector(css, at) {
-    const open = css.lastIndexOf('{', at);
-    if (open < 0)
-        return '';
-    const start = Math.max(css.lastIndexOf('}', open), css.lastIndexOf(';', open), css.lastIndexOf('{', open - 1)) + 1; // stop at an enclosing @media brace too
-    return css.slice(start, open).replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/\s+/g, ' ').trim().slice(0, 80);
+// Engine 1.5.2: the `font` shorthand sets a size too, and until 1.5.2 v46 read
+// only `font-size`, so `font: 500 0.66rem/1 var(--mono)` sat outside the check.
+// The size is the first token that is a length, a size keyword or a size
+// function, ahead of the line-height slash and the family; a weight (500) has
+// no unit and a family name is no length, so neither is taken. A system font
+// keyword (caption, menu…) or a CSS-wide keyword sets no measurable size.
+const V46_FONT_SYSTEM = /^(?:caption|icon|menu|message-box|small-caption|status-bar|inherit|initial|unset|revert|revert-layer)$/i;
+const V46_SIZE_WORDS = new Set(['small', 'large', 'x-small', 'x-large', 'xx-small', 'xx-large', 'xxx-small', 'xxx-large', 'medium', 'smaller', 'larger']);
+/** `s` with A to Z lower-cased and every other code unit kept: the case folding of the /i flag without the u flag. */
+function foldAsciiCase(s) {
+    return s.replace(/[A-Z]+/g, (run) => run.toLowerCase());
+}
+/**
+ * Whether a shorthand token is a size, as
+ * /^(?:\d*\.?\d+(?:[a-z]+|%)|(?:xx?-|xxx-)?(?:small|large)|medium|smaller|larger|(?:clamp|min|max|calc)\(.*\))$/i
+ * answers: a number and then a unit or %, a size keyword, or a size function
+ * whose parenthesis closes at the end of the token with no line break inside.
+ * Read in one pass: the number in that pattern can split a run of digits
+ * between \d* and \d+ in as many ways as the run is long.
+ */
+function isV46SizeToken(s) {
+    const n = s.length;
+    let k = 0;
+    let dot = false;
+    for (; k < n; k++) {
+        const c = s.charCodeAt(k);
+        if (c === 46) {
+            if (dot)
+                return false; // a second dot ends every reading
+            dot = true;
+        }
+        else if (!isDigit(c))
+            break;
+    }
+    if (k > 0) {
+        if (k === n || s.charCodeAt(k - 1) === 46)
+            return false; // the number ends in a digit, and a unit follows it
+        if (k === n - 1 && s.charCodeAt(k) === 37)
+            return true; // %
+        for (let i = k; i < n; i++) {
+            const c = s.charCodeAt(i) | 32;
+            if (c < 97 || c > 122)
+                return false;
+        }
+        return true;
+    }
+    if (n <= 9 && V46_SIZE_WORDS.has(foldAsciiCase(s)))
+        return true;
+    const open = s.indexOf('(');
+    if (open < 3 || open > 5 || n < open + 2 || s.charCodeAt(n - 1) !== 41)
+        return false;
+    const fn = foldAsciiCase(s.slice(0, open));
+    if (fn !== 'clamp' && fn !== 'min' && fn !== 'max' && fn !== 'calc')
+        return false;
+    for (let i = open + 1; i < n - 1; i++)
+        if (isLineTerminator(s.charCodeAt(i)))
+            return false;
+    return true;
+}
+/** The size written inside a `font` shorthand value, or null when it carries none. */
+function v46ShorthandSize(value, tokens) {
+    const whole = resolveVar(value, tokens); // a whole-shorthand token alias
+    if (V46_FONT_SYSTEM.test(whole))
+        return null;
+    for (const part of splitCssTopLevel(whole.replace(/\//g, ' / ').replace(/\s+/g, ' '), ' ')) {
+        if (part === '/')
+            return null; // a slash before any size: not a shorthand v46 can read
+        if (isV46SizeToken(resolveVar(part, tokens)))
+            return part;
+    }
+    return null;
+}
+/**
+ * The declarations v46 reads: matches of
+ * /(font-size|(?<![\w-])font)\s*:\s*([^;}]+)/gi, groups [property, value].
+ * A font-size match is read past its value, as the global pattern reads it.
+ * After a `font` match the scan goes on from the end of the word, so a
+ * shorthand never swallows a font-size written after it. A `font` match is
+ * dropped when it sits inside the value of the shorthand before it (it is
+ * that value's own text), or when its value holds a `{`: an @supports
+ * condition such as `(font: -apple-system-body) and …{` declares nothing.
+ *
+ * Engine 1.5.2. Each start is tried once, and the starts that share a value's
+ * end share one search for it, so the scan reads the sheet in linear time.
+ */
+function v46SizeDecls(css) {
+    const start = /font/gi;
+    const sizeWord = /-size/iy;
+    const valueEnd = nextMatchFinder(css, /[;}]/g);
+    const brace = nextMatchFinder(css, /\{/g);
+    const out = [];
+    let shorthandEnd = -1;
+    for (let pos = 0;;) {
+        start.lastIndex = pos;
+        const m = start.exec(css);
+        if (!m)
+            break;
+        const at = m.index;
+        pos = at + 1;
+        sizeWord.lastIndex = at + 4;
+        const size = sizeWord.test(css);
+        if (!size && (at < shorthandEnd || (at > 0 && isNameChar(css.charCodeAt(at - 1)))))
+            continue;
+        const word = size ? 9 : 4;
+        const colon = wsEnd(css, at + word);
+        if (css.charCodeAt(colon) !== 58)
+            continue;
+        const ws = wsEnd(css, colon + 1);
+        let from = ws;
+        let end = ws;
+        if (ws < css.length && css.charCodeAt(ws) !== 59 && css.charCodeAt(ws) !== 125) {
+            const r = valueEnd(ws);
+            end = r === Infinity ? css.length : r;
+        }
+        else if (ws > colon + 1) {
+            from = ws - 1; // only white space before the end: the value is its last character
+        }
+        else
+            continue;
+        if (size) {
+            pos = end;
+        }
+        else {
+            pos = at + 4;
+            if (brace(from) < end)
+                continue;
+            shorthandEnd = end;
+        }
+        out.push({ index: at, text: css.slice(at, end), groups: [css.slice(at, at + word), css.slice(from, end)] });
+    }
+    return out;
+}
+/**
+ * The selector of the rule a v46 finding sits in, by offset: the text from
+ * the `{`, `}` or `;` before the last `{` at or before the offset up to that
+ * brace, without comments, white space collapsed, cut to 80 characters (''
+ * when no `{` comes before the offset).
+ *
+ * Engine 1.5.2: the sheet's braces and semicolons are listed once, each offset
+ * is answered by binary search, and the findings of one rule share one
+ * reading of its selector. Before, each finding ran four lastIndexOf scans,
+ * and on a sheet with few braces or semicolons each one read back toward the
+ * start of the sheet, so the check's cost grew with the square of its length.
+ */
+function v46SelectorFinder(css) {
+    const opens = [];
+    const marks = [];
+    for (let i = 0; i < css.length; i++) {
+        const c = css.charCodeAt(i);
+        if (c === 123) {
+            opens.push(i);
+            marks.push(i);
+        }
+        else if (c === 125 || c === 59)
+            marks.push(i);
+    }
+    const read = new Map();
+    return (at) => {
+        const k = lowerBound(opens, at + 1) - 1; // the last `{` at or before the offset
+        if (k < 0)
+            return '';
+        const open = opens[k];
+        let selector = read.get(open);
+        if (selector === undefined) {
+            const j = lowerBound(marks, open) - 1; // the `{`, `}` or `;` before it
+            selector = withoutCssComments(css.slice(j < 0 ? 0 : marks[j] + 1, open), ' ').replace(/\s+/g, ' ').trim().slice(0, 80);
+            read.set(open, selector);
+        }
+        return selector;
+    };
 }
 function checkTypeScale(css, tokens) {
     const scale = v46TypeScale(tokens);
@@ -2974,10 +5242,12 @@ function checkTypeScale(css, tokens) {
     };
     let judged = 0;
     let fluid = 0;
-    const re = /font-size\s*:\s*([^;}]+)/gi;
-    let m;
-    while ((m = re.exec(css)) !== null) {
-        const written = m[1].replace(/\/\*[\s\S]*?\*\//g, '').replace(/!important/i, '').trim();
+    const selectorAt = v46SelectorFinder(css);
+    for (const m of v46SizeDecls(css)) { // engine 1.5.2: font-size and the font shorthand
+        const declared = withoutCssComments(m.groups[1], '').replace(/!important/i, '').trim();
+        const written = m.groups[0].length === 4 ? v46ShorthandSize(declared, tokens) : declared;
+        if (written === null)
+            continue;
         const value = resolveVar(written, tokens);
         if (/^var\(/i.test(value))
             continue; // an alias the token table cannot resolve
@@ -2985,7 +5255,7 @@ function checkTypeScale(css, tokens) {
             fluid++;
             const low = v46FluidFloor(value);
             if (low !== null && below(low)) {
-                add({ selector: v46Selector(css, m.index), value: written, px: Math.round(low * 100) / 100, issue: 'fluid minimum below the floor', nearest: floor });
+                add({ selector: selectorAt(m.index), value: written, px: Math.round(low * 100) / 100, issue: 'fluid minimum below the floor', nearest: floor });
             }
             continue;
         }
@@ -2994,10 +5264,10 @@ function checkTypeScale(css, tokens) {
             continue; // em, %, keywords, calc(): relative or not static
         judged++;
         if (below(px)) {
-            add({ selector: v46Selector(css, m.index), value: written, px: Math.round(px * 100) / 100, issue: 'below the floor', nearest: floor });
+            add({ selector: selectorAt(m.index), value: written, px: Math.round(px * 100) / 100, issue: 'below the floor', nearest: floor });
         }
         else if (!onScale(px)) {
-            add({ selector: v46Selector(css, m.index), value: written, px: Math.round(px * 100) / 100, issue: 'off the scale', nearest: nearest(px) });
+            add({ selector: selectorAt(m.index), value: written, px: Math.round(px * 100) / 100, issue: 'off the scale', nearest: nearest(px) });
         }
     }
     const scaleText = `${steps.length}-step scale (ratio ${ratio.toFixed(3)}, ${scale.count} type tokens, floor ${floor}px)`;
@@ -3082,7 +5352,7 @@ function checkPausedEntrances(css) {
                         visibility = d.value.trim().toLowerCase();
                 }
             }
-            return (opacity !== null && /\d/.test(opacity) && /^(?:0*\.?0*|0*(?:\.0+)?%)$/.test(opacity)) || visibility === 'hidden';
+            return (opacity !== null && /\d/.test(opacity) && isZeroOpacity(opacity)) || visibility === 'hidden';
         };
         if (frameHides(/^(?:from|0*(?:\.0+)?%)$/) && !frameHides(/^(?:to|100(?:\.0+)?%)$/))
             hiddenNames.add(name);
@@ -3302,55 +5572,45 @@ function checkAiDisclosure(html) {
     const CATEGORY = 'identity';
     // Strip scripts/styles for visible-text checks but keep them for script-src
     // and JSON-LD detection. We use both raw html and a visible-only variant.
-    const visibleHtml = html
-        .replace(/<script[\s\S]*?<\/script>/gi, '')
-        .replace(/<style[\s\S]*?<\/style>/gi, '');
+    const visibleHtml = withoutScriptsAndStyles(html);
     // Text-only: strip all tags so attribute values like class="chatbot" don't
     // false-positive as disclosure TEXT. Disclosure text must be human-readable
     // content between tags, not class/id/aria attribute values.
-    const textOnly = visibleHtml.replace(/<[^>]+>/g, ' ');
+    const textOnly = withoutTags(visibleHtml, ' ', true);
     // ── AI chat surfaces, positively identified ─────────────────────────────
-    const aiContainerRe = /<(?:iframe|div|section|aside)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:chatbot|chat-bot|ai-assistant|ai_chat)\b/i;
-    const aiScriptRe = /<script\b[^>]*src\s*=\s*["'][^"']*\b(?:chatbot|ai-widget|dialogflow)\b/i;
-    const aiInputRe = /<(?:input|textarea|form)\b[^>]*(?:placeholder|aria-label)\s*=\s*["'][^"']*\b(?:ask\s+ai|message\s+ai|chat\s+with\s+ai|ai\s+assistant)\b/i;
     // ── Possible AI surfaces: a review item, never a FAIL ───────────────────
-    const chatContainerRe = /<(?:iframe|div|section|aside)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:assistant-widget|intercom|drift|zendesk-chat|tawk(?:\.to)?|crisp\.chat|livechat|chat-widget|chat-container)\b/i;
-    const chatScriptRe = /<script\b[^>]*src\s*=\s*["'][^"']*\b(?:assistant|claude|gemini|rasa|intercom|drift|tawk|crisp|livechat|conversational)\b/i;
     const aiTextRe = /\b(?:chat\s*with\s*(?:ai|our\s*bot|ai\s*assistant)|ask\s+ai|ai\s+assistant|talk\s+to\s+(?:our\s+)?bot|powered\s+by\s+ai|ai-generated|ai\s+chatbot|virtual\s+assistant)\b/i;
-    const ambiguousRe = /<(?:iframe|div|section)\b[^>]*(?:class|id)\s*=\s*["'][^"']*\b(?:contact-widget|smart-search|virtual-agent|message-us|help-widget)\b/i;
     const surfaceSignals = [];
-    if (aiContainerRe.test(html))
+    if (hasAiChatContainer(html))
         surfaceSignals.push('chatbot container');
-    if (aiScriptRe.test(html))
+    if (hasAiWidgetScript(html))
         surfaceSignals.push('AI widget script');
-    if (aiInputRe.test(html))
+    if (hasAiInput(html))
         surfaceSignals.push('AI input');
     const possibleSignals = [];
-    if (chatContainerRe.test(html))
+    if (hasChatWidgetContainer(html))
         possibleSignals.push('chat widget container');
-    if (chatScriptRe.test(html))
+    if (hasChatScript(html))
         possibleSignals.push('chat or assistant script');
     if (aiTextRe.test(textOnly))
         possibleSignals.push('AI prompt text');
-    if (ambiguousRe.test(html))
+    if (hasAmbiguousWidget(html))
         possibleSignals.push('ambiguous widget');
     // ── Disclosure detection ────────────────────────────────────────────────
     const disclosureTextRe = /\b(?:ai\s+assistant|ai\s+chatbot|ai-powered|powered\s+by\s+ai|automated\s+assistant|virtual\s+assistant|chatbot)\b/i;
     const ariaDisclosureRe = /aria-(?:label|description)\s*=\s*["'][^"']*\b(?:ai|assistant|bot|automated|chatbot)\b/i;
-    const generatorMetaRe = /<meta\s+name\s*=\s*["']generator["'][^>]*content\s*=\s*["'][^"']*\b(?:ai|gpt|claude|gemini|llm|generated|artificial\s+intelligence)\b/i;
     const c2paRe = /(?:<link\s+rel\s*=\s*["']c2pa-manifest["']|<meta\s+name\s*=\s*["']c2pa["'])/i;
-    const jsonldAiRe = /<script\s+type\s*=\s*["']application\/ld\+json["'][\s\S]*?"@type"\s*:\s*"[^"]*\b(?:ai|softwareapplication)\b[^"]*"[\s\S]*?(?:"applicationCategory"\s*:\s*"[^"]*ai[^"]*"|"[^"]*ai[^"]*")/i;
     const dataAiRe = /data-ai-disclosure\s*=/i;
     const disclosureSignals = [];
     if (disclosureTextRe.test(textOnly))
         disclosureSignals.push('visible AI text');
     if (ariaDisclosureRe.test(html))
         disclosureSignals.push('aria-label');
-    if (generatorMetaRe.test(html))
+    if (hasAiGeneratorMeta(html))
         disclosureSignals.push('generator meta');
     if (c2paRe.test(html))
         disclosureSignals.push('C2PA manifest');
-    if (jsonldAiRe.test(html))
+    if (hasAiJsonLd(html))
         disclosureSignals.push('JSON-LD');
     if (dataAiRe.test(html))
         disclosureSignals.push('data-ai-disclosure');
@@ -3377,11 +5637,11 @@ function checkForcedColors(css) {
     const ITEM = 'Forced-colors readiness: @media (forced-colors: active) block present';
     const CATEGORY = 'accessibility';
     // Primary signal: @media (forced-colors: active) block exists
-    const hasForcedColorsMedia = /@media[^{]*forced-colors\s*:\s*active/i.test(css);
+    const hasForcedColorsMedia = mediaQueryHasForcedColors(css);
     // Secondary signal: forced-color-adjust property used anywhere
     const hasForcedColorAdjust = /forced-color-adjust\s*:/i.test(css);
     // Tertiary signal: -ms-high-contrast (legacy Edge/IE) — still relevant
-    const hasHighContrast = /@media[^{]*-ms-high-contrast/i.test(css);
+    const hasHighContrast = mediaQueryHasHighContrast(css);
     if (hasForcedColorsMedia && hasForcedColorAdjust) {
         return { id: 'v35', item: ITEM, category: CATEGORY, status: 'PASS', detail: 'forced-colors media query + forced-color-adjust both present' };
     }
@@ -3534,11 +5794,10 @@ function checkSecurityConfusables(css, tokens) {
     }
     // Scan 3: url() references — confusables in file paths can redirect to
     // different assets (logo spoofing, CSS injection via @import)
-    const urlRe = /url\(\s*['"]?([^'")]+)['"]?\s*\)/gi;
     const urlConfusables = [];
     const scannedUrls = new Set();
-    while ((m = urlRe.exec(css)) !== null) {
-        const urlPath = m[1];
+    for (const u of cssUrlMatches(css)) {
+        const urlPath = u.groups[0];
         if (scannedUrls.has(urlPath))
             continue;
         scannedUrls.add(urlPath);
@@ -3661,8 +5920,6 @@ function checkButtonTextVerb(html) {
     const ITEM = 'Button text is a verb phrase or recognized command (not a bare noun)';
     const CATEGORY = 'copywriting';
     // Extract <button> and [role="button"] text content
-    const buttonRe = /<button[^>]*>([\s\S]*?)<\/button>/gi;
-    const roleButtonRe = /<(?:a|div|span)[^>]*role=["']button["'][^>]*>([\s\S]*?)<\/(?:a|div|span)>/gi;
     // Remove aria-hidden subtrees before extracting text.
     //
     // Content marked aria-hidden is by definition not part of the accessible name,
@@ -3679,7 +5936,7 @@ function checkButtonTextVerb(html) {
         let out = inner;
         for (let i = 0; i < 4; i++) {
             // Repeat to handle an aria-hidden wrapper containing another.
-            const next = out.replace(/<([a-z][a-z0-9-]*)\b[^>]*\baria-hidden\s*=\s*["']?true["']?[^>]*>[\s\S]*?<\/\1>/gi, '');
+            const next = withoutAriaHiddenElements(out);
             if (next === out)
                 break;
             out = next;
@@ -3701,12 +5958,10 @@ function checkButtonTextVerb(html) {
     // Carry the opening tag alongside the label so the violation loop can tell a
     // command button from a selection control (see isSelectionControl).
     const buttonTexts = [];
-    let m;
     // Strip keyboard shortcut hints that are fused to or appended after the
     // button label — e.g. "Find⌘K", "Search ⌘+K", "Save Ctrl+S". These are
     // visual hints, not part of the verb. Ranges: ⌘ (U+2318), ⌃ (U+2303),
     // ⌥ (U+2325), ⇧ (U+21E7), and common "Ctrl+", "Cmd+", "Shift+" prefixes.
-    const SHORTCUT_RE = /[\s]*[\u2303\u2318\u2325\u21E7\u21E7\u2387].*$/i;
     // The `+` is optional and the key may be fused directly to the modifier
     // ("CtrlK"), because the badge is now platform-aware and renders "Ctrl" with
     // no glyph to strip. Requiring a literal '+' meant "FindCtrlK" survived and
@@ -3715,14 +5970,13 @@ function checkButtonTextVerb(html) {
     // The key must be ADJACENT to the modifier (plus form, or fused alphanumerics
     // with no space between). A space separates a real word: "Alt text" is a
     // label, not a shortcut, and must not be eaten.
-    const TEXT_SHORTCUT_RE = /[\s]*(?:Ctrl|Cmd|Shift|Alt|Option|Command)(?:\+[A-Za-z0-9+\-]*|[A-Z0-9]+)?$/;
     // Engine 1.3.1: a "+key" hint written in lower case ("Save ctrl+s",
     // "Find ctrl+k") is a hint too. The modifier is case-insensitive here but
     // must stand as its own word (the start of the label or after a space), so
     // "Halt+1" is untouched, and only the plus form is read: a modifier followed
     // by a space and a letter ("Shift A") is a label, as it was in 1.3.0.
     const PLUS_SHORTCUT_RE = /(?:^|\s)(?:ctrl|cmd|shift|alt|option|command)(?:\s*\+\s*[a-z0-9]+)+$/i;
-    const stripShortcut = (s) => s.replace(SHORTCUT_RE, '').replace(TEXT_SHORTCUT_RE, '').replace(PLUS_SHORTCUT_RE, '').trim();
+    const stripShortcut = (s) => withoutTextShortcut(withoutGlyphShortcut(s)).replace(PLUS_SHORTCUT_RE, '').trim();
     // Engine 1.3.1: keycaps are read from the markup, not guessed from text.
     // A <kbd> element is keyboard input (HTML Living Standard, the kbd element),
     // a hint beside the label rather than the label, so its text is dropped
@@ -3737,23 +5991,23 @@ function checkButtonTextVerb(html) {
         const visible = stripAriaHidden(inner);
         let out = visible;
         for (let i = 0; i < 4; i++) {
-            const next = out.replace(/<kbd\b[^>]*>(?:(?!<kbd\b)[\s\S])*?<\/kbd>/gi, ' ');
+            const next = withoutKbdElements(out);
             if (next === out)
                 break;
             out = next;
         }
-        const text = out.replace(/<[^>]*>/g, '').trim();
-        return out === visible ? text : text.replace(/(?:\s*\+)+$/, '').trim();
+        const text = withoutTags(out, '', false).trim();
+        return out === visible ? text : withoutTrailingPluses(text).trim();
     };
-    while ((m = buttonRe.exec(html)) !== null) {
-        let text = labelText(m[1]);
+    for (const m of buttonElements(html)) {
+        let text = labelText(m.groups[0]);
         // Strip leading icon characters so "✕Close" → "Close"
         text = text.replace(ICON_PREFIX_RE, '').trim();
         // Strip trailing keyboard shortcut hints so "Find⌘K" → "Find"
         text = stripShortcut(text);
         // Icon-only button with an accessible name: use the aria-label verb.
         if (!text) {
-            const aria = /aria-label=["']([^"']+)["']/i.exec(m[0]);
+            const aria = /aria-label=["']([^"']+)["']/i.exec(m.text);
             if (aria)
                 text = aria[1].trim();
         }
@@ -3763,19 +6017,19 @@ function checkButtonTextVerb(html) {
         // Without this, v38 reported six single-letter "buttons" as non-verb labels
         // on /maturity — an accurate observation of the wrong string.
         if (text && text.length <= 2) {
-            const aria = /aria-label=["']([^"']+)["']/i.exec(m[0]);
+            const aria = /aria-label=["']([^"']+)["']/i.exec(m.text);
             if (aria)
                 text = aria[1].trim();
         }
         if (text)
-            buttonTexts.push({ text, tag: m[0] });
+            buttonTexts.push({ text, tag: m.text });
     }
-    while ((m = roleButtonRe.exec(html)) !== null) {
-        let text = labelText(m[1]);
+    for (const m of roleButtonElements(html)) {
+        let text = labelText(m.groups[0]);
         text = text.replace(ICON_PREFIX_RE, '').trim();
         text = stripShortcut(text);
         if (!text) {
-            const aria = /aria-label=["']([^"']+)["']/i.exec(m[0]);
+            const aria = /aria-label=["']([^"']+)["']/i.exec(m.text);
             if (aria)
                 text = aria[1].trim();
         }
@@ -3785,12 +6039,12 @@ function checkButtonTextVerb(html) {
         // Without this, v38 reported six single-letter "buttons" as non-verb labels
         // on /maturity — an accurate observation of the wrong string.
         if (text && text.length <= 2) {
-            const aria = /aria-label=["']([^"']+)["']/i.exec(m[0]);
+            const aria = /aria-label=["']([^"']+)["']/i.exec(m.text);
             if (aria)
                 text = aria[1].trim();
         }
         if (text)
-            buttonTexts.push({ text, tag: m[0] });
+            buttonTexts.push({ text, tag: m.text });
     }
     if (buttonTexts.length === 0) {
         return { id: 'v38', item: ITEM, category: CATEGORY, status: 'SKIP', detail: 'no button elements found in HTML' };
@@ -3860,23 +6114,19 @@ function checkButtonTextVerb(html) {
 function checkNoTrailingPeriod(html) {
     const ITEM = 'No trailing period on button text, labels, or tab text';
     const CATEGORY = 'copywriting';
-    const buttonRe = /<button[^>]*>([\s\S]*?)<\/button>/gi;
-    const labelRe = /<label[^>]*>([\s\S]*?)<\/label>/gi;
-    const tabRe = /<[a-z]+[^>]*role=["']tab["'][^>]*>([\s\S]*?)<\/[a-z]+>/gi;
     const texts = [];
-    let m;
-    while ((m = buttonRe.exec(html)) !== null) {
-        const text = m[1].replace(/<[^>]*>/g, '').trim();
+    for (const m of buttonElements(html)) {
+        const text = withoutTags(m.groups[0], '', false).trim();
         if (text)
             texts.push({ type: 'button', text });
     }
-    while ((m = labelRe.exec(html)) !== null) {
-        const text = m[1].replace(/<[^>]*>/g, '').trim();
+    for (const m of labelElements(html)) {
+        const text = withoutTags(m.groups[0], '', false).trim();
         if (text)
             texts.push({ type: 'label', text });
     }
-    while ((m = tabRe.exec(html)) !== null) {
-        const text = m[1].replace(/<[^>]*>/g, '').trim();
+    for (const m of roleTabElements(html)) {
+        const text = withoutTags(m.groups[0], '', false).trim();
         if (text)
             texts.push({ type: 'tab', text });
     }
@@ -3900,11 +6150,9 @@ const NON_DESCRIPTIVE_LINK_TEXT = /^(click here|here|learn more|read more|more|l
 function checkLinkTextDescriptive(html) {
     const ITEM = 'Link text is descriptive (not bare "click here", "learn more", "here")';
     const CATEGORY = 'copywriting';
-    const linkRe = /<a[^>]*>([\s\S]*?)<\/a>/gi;
     const linkTexts = [];
-    let m;
-    while ((m = linkRe.exec(html)) !== null) {
-        const text = m[1].replace(/<[^>]*>/g, '').trim();
+    for (const m of anchorElements(html)) {
+        const text = withoutTags(m.groups[0], '', false).trim();
         if (text)
             linkTexts.push(text);
     }
@@ -3934,20 +6182,18 @@ function checkNoAllCaps(html) {
     const ITEM = 'No ALL CAPS UI text except eyebrow labels';
     const CATEGORY = 'copywriting';
     // Match elements with their class attributes so we can exclude eyebrow labels
-    const elementRe = /<(button|a|label|td|th|p|li|h[1-6])\s([^>]*?)>([\s\S]*?)<\/\1>/gi;
     const violations = [];
-    let m;
-    while ((m = elementRe.exec(html)) !== null) {
-        const attrs = m[2] || '';
-        const text = m[3].replace(/<[^>]*>/g, '').trim();
+    for (const m of capsElementMatches(html)) {
+        const attrs = m.groups[1] || '';
+        const text = withoutTags(m.groups[2], '', false).trim();
         if (!text || text.length < 4)
             continue;
         // Skip eyebrow labels (class contains "eyebrow" or "label" — per typography
         // contract, eyebrows are intentionally uppercase)
-        if (/class=["'][^"']*(eyebrow|eyebro|meta-label)[^"']*["']/i.test(attrs))
+        if (hasEyebrowClass(attrs))
             continue;
         // Skip elements with text-transform: uppercase in inline style
-        if (/style=["'][^"']*text-transform:\s*uppercase[^"']*["']/i.test(attrs))
+        if (hasUppercaseStyle(attrs))
             continue;
         // Check if text is ALL CAPS (only letters, all uppercase, >3 chars)
         const letters = text.replace(/[^a-zA-Z]/g, '');
@@ -3979,19 +6225,19 @@ function checkPoiseInteractionRules(css) {
     const rules = [
         {
             name: 'fine-pointer hover guard',
-            re: /@media[^{]*(?:hover\s*:\s*hover|pointer\s*:\s*fine)/i,
+            test: (s) => mediaQueryHasHoverGuard(s),
         },
         {
             name: 'press settle scale ~0.97',
-            re: /scale\s*\(\s*0?\.9[5-9]\s*\)/i,
+            test: (s) => /scale\s*\(\s*0?\.9[5-9]\s*\)/i.test(s),
         },
         {
             name: 'opacity-only mark breath',
-            re: /@keyframes\s+[^{]*breath[^{]*\{[^}]*opacity\s*:/i,
+            test: (s) => hasBreathKeyframes(s),
         },
     ];
-    const found = rules.filter(r => r.re.test(css)).map(r => r.name);
-    const missing = rules.filter(r => !r.re.test(css)).map(r => r.name);
+    const found = rules.filter(r => r.test(css)).map(r => r.name);
+    const missing = rules.filter(r => !r.test(css)).map(r => r.name);
     if (found.length >= 2) {
         return {
             id: 'v08',
@@ -4020,8 +6266,8 @@ function checkPoiseKeyboardPath(css, html) {
     const hasFocusVisible = /:focus-visible/i.test(css);
     const hasFocus = /:focus[^-]/i.test(css);
     // Detect focus styles that strip outline without a replacement ring/box-shadow
-    const stripsOutline = /:focus[^{]*\{[^}]*outline\s*:\s*(none|0)\s*[;}]/i.test(css);
-    const hasFocusRing = /:focus[^{]*\{[^}]*(box-shadow|outline\s*:\s*[^n0])/i.test(css);
+    const stripsOutline = focusStripsOutline(css);
+    const hasFocusRing = focusHasRing(css);
     const hasTabindex = /tabindex\s*=/i.test(html);
     const hasAria = /aria-(label|labelledby|describedby|expanded|selected|pressed)/i.test(html);
     const signals = [hasFocusVisible, hasFocus, hasFocusRing, hasTabindex, hasAria].filter(Boolean).length;
@@ -4063,19 +6309,19 @@ function checkTaktFeelRules(css) {
     const rules = [
         {
             name: 'stagger enter animation-delay',
-            re: /animation-delay\s*:\s*(?:0?\.(?:0?[6-9]|1[0-2])\d*s|\d{2,3}ms)/i,
+            test: (s) => /animation-delay\s*:\s*(?:0?\.(?:0?[6-9]|1[0-2])\d*s|\d{2,3}ms)/i.test(s),
         },
         {
             name: 'soften exit transform ease-out',
-            re: /transition\s*:[^;]*transform[^;]*(ease-out|cubic-bezier\([^)]*0[, ])/i,
+            test: (s) => hasTransformEaseTransition(s),
         },
         {
             name: 'concentric border-radius set',
-            re: /border-radius\s*:\s*\d+/i,
+            test: (s) => /border-radius\s*:\s*\d+/i.test(s),
         },
     ];
-    const found = rules.filter(r => r.re.test(css)).map(r => r.name);
-    const missing = rules.filter(r => !r.re.test(css)).map(r => r.name);
+    const found = rules.filter(r => r.test(css)).map(r => r.name);
+    const missing = rules.filter(r => !r.test(css)).map(r => r.name);
     if (found.length >= 2) {
         return {
             id: 'v10',
@@ -4172,13 +6418,50 @@ async function checkDesignMdSpec(targetUrl) {
 // (an account name often does); the last one may not, so the sentence after
 // a path survives, and trailing punctuation is kept.
 function sanitizeErrorText(text) {
-    const keep = (label) => (m) => `${label}${/[.,;:!?)]+$/.exec(m)?.[0] ?? ''}`;
-    return text
+    // The punctuation a replaced path ended with, read back from its end
+    // (engine 1.5.1: /[.,;:!?)]+$/ was retried from every mark in a run).
+    const tail = (m) => {
+        let k = m.length;
+        while (k > 0 && '.,;:!?)'.indexOf(m[k - 1]) >= 0)
+            k--;
+        return m.slice(k);
+    };
+    const keep = (label) => (m) => `${label}${tail(m)}`;
+    const pathless = text
         .replace(/\bfile:\/\/[^\s'"<>`|]*/gi, keep('a local file'))
         .replace(/\\\\[^\\\s'"<>`|]+\\(?:[^\\\r\n'"<>`|*?]+\\)*[^\\\s'"<>`|*?]*/g, keep('a local path'))
         .replace(/(?<![\w\\/])[A-Za-z]:([\\/])(?:[^\\/\r\n'"<>`|*?]+\1)*[^\\/\s'"<>`|*?]*/g, keep('a local path'))
-        .replace(/(^|[\s'"`(=,:[])\/(?:home|Users|root|tmp|var|private|opt|usr|srv|mnt|Volumes|Library|app|vercel|workspace|workspaces|github|runner|nix|snap)(?:\/[^/\r\n'"<>`|]+(?=\/))*\/[^/\s'"<>`|]+/g, (m, lead) => `${lead}${keep('a local path')(m.slice(lead.length))}`)
-        .replace(/[^\s'"<>`|]*(?:npm-cache|[\\/]_npx[\\/]|[\\/]\.npm[\\/])[^\s'"<>`|]*/gi, keep('the npm cache'));
+        .replace(/(^|[\s'"`(=,:[])\/(?:home|Users|root|tmp|var|private|opt|usr|srv|mnt|Volumes|Library|app|vercel|workspace|workspaces|github|runner|nix|snap)(?:\/[^/\r\n'"<>`|]+(?=\/))*\/[^/\s'"<>`|]+/g, (m, lead) => `${lead}${keep('a local path')(m.slice(lead.length))}`);
+    // npm cache segments: a run of characters other than space, quotes, angle
+    // brackets, backtick and pipe that holds npm-cache, /_npx/ or /.npm/ is
+    // replaced whole. Each run is read once (engine 1.5.1: the run pattern was
+    // retried from every character in it).
+    const marker = /npm-cache|[\\/]_npx[\\/]|[\\/]\.npm[\\/]/gi;
+    const stop = /[\s'"<>`|]/;
+    const parts = [];
+    let last = 0;
+    let markerAt = -1;
+    for (let a = 0; a < pathless.length;) {
+        if (stop.test(pathless[a])) {
+            a++;
+            continue;
+        }
+        let b = a + 1;
+        while (b < pathless.length && !stop.test(pathless[b]))
+            b++;
+        if (markerAt < a) {
+            marker.lastIndex = a;
+            const found = marker.exec(pathless);
+            markerAt = found ? found.index : Infinity;
+        }
+        if (markerAt < b) {
+            parts.push(pathless.slice(last, a), keep('the npm cache')(pathless.slice(a, b)));
+            last = b;
+        }
+        a = b;
+    }
+    parts.push(pathless.slice(last));
+    return parts.join('');
 }
 /** The checks with every detail passed through sanitizeErrorText. */
 function sanitizeCheckDetails(checks) {
@@ -4318,7 +6601,7 @@ function scoreArithmetic(checks, slopTotal, originalityPoints) {
     // contrast or horizontal overflow cannot be A-grade no matter how good its
     // tokens are. Caps are applied AFTER the a11y floor (floor wins over ceilings).
     //
-    // No A while any check FAILs (engine 1.3.0, owner decision 2026-10-11). A
+    // No A while any check FAILs (engine 1.3.0, see CHANGELOG). A
     // FAIL is the engine's own finding that the page breaks a rule, so any FAIL
     // caps the score at 89.9, a B at most. Until 1.3.0 a page could score 100, an
     // A, beside FAIL verdicts, including the engine's own WCAG contrast FAIL
@@ -4346,7 +6629,7 @@ function scoreArithmetic(checks, slopTotal, originalityPoints) {
         }
         // v44 Status text contrast — the words that report a state fail WCAG
         // 1.4.3 (or 1.4.11 for a graphic) on a surface the stylesheet attests.
-        // Same cap as v06 (engine 1.3.0, owner decision 2026-10-11): both are
+        // Same cap as v06 (engine 1.3.0): both are
         // measured WCAG contrast failures on text.
         if (c.id === 'v44') {
             cap = 65;
@@ -4596,40 +6879,13 @@ export async function scoreFromParts(input) {
         // reverse, `linear-gradient(color-mix(...) 1px, transparent 1px)`, and its
         // graph-paper grid was reported at the maximum severity. Match a 1px stop
         // in EITHER order, which is what "hairline" means however it is written.
-        const isGridPattern = (text) => /(?:transparent|rgba\([^)]+\)|color-mix\([^)]*\)|var\([^)]*\)|#[0-9a-fA-F]{3,8})\s+1px(?:\s*,)/.test(text)
-            || /\s+1px\s*,\s*(?:transparent|rgba\([^)]+\)|color-mix\([^)]*\)|var\([^)]*\))/.test(text);
-        // Two or more colour stops in some linear-gradient() of the value.
-        const multiStop = (value) => {
-            let from = 0;
-            for (;;) {
-                const at = value.toLowerCase().indexOf('linear-gradient(', from);
-                if (at < 0)
-                    return false;
-                let depth = 0;
-                let end = -1;
-                for (let i = at + 15; i < value.length; i++) {
-                    if (value[i] === '(')
-                        depth++;
-                    else if (value[i] === ')' && --depth === 0) {
-                        end = i;
-                        break;
-                    }
-                }
-                if (end < 0)
-                    return false;
-                const args = splitCssTopLevel(value.slice(at + 16, end), ',');
-                const stops = /^(?:to\s|[-+]?[\d.]+(?:deg|turn|rad|grad)\b)/i.test(args[0] ?? '') ? args.slice(1) : args;
-                if (stops.length >= 2)
-                    return true;
-                from = end;
-            }
-        };
+        const isGridPattern = (text) => hasColorThenHairline(text) || hasHairlineThenColor(text);
         const pageGrad = [];
         for (const rule of parseCssRules(css).rules) {
             if (!/linear-gradient\s*\(/i.test(rule.decls))
                 continue;
             const decls = parseCssDecls(rule.decls);
-            if (!decls.some((d) => (d.prop === 'background' || d.prop === 'background-image') && multiStop(d.value)))
+            if (!decls.some((d) => (d.prop === 'background' || d.prop === 'background-image') && hasMultiStopGradient(d.value)))
                 continue;
             const text = `${rule.selector}{${rule.decls}}`;
             if (isGridPattern(text))
@@ -4652,7 +6908,7 @@ export async function scoreFromParts(input) {
             const hairline = decls.some((d) => (/^(?:height|width|block-size|inline-size)$/.test(d.prop) && d.value.trim() === '1px')
                 || (/^border(?:-top|-bottom)?-width$/.test(d.prop) && d.value.trim() === '1px')
                 || (d.prop === 'background-size' && /(?:^|[\s,])1px(?:$|[\s,])/.test(d.value))
-                || (d.prop === 'background' && /\/\s*[^,/]*(?:^|\s)1px(?:$|[\s,])/.test(d.value)));
+                || (d.prop === 'background' && hasSlashThenHairline(d.value)));
             const fixedCover = last('position') === 'fixed' && (pinned || viewportSized);
             if ((pageSelector || fixedCover || (viewportSized && !component)) && !hairline)
                 pageGrad.push(text.replace(/\s+/g, ' ').slice(0, 160));
@@ -4670,8 +6926,7 @@ export async function scoreFromParts(input) {
     }
     // S3. Purple/violet gradient
     {
-        const purplePattern = /(?:background(?:-image)?\s*:[^;]*linear-gradient[^;]*(?:#?(?:615fff|8e51ff|4f39f6|7f22fe|a855f7|9333ea|7c3aed|6d28d9|5b21b6|4c1d95)))/gi;
-        const matches = css.match(purplePattern);
+        const matches = purpleGradientDecls(css);
         if (matches)
             slopFindings.push({ id: 'S3', label: 'Purple/violet AI gradient', severity: 4, instances: matches.length, evidence: matches.slice(0, 3) });
     }
@@ -4683,7 +6938,7 @@ export async function scoreFromParts(input) {
         // pattern anchored to `(?:^|})` takes 4 ms and matches the same rule.
         // Measured 2026-09-19, Node 24. This was the real cause of the 55s cold
         // score, not the network (0.9s) and not the sequential CSS fetch.
-        const gradientClips = css.match(/(?:^|\})[^{}]*\{[^}]*background-clip\s*:\s*text[^}]*\}/gi) || [];
+        const gradientClips = gradientClipRules(css);
         const hueKey = (stop) => {
             if (/var\(/.test(stop))
                 return null;
@@ -4705,7 +6960,7 @@ export async function scoreFromParts(input) {
                 h = Math.round(((h * 60) + 360) % 360);
                 return 'h' + Math.floor(h / 45);
             }
-            const rgb = stop.match(/rgba?\(([^)]+)\)/i);
+            const rgb = rgbArgs(stop);
             if (rgb) {
                 const p = rgb[1].split(',').map(x => parseFloat(x));
                 if (p.length >= 3) {
@@ -4728,8 +6983,8 @@ export async function scoreFromParts(input) {
             return null;
         };
         const multiColorGradient = gradientClips.filter(block => {
-            const gradientMatch = block.match(/linear-gradient\(([\s\S]+)\)\s*;?\s*background-size|linear-gradient\(([^;]+)\)/i);
-            const gradText = (gradientMatch && (gradientMatch[1] || gradientMatch[2])) || '';
+            const gradientMatch = linearGradientArgs(block);
+            const gradText = (gradientMatch && (gradientMatch.groups[0] || gradientMatch.groups[1])) || '';
             const stops = gradText.split(',').map(s => s.trim());
             const hueKeys = new Set(stops.map(hueKey).filter((k) => k !== null && k !== 'neutral'));
             return hueKeys.size >= 2;
@@ -4750,8 +7005,7 @@ export async function scoreFromParts(input) {
     {
         const cardPattern = /\.(card|panel|tile|feature|item|box|cell|block)\b/gi;
         const cardClasses = css.match(cardPattern) || [];
-        const gridCardPattern = /grid-template-columns[^}]*repeat\s*\(\s*(?:auto-fit|auto-fill|\d+)/gi;
-        const gridMatches = css.match(gridCardPattern) || [];
+        const gridMatches = gridRepeatRules(css);
         if (cardClasses.length >= 3 && gridMatches.length > 0)
             slopFindings.push({ id: 'S6', label: 'Repeated identical card grid', severity: 5, instances: 1, evidence: [`${cardClasses.length} card-like classes with repeating grid layouts`] });
     }
@@ -4765,7 +7019,7 @@ export async function scoreFromParts(input) {
     // text-default ones promoted with U+FE0F. This also catches ⭐ (U+2B50), which
     // the old range missed while it was busy flagging checkmarks.
     {
-        const emojiInButtons = html.match(/(?:<button|<a[^>]*class[^>]*(?:btn|cta|primary|action))[^>]*>[\s\S]{0,200}(?:[\p{Emoji_Presentation}]|[\p{Emoji}]\uFE0F)/giu);
+        const emojiInButtons = emojiCtaMatches(html);
         if (emojiInButtons && emojiInButtons.length >= 2)
             slopFindings.push({ id: 'S7', label: 'Emoji as UI icons', severity: 4, instances: emojiInButtons.length, evidence: [`${emojiInButtons.length} emoji in button/CTA elements`] });
     }
@@ -4783,11 +7037,7 @@ export async function scoreFromParts(input) {
     // Skipped on a page that documents the rules (see isDocumentingSlopRules):
     // the anti-slop rule table on /methodology lists these phrases.
     {
-        const visible = html
-            .replace(/<script\b[\s\S]*?<\/script\s*>/gi, ' ')
-            .replace(/<style\b[\s\S]*?<\/style\s*>/gi, ' ')
-            .replace(/<template\b[\s\S]*?<\/template\s*>/gi, ' ')
-            .replace(/<!--[\s\S]*?-->/g, ' ');
+        const visible = withoutNonVisibleMarkup(html);
         const pillPhrase = /\b(?:AI-powered|Generate|Chat with AI|Powered by AI|Built with AI|AI-driven)\b/i;
         const openRe = /<(span|a|button|div|small|strong|b|em|mark|label|p|li)\b([^<>]*)>/gi;
         const tagRe = {};
@@ -4818,7 +7068,7 @@ export async function scoreFromParts(input) {
             }
             if (end < 0)
                 continue;
-            const text = windowText.slice(0, end).replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+            const text = withoutTags(windowText.slice(0, end), ' ', false).replace(/\s+/g, ' ').trim();
             if (text && text.length <= 40 && pillPhrase.test(text))
                 pills.push(text);
         }
@@ -4854,7 +7104,7 @@ export async function scoreFromParts(input) {
     // S11. Marketing buzzwords
     {
         const buzzwords = ['streamline', 'empower', 'supercharge', 'world-class', 'enterprise-grade', 'next-generation', 'unlock', 'leverage', 'seamless', 'cutting-edge', 'revolutionize', 'game-chang', 'disrupt', 'synerg'];
-        const bodyText = html.replace(/<[^>]+>/g, ' ').toLowerCase();
+        const bodyText = withoutTags(html, ' ', true).toLowerCase();
         const found = [];
         for (const word of buzzwords) {
             if (bodyText.includes(word))
@@ -4880,21 +7130,20 @@ export async function scoreFromParts(input) {
     const originalitySignals = [];
     // O1. Bespoke easing
     {
-        const bezierRe = /cubic-bezier\(\s*(-?\d*\.?\d+)\s*,\s*(-?\d*\.?\d+)\s*,\s*(-?\d*\.?\d+)\s*,\s*(-?\d*\.?\d+)\s*\)/gi;
         const EASING_PRESETS = new Set(['0.25,0.1,0.25,1', '0.42,0,1,1', '0,0,0.58,1', '0.42,0,0.58,1', '0.4,0,0.2,1', '0.4,0,0.6,1', '0,0,0.2,1', '0.4,0,1,1', '0.68,-0.55,0.265,1.55']);
         const distinct = new Set();
         let hasOvershoot = false;
-        let m;
-        while ((m = bezierRe.exec(css)) !== null) {
-            const key = `${m[1]},${m[2]},${m[3]},${m[4]}`.replace(/(\.\d*?)0+(?=\D|$)/g, '$1').replace(/\s+/g, '');
+        for (const b of cubicBezierMatches(css)) {
+            const [x1, y1s, x2, y2s] = b.groups;
+            const key = withoutTrailingDecimalZeros(`${x1},${y1s},${x2},${y2s}`).replace(/\s+/g, '');
             if (EASING_PRESETS.has(key))
                 continue;
             distinct.add(key);
-            const y1 = parseFloat(m[2]), y2 = parseFloat(m[4]);
+            const y1 = parseFloat(y1s), y2 = parseFloat(y2s);
             if (y1 < 0 || y1 > 1 || y2 < 0 || y2 > 1)
                 hasOvershoot = true;
         }
-        const linearSprings = css.match(/linear\(\s*[^)]{20,}\)/gi) || [];
+        const linearSprings = longLinearEasings(css);
         if (linearSprings.length > 0)
             hasOvershoot = true;
         const easingCount = distinct.size;
@@ -4924,8 +7173,8 @@ export async function scoreFromParts(input) {
     }
     // O4. Tiered reduced-motion
     {
-        const reducedMotion = /@media[^{]*prefers-reduced-motion/i.test(css);
-        const blanketKill = /prefers-reduced-motion[\s\S]{0,200}\*\s*\{[^}]*animation\s*:\s*none/i.test(css);
+        const reducedMotion = mediaQueryHasReducedMotion(css);
+        const blanketKill = hasBlanketMotionKill(css);
         if (reducedMotion && !blanketKill)
             originalitySignals.push({ id: 'O4', label: 'Tiered reduced-motion', points: 1, evidence: 'targeted (not blanket) motion reduction' });
     }
@@ -4942,8 +7191,8 @@ export async function scoreFromParts(input) {
     }
     // O6. Bespoke iconography
     {
-        const inlineSvg = html.match(/<svg[^>]*viewBox=/gi) || [];
-        const svgSymbols = html.match(/<symbol[^>]*>/gi) || [];
+        const inlineSvg = svgViewBoxTags(html);
+        const svgSymbols = symbolTags(html);
         if (inlineSvg.length >= 3 || svgSymbols.length >= 2)
             originalitySignals.push({ id: 'O6', label: 'Bespoke iconography', points: 1, evidence: `${inlineSvg.length} inline SVGs${svgSymbols.length ? ` + ${svgSymbols.length} symbols` : ''}` });
     }
@@ -4953,11 +7202,11 @@ export async function scoreFromParts(input) {
         const shadcnHits = SHADCN_FINGERPRINT.filter((t) => css.includes(t + ':')).length;
         const referencesTwPrimitives = /var\(--color-[a-z]+-\d{2,3}\)/i.test(css);
         const isShadcnTemplate = shadcnHits >= 6 || (shadcnHits >= 4 && referencesTwPrimitives);
-        const customProps = css.match(/--[\w-]+\s*:/g) || [];
+        const customProps = customPropertyDecls(css);
         const semanticTokens = customProps.filter((p) => /--(surface|ink|paper|signal|line|muted|elevation|radius|duration|ease|accent|foreground|space|gap|shadow|canvas|action|feedback|success|warning|danger|error|info|subtle|on-[a-z]+)/i.test(p));
         const primitiveHue = /--(?:color|colour)-[a-z]+-\d{2,3}\s*:/i;
         const semanticCount = isShadcnTemplate ? 0 : semanticTokens.filter((p) => !primitiveHue.test(p)).length;
-        const hasLayering = /--(?:color|surface|accent|action|feedback)[\w-]*\s*:\s*var\(--/i.test(css);
+        const hasLayering = hasTokenLayering(css);
         const hasTheming = /light-dark\(|prefers-color-scheme\s*:\s*dark|data-theme/i.test(css);
         let tokenPoints = 0;
         const tokenEvidence = [];
@@ -5110,9 +7359,12 @@ export function emitReview(url, result) {
             continue;
         num++;
         const severity = c.status === 'FAIL' ? 'HIGH' : 'MEDIUM';
-        const before = c.detail.replace(/\|/g, '\\|').substring(0, 80);
-        const after = (c.remediation || '').replace(/\|/g, '\\|').substring(0, 80);
-        const why = `${c.item} (${c.category})`.replace(/\|/g, '\\|');
+        // A cell escapes its backslashes before its pipes: a detail carries text
+        // read from the scored page, where a backslash before a pipe would
+        // otherwise escape the escape and leave a live cell separator.
+        const before = c.detail.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').substring(0, 80);
+        const after = (c.remediation || '').replace(/\\/g, '\\\\').replace(/\|/g, '\\|').substring(0, 80);
+        const why = `${c.item} (${c.category})`.replace(/\\/g, '\\\\').replace(/\|/g, '\\|');
         lines.push(`| ${num} | ${severity} | ${c.category} | ${url} | ${before} | ${after} | ${why} |`);
     }
     if (num === 0)