@ismail-elkorchi/css-parser 0.1.0

package/dist/public/mod.js

@@ -0,0 +1,1740 @@
+import { decodeCssBytes, sniffCssEncoding } from "../internal/encoding/mod.js";
+import { sanitizeCssNode, serializeTreeNode } from "../internal/serializer/mod.js";
+import { tokenize as tokenizeInternal } from "../internal/tokenizer/mod.js";
+import { buildTreeFromCss } from "../internal/tree/mod.js";
+const STREAM_ENCODING_PRESCAN_BYTES = 1024;
+const CSS_PARSE_ERRORS_SECTION_URL = "https://drafts.csswg.org/css-syntax/#error-handling";
+const SUPPORTED_PARSE_CONTEXTS = new Set([
+    "stylesheet",
+    "atrule",
+    "atrulePrelude",
+    "mediaQueryList",
+    "mediaQuery",
+    "condition",
+    "rule",
+    "selectorList",
+    "selector",
+    "block",
+    "declarationList",
+    "declaration",
+    "value"
+]);
+export class BudgetExceededError extends Error {
+    payload;
+    constructor(payload) {
+        super(`Budget exceeded: ${payload.budget} limit=${String(payload.limit)} actual=${String(payload.actual)}`);
+        this.name = "BudgetExceededError";
+        this.payload = payload;
+    }
+}
+export class PatchPlanningError extends Error {
+    payload;
+    constructor(payload) {
+        super(`Patch planning failed: ${payload.code}${payload.target === undefined ? "" : ` target=${String(payload.target)}`}`);
+        this.name = "PatchPlanningError";
+        this.payload = payload;
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}
+function isPublicNode(value) {
+    return isRecord(value) && typeof value["id"] === "number" && typeof value["type"] === "string";
+}
+function normalizeParseErrorId(message) {
+    const normalized = message.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    return normalized.length > 0 ? normalized : "css-syntax-error";
+}
+function normalizeFragmentContext(contextTagName) {
+    const normalized = contextTagName.trim().toLowerCase();
+    switch (normalized) {
+        case "stylesheet":
+            return "stylesheet";
+        case "atrule":
+        case "at-rule":
+            return "atrule";
+        case "atruleprelude":
+        case "at-rule-prelude":
+            return "atrulePrelude";
+        case "mediaquerylist":
+        case "media-query-list":
+            return "mediaQueryList";
+        case "mediaquery":
+        case "media-query":
+            return "mediaQuery";
+        case "condition":
+            return "condition";
+        case "rule":
+        case "rulelist":
+        case "rule-list":
+            return "rule";
+        case "selectorlist":
+        case "selector-list":
+            return "selectorList";
+        case "selector":
+            return "selector";
+        case "block":
+            return "block";
+        case "declarationlist":
+        case "declaration-list":
+            return "declarationList";
+        case "declaration":
+            return "declaration";
+        case "value":
+            return "value";
+        default:
+            throw new Error(`Unsupported parse context: ${contextTagName}`);
+    }
+}
+function enforceBudget(budget, limit, actual) {
+    if (limit === undefined || actual <= limit) {
+        return;
+    }
+    throw new BudgetExceededError({
+        code: "BUDGET_EXCEEDED",
+        budget,
+        limit,
+        actual
+    });
+}
+function eventSize(event) {
+    return JSON.stringify(event).length;
+}
+function pushTrace(trace, event, budgets) {
+    if (!trace) {
+        return undefined;
+    }
+    const nextEvent = {
+        seq: trace.length + 1,
+        ...event
+    };
+    const next = [...trace, nextEvent];
+    enforceBudget("maxTraceEvents", budgets?.maxTraceEvents, next.length);
+    const bytes = next.reduce((total, item) => total + eventSize(item), 0);
+    enforceBudget("maxTraceBytes", budgets?.maxTraceBytes, bytes);
+    return next;
+}
+function pushBudgetTrace(trace, budget, limit, actual, budgets) {
+    return pushTrace(trace, {
+        kind: "budget",
+        budget,
+        limit: limit ?? null,
+        actual,
+        status: limit === undefined || actual <= limit ? "ok" : "exceeded"
+    }, budgets);
+}
+function toPublicSpanFromLoc(loc, captureSpans) {
+    if (!captureSpans || !isRecord(loc)) {
+        return undefined;
+    }
+    const start = loc["start"];
+    const end = loc["end"];
+    if (!isRecord(start) || !isRecord(end)) {
+        return undefined;
+    }
+    const startOffset = start["offset"];
+    const endOffset = end["offset"];
+    if (typeof startOffset !== "number" ||
+        typeof endOffset !== "number" ||
+        startOffset < 0 ||
+        endOffset < startOffset) {
+        return undefined;
+    }
+    return {
+        start: startOffset,
+        end: endOffset
+    };
+}
+function annotateAnyWithSpans(value, nodeIdState) {
+    if (value === null || typeof value !== "object") {
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            annotateAnyWithSpans(value[index], nodeIdState);
+        }
+        return;
+    }
+    const mutable = value;
+    const isTypedNode = typeof mutable["type"] === "string";
+    for (const key in mutable) {
+        if (isTypedNode && (key === "loc" || key === "type")) {
+            continue;
+        }
+        const entry = mutable[key];
+        if (entry === null || typeof entry !== "object") {
+            continue;
+        }
+        if (Array.isArray(entry)) {
+            const children = entry;
+            for (let index = 0; index < children.length; index += 1) {
+                const child = children[index];
+                if (child !== null && typeof child === "object") {
+                    annotateAnyWithSpans(child, nodeIdState);
+                }
+            }
+            continue;
+        }
+        annotateAnyWithSpans(entry, nodeIdState);
+    }
+    if (!isTypedNode) {
+        return;
+    }
+    mutable["id"] = nodeIdState.next;
+    nodeIdState.next += 1;
+    const span = toPublicSpanFromLoc(mutable["loc"], true);
+    mutable["spanProvenance"] = span ? "input" : "none";
+    if (span) {
+        mutable["span"] = span;
+    }
+}
+function annotateAnyNoSpans(value, nodeIdState) {
+    if (value === null || typeof value !== "object") {
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (let index = 0; index < value.length; index += 1) {
+            annotateAnyNoSpans(value[index], nodeIdState);
+        }
+        return;
+    }
+    const mutable = value;
+    const isTypedNode = typeof mutable["type"] === "string";
+    for (const key in mutable) {
+        if (isTypedNode && (key === "loc" || key === "type")) {
+            continue;
+        }
+        const entry = mutable[key];
+        if (entry === null || typeof entry !== "object") {
+            continue;
+        }
+        if (Array.isArray(entry)) {
+            const children = entry;
+            for (let index = 0; index < children.length; index += 1) {
+                const child = children[index];
+                if (child !== null && typeof child === "object") {
+                    annotateAnyNoSpans(child, nodeIdState);
+                }
+            }
+            continue;
+        }
+        annotateAnyNoSpans(entry, nodeIdState);
+    }
+    if (!isTypedNode) {
+        return;
+    }
+    mutable["id"] = nodeIdState.next;
+    nodeIdState.next += 1;
+}
+function annotateNode(rawNode, nodeIdState, captureSpans) {
+    if (captureSpans) {
+        annotateAnyWithSpans(rawNode, nodeIdState);
+    }
+    else {
+        annotateAnyNoSpans(rawNode, nodeIdState);
+    }
+    return rawNode;
+}
+function collectChildNodes(value, into) {
+    if (isPublicNode(value)) {
+        into.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            collectChildNodes(entry, into);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const entry of Object.values(value)) {
+        collectChildNodes(entry, into);
+    }
+}
+function childNodes(node) {
+    const result = [];
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "id" || key === "type" || key === "span" || key === "spanProvenance") {
+            continue;
+        }
+        collectChildNodes(value, result);
+    }
+    return result;
+}
+function collectMetrics(root, depth) {
+    let nodes = 1;
+    let maxDepth = depth;
+    for (const child of childNodes(root)) {
+        const childMetrics = collectMetrics(child, depth + 1);
+        nodes += childMetrics.nodes;
+        if (childMetrics.maxDepth > maxDepth) {
+            maxDepth = childMetrics.maxDepth;
+        }
+    }
+    return { nodes, maxDepth };
+}
+function toParseErrors(errors) {
+    return errors.map((error) => {
+        const offset = typeof error.offset === "number" && error.offset >= 0 ? error.offset : null;
+        const parseErrorId = normalizeParseErrorId(error.message);
+        return {
+            code: "PARSER_ERROR",
+            parseErrorId,
+            message: error.message,
+            ...(offset !== null
+                ? {
+                    span: {
+                        start: offset,
+                        end: offset + 1
+                    }
+                }
+                : {}),
+            ...(typeof error.line === "number" ? { line: error.line } : {}),
+            ...(typeof error.column === "number" ? { column: error.column } : {})
+        };
+    });
+}
+function tokenizerBudgetsFromParseOptions(budgets) {
+    if (!budgets) {
+        return undefined;
+    }
+    const next = {
+        ...(budgets.maxTokens !== undefined ? { maxTokens: budgets.maxTokens } : {}),
+        ...(budgets.maxTimeMs !== undefined ? { maxTimeMs: budgets.maxTimeMs } : {})
+    };
+    return Object.keys(next).length > 0 ? next : undefined;
+}
+function toPublicToken(token) {
+    return {
+        kind: token.kind,
+        rawKind: token.rawKind,
+        value: token.value,
+        start: token.start,
+        end: token.end
+    };
+}
+function topLevelChildren(root) {
+    const maybeChildren = root["children"];
+    if (!Array.isArray(maybeChildren)) {
+        return [];
+    }
+    return maybeChildren;
+}
+function isStyleSheetTree(value) {
+    return (isRecord(value) &&
+        value["kind"] === "stylesheet" &&
+        isPublicNode(value["root"]));
+}
+function isFragmentTree(value) {
+    return (isRecord(value) &&
+        value["kind"] === "fragment" &&
+        isPublicNode(value["root"]));
+}
+function parseInternal(css, context, options = {}) {
+    const budgets = options.budgets;
+    const maxTimeMs = budgets?.maxTimeMs;
+    const hasTimeBudget = maxTimeMs !== undefined;
+    const startedAt = hasTimeBudget ? Date.now() : 0;
+    const captureSpans = options.captureSpans ?? options.includeSpans ?? false;
+    let trace = options.trace ? [] : undefined;
+    const needsTokenization = options.trace === true ||
+        budgets?.maxTokens !== undefined ||
+        budgets?.maxTimeMs !== undefined;
+    const needsMetrics = options.trace === true ||
+        budgets?.maxNodes !== undefined ||
+        budgets?.maxDepth !== undefined;
+    enforceBudget("maxInputBytes", budgets?.maxInputBytes, css.length);
+    if (trace) {
+        trace =
+            pushTrace(trace, {
+                kind: "decode",
+                source: "input",
+                encoding: "utf-8",
+                sniffSource: "input"
+            }, budgets) ?? trace;
+        trace =
+            pushBudgetTrace(trace, "maxInputBytes", budgets?.maxInputBytes, css.length, budgets) ?? trace;
+    }
+    let tokenCount = null;
+    if (needsTokenization) {
+        const tokenizerBudgets = tokenizerBudgetsFromParseOptions(budgets);
+        const tokenized = tokenizerBudgets
+            ? tokenizeInternal(css, { budgets: tokenizerBudgets })
+            : tokenizeInternal(css);
+        tokenCount = tokenized.tokens.length;
+        enforceBudget("maxTokens", budgets?.maxTokens, tokenCount);
+        trace = pushTrace(trace, {
+            kind: "token",
+            count: tokenCount
+        }, budgets);
+    }
+    const built = buildTreeFromCss(css, {
+        context,
+        captureSpans
+    });
+    const nodeIdState = { next: 1 };
+    const treeId = nodeIdState.next;
+    nodeIdState.next += 1;
+    const root = annotateNode(built.root, nodeIdState, captureSpans);
+    const children = topLevelChildren(root);
+    let metrics = null;
+    if (needsMetrics) {
+        metrics = collectMetrics(root, 1);
+        enforceBudget("maxNodes", budgets?.maxNodes, metrics.nodes);
+        enforceBudget("maxDepth", budgets?.maxDepth, metrics.maxDepth);
+    }
+    if (hasTimeBudget) {
+        enforceBudget("maxTimeMs", maxTimeMs, Date.now() - startedAt);
+    }
+    const publicErrors = toParseErrors(built.errors);
+    if (trace) {
+        trace = pushTrace(trace, {
+            kind: "parse",
+            context,
+            nodeCount: metrics?.nodes ?? 0,
+            errorCount: built.errors.length
+        }, budgets);
+        for (const parseError of publicErrors) {
+            trace = pushTrace(trace, {
+                kind: "parseError",
+                parseErrorId: parseError.parseErrorId,
+                startOffset: parseError.span?.start ?? null,
+                endOffset: parseError.span?.end ?? null
+            }, budgets);
+        }
+        if (tokenCount !== null) {
+            trace = pushBudgetTrace(trace, "maxTokens", budgets?.maxTokens, tokenCount, budgets);
+        }
+        if (metrics) {
+            trace = pushBudgetTrace(trace, "maxNodes", budgets?.maxNodes, metrics.nodes, budgets);
+            trace = pushBudgetTrace(trace, "maxDepth", budgets?.maxDepth, metrics.maxDepth, budgets);
+        }
+    }
+    return {
+        root: Object.assign(root, { id: treeId }),
+        children,
+        errors: publicErrors,
+        ...(trace ? { trace } : {})
+    };
+}
+export function parse(css, options = {}) {
+    if (options.context !== undefined && options.context !== "stylesheet") {
+        throw new Error("parse() only supports context \"stylesheet\"; use parseFragment() for other contexts");
+    }
+    const parsed = parseInternal(css, "stylesheet", options);
+    return {
+        id: parsed.root.id,
+        kind: "stylesheet",
+        context: "stylesheet",
+        root: parsed.root,
+        children: parsed.children,
+        errors: parsed.errors,
+        ...(parsed.trace ? { trace: parsed.trace } : {})
+    };
+}
+export function parseFragment(css, contextTagName, options = {}) {
+    const context = normalizeFragmentContext(contextTagName);
+    if (!SUPPORTED_PARSE_CONTEXTS.has(context)) {
+        throw new Error(`Unsupported parse context: ${contextTagName}`);
+    }
+    const parsed = parseInternal(css, context, options);
+    return {
+        id: parsed.root.id,
+        kind: "fragment",
+        context,
+        root: parsed.root,
+        children: parsed.children,
+        errors: parsed.errors,
+        ...(parsed.trace ? { trace: parsed.trace } : {})
+    };
+}
+export function parseRuleList(css, options = {}) {
+    return parseFragment(css, "rule", options);
+}
+export function parseDeclarationList(css, options = {}) {
+    return parseFragment(css, "declarationList", options);
+}
+export function getParseErrorSpecRef(parseErrorId) {
+    void parseErrorId;
+    return CSS_PARSE_ERRORS_SECTION_URL;
+}
+function decodeStreamError(error) {
+    if (error instanceof Error) {
+        return new Error(`STREAM_READ_FAILED: ${error.message}`);
+    }
+    return new Error(`STREAM_READ_FAILED: ${String(error)}`);
+}
+async function decodeStreamToText(stream, options) {
+    const startedAt = Date.now();
+    const budgets = options.budgets;
+    const reader = stream.getReader();
+    let total = 0;
+    const pendingChunks = [];
+    let pendingBytes = 0;
+    let maxBufferedObserved = 0;
+    let sniff = null;
+    let decoder;
+    const decodedParts = [];
+    const readPendingBytes = () => {
+        if (pendingBytes === 0) {
+            return new Uint8Array(0);
+        }
+        const combined = new Uint8Array(pendingBytes);
+        let offset = 0;
+        for (const chunk of pendingChunks) {
+            combined.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return combined;
+    };
+    try {
+        for (;;) {
+            const next = await reader.read();
+            if (next.done) {
+                break;
+            }
+            const chunkValue = next.value;
+            total += chunkValue.byteLength;
+            enforceBudget("maxInputBytes", budgets?.maxInputBytes, total);
+            enforceBudget("maxTimeMs", budgets?.maxTimeMs, Date.now() - startedAt);
+            if (!sniff) {
+                pendingChunks.push(chunkValue);
+                pendingBytes += chunkValue.byteLength;
+                maxBufferedObserved = Math.max(maxBufferedObserved, pendingBytes);
+                enforceBudget("maxBufferedBytes", budgets?.maxBufferedBytes, pendingBytes);
+                const shouldSniffNow = options.transportEncodingLabel !== undefined || pendingBytes >= STREAM_ENCODING_PRESCAN_BYTES;
+                if (!shouldSniffNow) {
+                    continue;
+                }
+                const bufferedBytes = readPendingBytes();
+                sniff = sniffCssEncoding(bufferedBytes, {
+                    ...(options.transportEncodingLabel !== undefined
+                        ? { transportEncodingLabel: options.transportEncodingLabel }
+                        : {}),
+                    maxPrescanBytes: STREAM_ENCODING_PRESCAN_BYTES
+                });
+                decoder = new TextDecoder(sniff.encoding);
+                const decoded = decoder.decode(bufferedBytes, { stream: true });
+                if (decoded.length > 0) {
+                    decodedParts.push(decoded);
+                }
+                pendingChunks.length = 0;
+                pendingBytes = 0;
+                continue;
+            }
+            maxBufferedObserved = Math.max(maxBufferedObserved, chunkValue.byteLength);
+            enforceBudget("maxBufferedBytes", budgets?.maxBufferedBytes, chunkValue.byteLength);
+            if (!decoder) {
+                throw new Error("stream decoder unavailable");
+            }
+            const decoded = decoder.decode(chunkValue, { stream: true });
+            if (decoded.length > 0) {
+                decodedParts.push(decoded);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof BudgetExceededError) {
+            throw error;
+        }
+        throw decodeStreamError(error);
+    }
+    if (!sniff) {
+        const bufferedBytes = readPendingBytes();
+        sniff = sniffCssEncoding(bufferedBytes, {
+            ...(options.transportEncodingLabel !== undefined
+                ? { transportEncodingLabel: options.transportEncodingLabel }
+                : {}),
+            maxPrescanBytes: STREAM_ENCODING_PRESCAN_BYTES
+        });
+        decoder = new TextDecoder(sniff.encoding);
+        const decoded = decoder.decode(bufferedBytes, { stream: true });
+        if (decoded.length > 0) {
+            decodedParts.push(decoded);
+        }
+    }
+    if (!decoder) {
+        throw new Error("stream decoder initialization failed");
+    }
+    const decodedTail = decoder.decode();
+    if (decodedTail.length > 0) {
+        decodedParts.push(decodedTail);
+    }
+    return {
+        text: decodedParts.join(""),
+        sniff,
+        totalBytes: total,
+        maxBufferedObserved
+    };
+}
+export function tokenize(css, options = {}) {
+    enforceBudget("maxInputBytes", options.budgets?.maxInputBytes, css.length);
+    const tokenized = tokenizeInternal(css, {
+        budgets: {
+            ...(options.budgets?.maxTokens !== undefined ? { maxTokens: options.budgets.maxTokens } : {}),
+            ...(options.budgets?.maxTimeMs !== undefined ? { maxTimeMs: options.budgets.maxTimeMs } : {})
+        }
+    });
+    enforceBudget("maxTokens", options.budgets?.maxTokens, tokenized.tokens.length);
+    return tokenized.tokens.map((token) => toPublicToken(token));
+}
+export async function* tokenizeStream(stream, options = {}) {
+    const decoded = await decodeStreamToText(stream, options);
+    const tokens = tokenize(decoded.text, options);
+    for (const token of tokens) {
+        yield token;
+    }
+}
+export function parseBytes(bytes, options = {}) {
+    enforceBudget("maxInputBytes", options.budgets?.maxInputBytes, bytes.byteLength);
+    const decoded = decodeCssBytes(bytes, {
+        ...(options.transportEncodingLabel ? { transportEncodingLabel: options.transportEncodingLabel } : {})
+    });
+    const parsed = parse(decoded.text, options);
+    if (!parsed.trace) {
+        return parsed;
+    }
+    const withDecodeTrace = pushTrace([...parsed.trace], {
+        kind: "decode",
+        source: "sniff",
+        encoding: decoded.sniff.encoding,
+        sniffSource: decoded.sniff.source
+    }, options.budgets);
+    if (!withDecodeTrace) {
+        return parsed;
+    }
+    return {
+        ...parsed,
+        trace: withDecodeTrace
+    };
+}
+export async function parseStream(stream, options = {}) {
+    const budgets = options.budgets;
+    const decoded = await decodeStreamToText(stream, options);
+    const parsed = parse(decoded.text, options);
+    if (!parsed.trace) {
+        return parsed;
+    }
+    let trace = [...parsed.trace];
+    trace =
+        pushTrace(trace, {
+            kind: "decode",
+            source: "sniff",
+            encoding: decoded.sniff.encoding,
+            sniffSource: decoded.sniff.source
+        }, budgets) ?? trace;
+    trace =
+        pushTrace(trace, {
+            kind: "stream",
+            bytesRead: decoded.totalBytes
+        }, budgets) ?? trace;
+    trace =
+        pushBudgetTrace(trace, "maxBufferedBytes", budgets?.maxBufferedBytes, decoded.maxBufferedObserved, budgets) ?? trace;
+    return {
+        ...parsed,
+        trace
+    };
+}
+function nodeFromTree(treeOrNode) {
+    if (isStyleSheetTree(treeOrNode)) {
+        return treeOrNode.root;
+    }
+    if (isFragmentTree(treeOrNode)) {
+        return treeOrNode.root;
+    }
+    return treeOrNode;
+}
+export function serialize(treeOrNode) {
+    const node = nodeFromTree(treeOrNode);
+    const sanitized = sanitizeCssNode(node);
+    return serializeTreeNode(sanitized);
+}
+function walkNode(node, depth, visitor) {
+    visitor(node, depth);
+    for (const child of childNodes(node)) {
+        walkNode(child, depth + 1, visitor);
+    }
+}
+export function walk(tree, visitor) {
+    walkNode(tree.root, 0, visitor);
+}
+export function walkByType(tree, type, visitor) {
+    const normalizedType = type.toLowerCase();
+    walk(tree, (node, depth) => {
+        if (node.type.toLowerCase() === normalizedType) {
+            visitor(node, depth);
+        }
+    });
+}
+export function findById(tree, id) {
+    let matched = null;
+    walk(tree, (node) => {
+        if (matched === null && node.id === id) {
+            matched = node;
+        }
+    });
+    return matched;
+}
+export function* findAllByType(tree, type) {
+    const normalizedType = type.toLowerCase();
+    const found = [];
+    walk(tree, (node) => {
+        if (node.type.toLowerCase() === normalizedType) {
+            found.push(node);
+        }
+    });
+    for (const node of found) {
+        yield node;
+    }
+}
+export function outline(tree) {
+    const entries = [];
+    walk(tree, (node, depth) => {
+        if (node.type === "Rule" ||
+            node.type === "Atrule" ||
+            node.type === "Declaration" ||
+            node.type === "Selector") {
+            entries.push({
+                nodeId: node.id,
+                depth,
+                type: node.type,
+                text: serialize(node).slice(0, 200)
+            });
+        }
+    });
+    return {
+        entries
+    };
+}
+function countNodes(node) {
+    let total = 1;
+    for (const child of childNodes(node)) {
+        total += countNodes(child);
+    }
+    return total;
+}
+function topLevelNodes(tree) {
+    return tree.children.length > 0 ? tree.children : [tree.root];
+}
+export function chunk(tree, options = {}) {
+    const maxChars = options.maxChars ?? 8192;
+    const maxNodes = options.maxNodes ?? 256;
+    const maxBytes = options.maxBytes ?? Number.POSITIVE_INFINITY;
+    const encoder = new TextEncoder();
+    const chunks = [];
+    let activeContent = "";
+    let activeNodes = 0;
+    let activeBytes = 0;
+    let activeNodeId = null;
+    let index = 0;
+    const flush = () => {
+        if (activeNodeId === null) {
+            return;
+        }
+        chunks.push({
+            index,
+            nodeId: activeNodeId,
+            content: activeContent,
+            nodes: activeNodes
+        });
+        index += 1;
+        activeContent = "";
+        activeNodes = 0;
+        activeBytes = 0;
+        activeNodeId = null;
+    };
+    for (const node of topLevelNodes(tree)) {
+        const content = serialize(node);
+        const nodes = countNodes(node);
+        const bytes = encoder.encode(content).length;
+        const nextChars = activeContent.length + content.length;
+        const nextNodes = activeNodes + nodes;
+        const nextBytes = activeBytes + bytes;
+        if (activeNodeId !== null && (nextChars > maxChars || nextNodes > maxNodes || nextBytes > maxBytes)) {
+            flush();
+        }
+        if (activeNodeId === null) {
+            activeNodeId = node.id;
+        }
+        activeContent += content;
+        activeNodes += nodes;
+        activeBytes += bytes;
+    }
+    flush();
+    return chunks;
+}
+function indexNodeSpans(node, into) {
+    into.set(node.id, {
+        provenance: node.spanProvenance ?? "none",
+        ...(node.span ? { span: node.span } : {})
+    });
+    for (const child of childNodes(node)) {
+        indexNodeSpans(child, into);
+    }
+}
+function indexNodes(node, into) {
+    into.set(node.id, node);
+    for (const child of childNodes(node)) {
+        indexNodes(child, into);
+    }
+}
+function failPatchPlanning(payload) {
+    throw new PatchPlanningError(payload);
+}
+function requireNode(nodeById, target) {
+    const node = nodeById.get(target);
+    if (!node) {
+        failPatchPlanning({ code: "NODE_NOT_FOUND", target });
+    }
+    return node;
+}
+function requireNodeSpan(spanByNode, target) {
+    const indexedSpan = spanByNode.get(target);
+    if (!indexedSpan) {
+        failPatchPlanning({ code: "MISSING_NODE_SPAN", target });
+    }
+    if (indexedSpan.provenance !== "input") {
+        failPatchPlanning({ code: "NON_INPUT_SPAN_PROVENANCE", target, detail: indexedSpan.provenance });
+    }
+    if (!indexedSpan.span) {
+        failPatchPlanning({ code: "MISSING_NODE_SPAN", target });
+    }
+    return indexedSpan.span;
+}
+function buildReplacement(spanByNode, nodeById, edit, sourceIndex) {
+    if (edit.kind === "removeNode") {
+        const span = requireNodeSpan(spanByNode, edit.target);
+        return {
+            sourceIndex,
+            target: edit.target,
+            start: span.start,
+            end: span.end,
+            replacementCss: ""
+        };
+    }
+    if (edit.kind === "replaceNode") {
+        requireNode(nodeById, edit.target);
+        const span = requireNodeSpan(spanByNode, edit.target);
+        return {
+            sourceIndex,
+            target: edit.target,
+            start: span.start,
+            end: span.end,
+            replacementCss: edit.css
+        };
+    }
+    if (edit.kind === "insertCssBefore") {
+        requireNode(nodeById, edit.target);
+        const span = requireNodeSpan(spanByNode, edit.target);
+        return {
+            sourceIndex,
+            target: edit.target,
+            start: span.start,
+            end: span.start,
+            replacementCss: edit.css
+        };
+    }
+    requireNode(nodeById, edit.target);
+    const span = requireNodeSpan(spanByNode, edit.target);
+    return {
+        sourceIndex,
+        target: edit.target,
+        start: span.end,
+        end: span.end,
+        replacementCss: edit.css
+    };
+}
+export function applyPatchPlan(originalCss, plan) {
+    let cursor = 0;
+    let output = "";
+    for (const step of plan.steps) {
+        if (step.kind === "slice") {
+            if (step.start < cursor || step.end < step.start || step.end > originalCss.length) {
+                throw new Error("invalid patch slice bounds");
+            }
+            output += originalCss.slice(step.start, step.end);
+            cursor = step.end;
+            continue;
+        }
+        if (step.at !== cursor || step.at > originalCss.length) {
+            throw new Error("invalid patch insertion offset");
+        }
+        output += step.text;
+    }
+    return output;
+}
+export function computePatch(originalCss, edits) {
+    if (edits.length === 0) {
+        const steps = [
+            {
+                kind: "slice",
+                start: 0,
+                end: originalCss.length
+            }
+        ];
+        return {
+            steps,
+            result: originalCss
+        };
+    }
+    const parsed = parse(originalCss, { captureSpans: true });
+    const spanByNode = new Map();
+    const nodeById = new Map();
+    indexNodeSpans(parsed.root, spanByNode);
+    indexNodes(parsed.root, nodeById);
+    const replacements = edits.map((edit, sourceIndex) => buildReplacement(spanByNode, nodeById, edit, sourceIndex));
+    replacements.sort((left, right) => {
+        if (left.start !== right.start) {
+            return left.start - right.start;
+        }
+        if (left.end !== right.end) {
+            return left.end - right.end;
+        }
+        return left.sourceIndex - right.sourceIndex;
+    });
+    let previousEnd = 0;
+    for (const replacement of replacements) {
+        if (replacement.start < 0 ||
+            replacement.end < replacement.start ||
+            replacement.end > originalCss.length) {
+            failPatchPlanning({ code: "OVERLAPPING_EDITS", target: replacement.target, detail: "invalid replacement bounds" });
+        }
+        if (replacement.start < previousEnd) {
+            failPatchPlanning({ code: "OVERLAPPING_EDITS", target: replacement.target });
+        }
+        previousEnd = Math.max(previousEnd, replacement.end);
+    }
+    const steps = [];
+    let cursor = 0;
+    for (const replacement of replacements) {
+        if (cursor < replacement.start) {
+            steps.push({
+                kind: "slice",
+                start: cursor,
+                end: replacement.start
+            });
+        }
+        steps.push({
+            kind: "insert",
+            at: replacement.start,
+            text: replacement.replacementCss
+        });
+        cursor = replacement.end;
+    }
+    if (cursor < originalCss.length) {
+        steps.push({
+            kind: "slice",
+            start: cursor,
+            end: originalCss.length
+        });
+    }
+    const result = applyPatchPlan(originalCss, {
+        steps,
+        result: ""
+    });
+    return {
+        steps,
+        result
+    };
+}
+function isSelectorRecord(value) {
+    return value !== null && typeof value === "object";
+}
+function selectorNodeKind(node) {
+    if (typeof node.kind === "string") {
+        return node.kind.toLowerCase();
+    }
+    if (typeof node.type === "string") {
+        return node.type.toLowerCase();
+    }
+    return "";
+}
+function isSelectorElementNode(node) {
+    return selectorNodeKind(node) === "element";
+}
+function selectorChildrenFromNode(node) {
+    if (!Array.isArray(node.children)) {
+        return [];
+    }
+    const children = [];
+    for (const child of node.children) {
+        if (isSelectorRecord(child)) {
+            children.push(child);
+        }
+    }
+    return children;
+}
+function selectorTagName(node) {
+    if (!isSelectorElementNode(node) || typeof node.tagName !== "string") {
+        return null;
+    }
+    return node.tagName.toLowerCase();
+}
+function isAsciiWhitespaceCode(code) {
+    return code === 9 || code === 10 || code === 12 || code === 13 || code === 32;
+}
+function lowerAsciiCode(code) {
+    if (code >= 65 && code <= 90) {
+        return code + 32;
+    }
+    return code;
+}
+function equalsAsciiCaseInsensitive(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+        if (lowerAsciiCode(left.charCodeAt(index)) !== lowerAsciiCode(right.charCodeAt(index))) {
+            return false;
+        }
+    }
+    return true;
+}
+function includesWhitespaceSeparatedToken(input, expectedToken) {
+    let tokenStart = -1;
+    for (let index = 0; index <= input.length; index += 1) {
+        const code = index < input.length ? input.charCodeAt(index) : 32;
+        const atBoundary = index === input.length || isAsciiWhitespaceCode(code);
+        if (tokenStart === -1) {
+            if (!atBoundary) {
+                tokenStart = index;
+            }
+            continue;
+        }
+        if (!atBoundary) {
+            continue;
+        }
+        if (index - tokenStart === expectedToken.length && input.slice(tokenStart, index) === expectedToken) {
+            return true;
+        }
+        tokenStart = -1;
+    }
+    return false;
+}
+function selectorAttributeValue(node, name) {
+    if (!isSelectorElementNode(node) || !Array.isArray(node.attributes)) {
+        return null;
+    }
+    const target = name.toLowerCase();
+    for (const attribute of node.attributes) {
+        if (!isSelectorRecord(attribute)) {
+            continue;
+        }
+        if (typeof attribute.name !== "string" || typeof attribute.value !== "string") {
+            continue;
+        }
+        if (equalsAsciiCaseInsensitive(attribute.name, target)) {
+            return attribute.value;
+        }
+    }
+    return null;
+}
+function selectorAttributeMatch(actualValue, matcher, expectedValue, flags) {
+    if (actualValue === null) {
+        return false;
+    }
+    if (matcher === null) {
+        return true;
+    }
+    if (expectedValue === null) {
+        return false;
+    }
+    const caseInsensitive = (flags ?? "").toLowerCase().includes("i");
+    const left = caseInsensitive ? actualValue.toLowerCase() : actualValue;
+    const right = caseInsensitive ? expectedValue.toLowerCase() : expectedValue;
+    switch (matcher) {
+        case "=":
+            return left === right;
+        case "~=":
+            return includesWhitespaceSeparatedToken(left, right);
+        case "|=":
+            return left === right || left.startsWith(`${right}-`);
+        case "^=":
+            return left.startsWith(right);
+        case "$=":
+            return left.endsWith(right);
+        case "*=":
+            return left.includes(right);
+        default:
+            return false;
+    }
+}
+function matchesSelectorSimple(node, simple) {
+    if (!isSelectorElementNode(node)) {
+        return false;
+    }
+    if (simple.kind === "type") {
+        if (simple.universal) {
+            return true;
+        }
+        return selectorTagName(node) === simple.name.toLowerCase();
+    }
+    if (simple.kind === "id") {
+        return selectorAttributeValue(node, "id") === simple.value;
+    }
+    if (simple.kind === "class") {
+        const classes = selectorAttributeValue(node, "class");
+        if (classes === null) {
+            return false;
+        }
+        return includesWhitespaceSeparatedToken(classes, simple.value);
+    }
+    return selectorAttributeMatch(selectorAttributeValue(node, simple.name), simple.matcher, simple.value, simple.flags);
+}
+function matchesSelectorCompound(node, compound) {
+    if (compound.simpleSelectors.length === 0) {
+        return false;
+    }
+    for (const simple of compound.simpleSelectors) {
+        if (!matchesSelectorSimple(node, simple)) {
+            return false;
+        }
+    }
+    return true;
+}
+function buildSelectorTreeIndex(root, options) {
+    const parentByNode = new Map();
+    const elements = [];
+    const stack = [{ node: root, parent: null }];
+    let visited = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        if (parentByNode.has(current.node)) {
+            continue;
+        }
+        visited += 1;
+        if (options.maxVisitedNodes !== undefined && visited > options.maxVisitedNodes) {
+            throw new BudgetExceededError({
+                code: "BUDGET_EXCEEDED",
+                budget: "maxNodes",
+                limit: options.maxVisitedNodes,
+                actual: visited
+            });
+        }
+        parentByNode.set(current.node, current.parent);
+        if (isSelectorElementNode(current.node)) {
+            elements.push(current.node);
+        }
+        const children = selectorChildrenFromNode(current.node);
+        for (let index = children.length - 1; index >= 0; index -= 1) {
+            const child = children[index];
+            if (!child) {
+                continue;
+            }
+            stack.push({
+                node: child,
+                parent: current.node
+            });
+        }
+    }
+    return {
+        parentByNode,
+        elements
+    };
+}
+function matchesCompiledSelector(selector, node, treeIndex) {
+    if (!selector.supported || selector.compounds.length === 0) {
+        return false;
+    }
+    const matchAt = (compoundIndex, candidate) => {
+        const compound = selector.compounds[compoundIndex];
+        if (!compound) {
+            return false;
+        }
+        if (!matchesSelectorCompound(candidate, compound)) {
+            return false;
+        }
+        if (compoundIndex === 0) {
+            return true;
+        }
+        const combinator = selector.combinators[compoundIndex - 1];
+        if (combinator === ">") {
+            const parent = treeIndex.parentByNode.get(candidate) ?? null;
+            if (parent === null || !isSelectorElementNode(parent)) {
+                return false;
+            }
+            return matchAt(compoundIndex - 1, parent);
+        }
+        let parent = treeIndex.parentByNode.get(candidate) ?? null;
+        while (parent !== null) {
+            if (isSelectorElementNode(parent) && matchAt(compoundIndex - 1, parent)) {
+                return true;
+            }
+            parent = treeIndex.parentByNode.get(parent) ?? null;
+        }
+        return false;
+    };
+    return matchAt(selector.compounds.length - 1, node);
+}
+function matchesCompiledSelectorInTraversal(selector, frame) {
+    if (!selector.supported || selector.compounds.length === 0) {
+        return false;
+    }
+    const matchAt = (compoundIndex, candidate) => {
+        const compound = selector.compounds[compoundIndex];
+        if (!compound) {
+            return false;
+        }
+        if (!matchesSelectorCompound(candidate.node, compound)) {
+            return false;
+        }
+        if (compoundIndex === 0) {
+            return true;
+        }
+        const combinator = selector.combinators[compoundIndex - 1];
+        if (combinator === ">") {
+            const parent = candidate.parentElement;
+            if (!parent) {
+                return false;
+            }
+            return matchAt(compoundIndex - 1, parent);
+        }
+        let cursor = candidate.parentElement;
+        while (cursor) {
+            if (matchAt(compoundIndex - 1, cursor)) {
+                return true;
+            }
+            cursor = cursor.parentElement;
+        }
+        return false;
+    };
+    return matchAt(selector.compounds.length - 1, frame);
+}
+function assertSelectorStrict(compiled, strict) {
+    if (!strict) {
+        return;
+    }
+    if (compiled.parseErrors.length > 0) {
+        throw new Error(`selector parse failed in strict mode: ${compiled.parseErrors[0]?.message ?? "unknown error"}`);
+    }
+    if (compiled.unsupportedParts.length > 0) {
+        const sample = compiled.unsupportedParts[0];
+        throw new Error(`selector unsupported in strict mode: ${sample?.partType ?? "unknown"} ${sample?.detail ?? ""}`.trim());
+    }
+}
+function selectorSimpleFromNode(selectorNode, selectorIndex, unsupported) {
+    const type = typeof selectorNode.type === "string" ? selectorNode.type : "";
+    if (type === "TypeSelector") {
+        const rawName = typeof selectorNode.name === "string" ? selectorNode.name : "";
+        if (rawName.length === 0) {
+            unsupported.push({
+                selectorIndex,
+                partType: type,
+                detail: "missing type name"
+            });
+            return null;
+        }
+        return {
+            kind: "type",
+            name: rawName.toLowerCase(),
+            universal: rawName === "*"
+        };
+    }
+    if (type === "IdSelector") {
+        const value = typeof selectorNode.name === "string" ? selectorNode.name : "";
+        if (value.length === 0) {
+            unsupported.push({
+                selectorIndex,
+                partType: type,
+                detail: "missing id value"
+            });
+            return null;
+        }
+        return {
+            kind: "id",
+            value
+        };
+    }
+    if (type === "ClassSelector") {
+        const value = typeof selectorNode.name === "string" ? selectorNode.name : "";
+        if (value.length === 0) {
+            unsupported.push({
+                selectorIndex,
+                partType: type,
+                detail: "missing class value"
+            });
+            return null;
+        }
+        return {
+            kind: "class",
+            value
+        };
+    }
+    if (type === "AttributeSelector") {
+        const rawNameNode = isSelectorRecord(selectorNode.name) ? selectorNode.name : null;
+        const rawName = rawNameNode && typeof rawNameNode.name === "string" ? rawNameNode.name : "";
+        if (rawName.length === 0) {
+            unsupported.push({
+                selectorIndex,
+                partType: type,
+                detail: "missing attribute name"
+            });
+            return null;
+        }
+        const rawMatcher = selectorNode.matcher;
+        let matcher = null;
+        if (rawMatcher !== null && rawMatcher !== undefined) {
+            if (rawMatcher === "=" ||
+                rawMatcher === "~=" ||
+                rawMatcher === "|=" ||
+                rawMatcher === "^=" ||
+                rawMatcher === "$=" ||
+                rawMatcher === "*=") {
+                matcher = rawMatcher;
+            }
+            else {
+                const rawMatcherDetail = typeof rawMatcher === "string" ? rawMatcher : typeof rawMatcher;
+                unsupported.push({
+                    selectorIndex,
+                    partType: type,
+                    detail: `unsupported matcher ${rawMatcherDetail}`
+                });
+                return null;
+            }
+        }
+        const rawValueNode = isSelectorRecord(selectorNode.value) ? selectorNode.value : null;
+        const value = rawValueNode
+            ? (typeof rawValueNode.value === "string"
+                ? rawValueNode.value
+                : (typeof rawValueNode.name === "string" ? rawValueNode.name : null))
+            : null;
+        const flags = typeof selectorNode.flags === "string" ? selectorNode.flags : null;
+        return {
+            kind: "attribute",
+            name: rawName.toLowerCase(),
+            matcher,
+            value,
+            flags
+        };
+    }
+    unsupported.push({
+        selectorIndex,
+        partType: type.length > 0 ? type : "unknown",
+        detail: "unsupported simple selector"
+    });
+    return null;
+}
+function normalizeSelectorCombinator(rawName, selectorIndex, unsupported) {
+    const combinatorName = typeof rawName === "string" ? rawName : "";
+    const trimmed = combinatorName.trim();
+    if (trimmed === ">") {
+        return ">";
+    }
+    if (trimmed.length === 0) {
+        return " ";
+    }
+    unsupported.push({
+        selectorIndex,
+        partType: "Combinator",
+        detail: `unsupported combinator ${trimmed}`
+    });
+    return " ";
+}
+function compileSingleSelector(selectorNode, selectorIndex) {
+    const unsupported = [];
+    const compounds = [];
+    const combinators = [];
+    let currentSimpleSelectors = [];
+    const children = Array.isArray(selectorNode.children) ? selectorNode.children : [];
+    for (const child of children) {
+        if (!isSelectorRecord(child)) {
+            continue;
+        }
+        const childType = typeof child.type === "string" ? child.type : "";
+        if (childType === "Combinator") {
+            if (currentSimpleSelectors.length === 0) {
+                unsupported.push({
+                    selectorIndex,
+                    partType: "Combinator",
+                    detail: "combinator without left compound"
+                });
+                continue;
+            }
+            compounds.push({
+                simpleSelectors: currentSimpleSelectors
+            });
+            combinators.push(normalizeSelectorCombinator(child.name, selectorIndex, unsupported));
+            currentSimpleSelectors = [];
+            continue;
+        }
+        const simple = selectorSimpleFromNode(child, selectorIndex, unsupported);
+        if (simple) {
+            currentSimpleSelectors.push(simple);
+        }
+    }
+    if (currentSimpleSelectors.length > 0) {
+        compounds.push({
+            simpleSelectors: currentSimpleSelectors
+        });
+    }
+    else if (combinators.length > 0) {
+        unsupported.push({
+            selectorIndex,
+            partType: "Combinator",
+            detail: "selector ends with combinator"
+        });
+    }
+    if (compounds.length === 0) {
+        unsupported.push({
+            selectorIndex,
+            partType: "Selector",
+            detail: "empty selector"
+        });
+    }
+    if (compounds.length > 0 && combinators.length !== compounds.length - 1) {
+        unsupported.push({
+            selectorIndex,
+            partType: "Selector",
+            detail: "invalid combinator count"
+        });
+    }
+    return {
+        selectorIndex,
+        compounds,
+        combinators,
+        supported: unsupported.length === 0,
+        unsupportedParts: unsupported
+    };
+}
+export function compileSelectorList(selectorText) {
+    const parsed = parseFragment(selectorText, "selectorList");
+    const selectorNodes = Array.isArray(parsed.root.children)
+        ? parsed.root.children.filter((child) => isSelectorRecord(child) && child.type === "Selector")
+        : [];
+    const selectors = selectorNodes.map((selectorNode, selectorIndex) => compileSingleSelector(selectorNode, selectorIndex));
+    const unsupportedParts = selectors.flatMap((selector) => selector.unsupportedParts);
+    const supported = parsed.errors.length === 0 && selectors.length > 0 && unsupportedParts.length === 0;
+    return {
+        source: selectorText,
+        parseErrors: parsed.errors,
+        selectors,
+        supported,
+        unsupportedParts
+    };
+}
+function compareSpecificity(left, right) {
+    if (left.a !== right.a) {
+        return left.a - right.a;
+    }
+    if (left.b !== right.b) {
+        return left.b - right.b;
+    }
+    return left.c - right.c;
+}
+function specificityForSimple(simple) {
+    switch (simple.kind) {
+        case "id":
+            return { a: 1, b: 0, c: 0 };
+        case "class":
+        case "attribute":
+            return { a: 0, b: 1, c: 0 };
+        case "type":
+            return { a: 0, b: 0, c: simple.universal ? 0 : 1 };
+        default:
+            return { a: 0, b: 0, c: 0 };
+    }
+}
+function specificityForCompiledSelector(selector) {
+    let a = 0;
+    let b = 0;
+    let c = 0;
+    for (const compound of selector.compounds) {
+        for (const simple of compound.simpleSelectors) {
+            const specificity = specificityForSimple(simple);
+            a += specificity.a;
+            b += specificity.b;
+            c += specificity.c;
+        }
+    }
+    return { a, b, c };
+}
+function specificityMaxForSelectorList(selectorList) {
+    let best = { a: 0, b: 0, c: 0 };
+    for (const selector of selectorList.selectors) {
+        const current = specificityForCompiledSelector(selector);
+        if (compareSpecificity(current, best) > 0) {
+            best = current;
+        }
+    }
+    return best;
+}
+function declarationSignalFromNode(node, declarationOrder) {
+    if (node.type !== "Declaration") {
+        return null;
+    }
+    const propertyRaw = typeof node["property"] === "string" ? node["property"] : "";
+    const property = propertyRaw.trim().toLowerCase();
+    if (property.length === 0) {
+        return null;
+    }
+    const valueNode = isPublicNode(node["value"]) ? node["value"] : null;
+    const value = valueNode ? serialize(valueNode).trim() : "";
+    const important = node["important"] === true;
+    return {
+        declarationNodeId: node.id,
+        property,
+        value,
+        important,
+        declarationOrder
+    };
+}
+function declarationSignalsFromContainer(container) {
+    const signals = [];
+    let declarationOrder = 0;
+    for (const child of childNodes(container)) {
+        const declaration = declarationSignalFromNode(child, declarationOrder);
+        if (!declaration) {
+            continue;
+        }
+        signals.push(declaration);
+        declarationOrder += 1;
+    }
+    return signals;
+}
+function normalizeDeclarationValueForRenderSignals(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function classifyRenderSignalClass(declaration, options) {
+    const includeControlAffordance = options.includeControlAffordance !== false;
+    const includeVisibilitySignals = options.includeVisibilitySignals !== false;
+    const property = declaration.property.toLowerCase();
+    const normalizedValue = normalizeDeclarationValueForRenderSignals(declaration.value);
+    if (includeVisibilitySignals) {
+        if (property === "display" && normalizedValue === "none") {
+            return "visibility-hidden-subtree";
+        }
+        if (property === "visibility" && (normalizedValue === "hidden" || normalizedValue === "collapse")) {
+            return "visibility-hidden-subtree";
+        }
+        if (property === "content-visibility" && normalizedValue === "hidden") {
+            return "visibility-hidden-subtree";
+        }
+        if (property === "opacity" && normalizedValue === "0") {
+            return "visibility-hidden-self";
+        }
+        if (property === "font-size" && normalizedValue === "0") {
+            return "visibility-hidden-self";
+        }
+    }
+    if (includeControlAffordance) {
+        if (property === "cursor" && normalizedValue === "pointer") {
+            return "control-affordance";
+        }
+        if (property === "appearance" && normalizedValue.includes("button")) {
+            return "control-affordance";
+        }
+        if (property === "user-select" && normalizedValue === "none") {
+            return "control-affordance";
+        }
+        if (property === "pointer-events" && normalizedValue === "none") {
+            return "control-affordance";
+        }
+    }
+    return null;
+}
+export function extractStyleRuleSignals(cssOrTree, options = {}) {
+    const includeUnsupportedSelectors = options.includeUnsupportedSelectors === true;
+    const strictSelectors = options.strictSelectors === true;
+    const tree = typeof cssOrTree === "string" ? parse(cssOrTree) : cssOrTree;
+    const signals = [];
+    let cascadeOrder = 0;
+    walk(tree, (node) => {
+        if (node.type !== "Rule") {
+            return;
+        }
+        const ruleOrder = cascadeOrder;
+        cascadeOrder += 1;
+        const preludeNode = isPublicNode(node["prelude"]) ? node["prelude"] : null;
+        const blockNode = isPublicNode(node["block"]) ? node["block"] : null;
+        if (!preludeNode || !blockNode) {
+            return;
+        }
+        const selectorText = serialize(preludeNode).trim();
+        if (selectorText.length === 0) {
+            return;
+        }
+        const selector = compileSelectorList(selectorText);
+        if (strictSelectors && !selector.supported) {
+            const unsupported = selector.unsupportedParts[0];
+            const detail = unsupported
+                ? `${unsupported.partType} ${unsupported.detail}`.trim()
+                : "unknown selector unsupported part";
+            throw new Error(`unsupported selector in strict mode: ${detail}`);
+        }
+        if (!includeUnsupportedSelectors && !selector.supported) {
+            return;
+        }
+        signals.push({
+            ruleNodeId: node.id,
+            selectorText,
+            selector,
+            selectorSupported: selector.supported,
+            specificityMax: specificityMaxForSelectorList(selector),
+            cascadeOrder: ruleOrder,
+            declarations: declarationSignalsFromContainer(blockNode)
+        });
+    });
+    return signals;
+}
+export function extractInlineStyleSignals(styleText) {
+    const fragment = parseDeclarationList(styleText);
+    const signals = [];
+    let declarationOrder = 0;
+    for (const node of fragment.children) {
+        const declaration = declarationSignalFromNode(node, declarationOrder);
+        if (!declaration) {
+            continue;
+        }
+        signals.push(declaration);
+        declarationOrder += 1;
+    }
+    return signals;
+}
+export function extractRenderSignals(cssOrTree, options = {}) {
+    const ruleSignals = extractStyleRuleSignals(cssOrTree, options);
+    const renderSignals = [];
+    for (const ruleSignal of ruleSignals) {
+        for (const declaration of ruleSignal.declarations) {
+            const signalClass = classifyRenderSignalClass(declaration, options);
+            if (!signalClass) {
+                continue;
+            }
+            renderSignals.push({
+                signalClass,
+                source: "rule",
+                property: declaration.property,
+                value: declaration.value,
+                important: declaration.important,
+                declarationOrder: declaration.declarationOrder,
+                selectorText: ruleSignal.selectorText,
+                declarationNodeId: declaration.declarationNodeId,
+                ruleNodeId: ruleSignal.ruleNodeId,
+                cascadeOrder: ruleSignal.cascadeOrder
+            });
+        }
+    }
+    return renderSignals;
+}
+export function extractInlineRenderSignals(styleText, options = {}) {
+    const declarations = extractInlineStyleSignals(styleText);
+    const renderSignals = [];
+    for (const declaration of declarations) {
+        const signalClass = classifyRenderSignalClass(declaration, options);
+        if (!signalClass) {
+            continue;
+        }
+        renderSignals.push({
+            signalClass,
+            source: "inline",
+            property: declaration.property,
+            value: declaration.value,
+            important: declaration.important,
+            declarationOrder: declaration.declarationOrder,
+            selectorText: null,
+            declarationNodeId: declaration.declarationNodeId,
+            ruleNodeId: null,
+            cascadeOrder: null
+        });
+    }
+    return renderSignals;
+}
+const MAX_SELECTOR_COMPILE_CACHE_SIZE = 256;
+const selectorCompileCache = new Map();
+function resolveCompiledSelectorList(selector) {
+    if (typeof selector !== "string") {
+        return selector;
+    }
+    const cached = selectorCompileCache.get(selector);
+    if (cached) {
+        selectorCompileCache.delete(selector);
+        selectorCompileCache.set(selector, cached);
+        return cached;
+    }
+    const compiled = compileSelectorList(selector);
+    selectorCompileCache.set(selector, compiled);
+    if (selectorCompileCache.size > MAX_SELECTOR_COMPILE_CACHE_SIZE) {
+        const oldestKey = selectorCompileCache.keys().next().value;
+        if (typeof oldestKey === "string") {
+            selectorCompileCache.delete(oldestKey);
+        }
+    }
+    return compiled;
+}
+export function matchesSelector(selector, node, root, options = {}) {
+    const compiled = resolveCompiledSelectorList(selector);
+    assertSelectorStrict(compiled, options.strict === true);
+    const treeIndex = buildSelectorTreeIndex(root, options);
+    if (!treeIndex.parentByNode.has(node)) {
+        return false;
+    }
+    if (!isSelectorElementNode(node)) {
+        return false;
+    }
+    for (const selectorEntry of compiled.selectors) {
+        if (matchesCompiledSelector(selectorEntry, node, treeIndex)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function querySelectorAll(selector, root, options = {}) {
+    const compiled = resolveCompiledSelectorList(selector);
+    assertSelectorStrict(compiled, options.strict === true);
+    const matches = [];
+    const seen = new Set();
+    const stack = [
+        {
+            node: root,
+            parent: null,
+            parentElement: null
+        }
+    ];
+    let visited = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current) {
+            continue;
+        }
+        if (seen.has(current.node)) {
+            continue;
+        }
+        seen.add(current.node);
+        visited += 1;
+        if (options.maxVisitedNodes !== undefined && visited > options.maxVisitedNodes) {
+            throw new BudgetExceededError({
+                code: "BUDGET_EXCEEDED",
+                budget: "maxNodes",
+                limit: options.maxVisitedNodes,
+                actual: visited
+            });
+        }
+        const currentIsElement = isSelectorElementNode(current.node);
+        if (currentIsElement) {
+            for (const selectorEntry of compiled.selectors) {
+                if (matchesCompiledSelectorInTraversal(selectorEntry, current)) {
+                    matches.push(current.node);
+                    break;
+                }
+            }
+        }
+        const children = selectorChildrenFromNode(current.node);
+        const parentElement = currentIsElement ? current : current.parentElement;
+        for (let index = children.length - 1; index >= 0; index -= 1) {
+            const child = children[index];
+            if (!child) {
+                continue;
+            }
+            stack.push({
+                node: child,
+                parent: current,
+                parentElement
+            });
+        }
+    }
+    return matches;
+}