@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/token-dark-mode.d.ts

@@ -1,64 +0,0 @@
-/**
- * Dark-mode insertion helpers for the tokens CSS scaffold.
- *
- * `fireforge token add --mode override --dark-value ...` must land the dark
- * declaration inside the nested `:root { }` of the
- * `@media (prefers-color-scheme: dark)` block. Landing after that block has
- * closed produces a declaration outside any rule. The helpers here scan the
- * comment-stripped source lines to find the *inner* `:root` block's closing
- * `}` and return a line index the caller can splice into. When the inner
- * `:root` is missing (a scaffold that drifted from the default), the
- * fallback helper returns the outer `@media` block's close so the caller can
- * materialise a fresh `:root` wrapper rather than dropping the dark value.
- */
-/**
- * Strips the content of `/* ... *\/` block comments from an array of
- * CSS source lines while preserving each line's length. Indexed scans
- * over the returned mirror line up with the original, so callers that
- * compute an insertion index against the stripped array can splice
- * into the original array at the same index.
- *
- * We blank the comment body with spaces (rather than removing it) so
- * any downstream consumer that indexes by column (or derives an
- * insertion index as a line number in the original array) still
- * agrees on line numbers.
- *
- * Spans are copied with `indexOf` + `slice` rather than appended one
- * character at a time. The per-character form allocated a rope link per
- * character of every line in `tokens.css`, which on a long line cost far
- * more than the scan it feeds: blanking a 1.6 MB line took ~39 ms against
- * ~0.07 ms here, and the GC that pressure provoked grew faster than the
- * input did — enough to make the scanners' linearity test read as
- * super-linear on a loaded runner.
- */
-export declare function stripBlockCommentsInLines(lines: string[]): string[];
-/**
- * Finds the closing `}` line of the nested `:root { ... }` block inside
- * a `@media (prefers-color-scheme: dark)` block. Returns `-1` when the
- * media block exists but the nested `:root` block is missing. Returns
- * `null` when the `@media` block itself is absent.
- *
- * Runs the scan over a comment-stripped mirror of the source lines so
- * braces inside CSS comments (`/* before { after *\/`) do not offset
- * the depth counter. The scan is line-indexed so callers
- * can splice into the original `lines` array at the returned index.
- */
-export declare function findDarkRootInsertionIndex(lines: string[]): number | null;
-/**
- * Depth-counts braces from `startLine` (whose lines must already have
- * block comments stripped), returning the index of the line on which the
- * block opened there returns to its entry depth, i.e. the line carrying
- * the block's closing `}`, or -1 when the block never closes. The first
- * `{` encountered sets the entry depth, so the scan may start on the
- * selector/at-rule line itself rather than on the opener.
- */
-export declare function findBlockCloseIndex(stripped: string[], startLine: number): number;
-/**
- * Finds the closing `}` of the outermost
- * `@media (prefers-color-scheme: dark)` block. Used as the fallback
- * landing site when the scaffold has no nested `:root { }`. The
- * insertion helper uses this index to splice a brand-new `:root`
- * wrapper containing the dark declaration, rather than dropping the
- * value.
- */
-export declare function findDarkMediaCloseIndex(lines: string[]): number;

package/dist/src/core/token-dark-mode.js

@@ -1,186 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Dark-mode insertion helpers for the tokens CSS scaffold.
- *
- * `fireforge token add --mode override --dark-value ...` must land the dark
- * declaration inside the nested `:root { }` of the
- * `@media (prefers-color-scheme: dark)` block. Landing after that block has
- * closed produces a declaration outside any rule. The helpers here scan the
- * comment-stripped source lines to find the *inner* `:root` block's closing
- * `}` and return a line index the caller can splice into. When the inner
- * `:root` is missing (a scaffold that drifted from the default), the
- * fallback helper returns the outer `@media` block's close so the caller can
- * materialise a fresh `:root` wrapper rather than dropping the dark value.
- */
-/**
- * True when `line` carries a `:root` selector whose opening brace is on the
- * same line, with no intervening brace of either kind.
- *
- * Index arithmetic rather than `/:root[^{}]*\{/`: that pattern restarts at
- * every `:root` in the line, which is quadratic on a line repeating the
- * selector (CodeQL `js/polynomial-redos`). `tokens.css` comes from a
- * consumer's engine tree, so such a line needs no attacker to arrive.
- */
-function rootOpensBraceOnLine(line) {
-    const brace = line.indexOf('{');
-    if (brace === -1)
-        return false;
-    const root = line.lastIndexOf(':root', brace - ':root'.length);
-    if (root === -1 || root + ':root'.length > brace)
-        return false;
-    return !line.slice(root + ':root'.length, brace).includes('}');
-}
-/**
- * Strips the content of `/* ... *\/` block comments from an array of
- * CSS source lines while preserving each line's length. Indexed scans
- * over the returned mirror line up with the original, so callers that
- * compute an insertion index against the stripped array can splice
- * into the original array at the same index.
- *
- * We blank the comment body with spaces (rather than removing it) so
- * any downstream consumer that indexes by column (or derives an
- * insertion index as a line number in the original array) still
- * agrees on line numbers.
- *
- * Spans are copied with `indexOf` + `slice` rather than appended one
- * character at a time. The per-character form allocated a rope link per
- * character of every line in `tokens.css`, which on a long line cost far
- * more than the scan it feeds: blanking a 1.6 MB line took ~39 ms against
- * ~0.07 ms here, and the GC that pressure provoked grew faster than the
- * input did — enough to make the scanners' linearity test read as
- * super-linear on a loaded runner.
- */
-export function stripBlockCommentsInLines(lines) {
-    const out = [];
-    let inBlockComment = false;
-    for (const original of lines) {
-        // A line with no comment to enter or leave is already its own mirror.
-        if (!inBlockComment && !original.includes('/*')) {
-            out.push(original);
-            continue;
-        }
-        let line = '';
-        let i = 0;
-        while (i < original.length) {
-            if (inBlockComment) {
-                const end = original.indexOf('*/', i);
-                if (end === -1) {
-                    line += ' '.repeat(original.length - i);
-                    break;
-                }
-                line += ' '.repeat(end + 2 - i);
-                i = end + 2;
-                inBlockComment = false;
-            }
-            else {
-                const start = original.indexOf('/*', i);
-                if (start === -1) {
-                    line += original.slice(i);
-                    break;
-                }
-                line += `${original.slice(i, start)}  `;
-                i = start + 2;
-                inBlockComment = true;
-            }
-        }
-        out.push(line);
-    }
-    return out;
-}
-/**
- * Finds the closing `}` line of the nested `:root { ... }` block inside
- * a `@media (prefers-color-scheme: dark)` block. Returns `-1` when the
- * media block exists but the nested `:root` block is missing. Returns
- * `null` when the `@media` block itself is absent.
- *
- * Runs the scan over a comment-stripped mirror of the source lines so
- * braces inside CSS comments (`/* before { after *\/`) do not offset
- * the depth counter. The scan is line-indexed so callers
- * can splice into the original `lines` array at the returned index.
- */
-export function findDarkRootInsertionIndex(lines) {
-    const stripped = stripBlockCommentsInLines(lines);
-    const darkMediaLine = stripped.findIndex((line) => /prefers-color-scheme:\s*dark/.test(line));
-    if (darkMediaLine === -1)
-        return null;
-    // Walk the comment-stripped lines after the @media header and find
-    // the first `:root {` opener inside the block. The opening brace of
-    // the selector may live on the same line as the selector name or on
-    // the following line. Either shape is tolerated.
-    let rootOpenLine = -1;
-    for (let i = darkMediaLine; i < stripped.length; i++) {
-        const line = stripped[i] ?? '';
-        if (/(?:^|[\s,{]):root\b/.test(line)) {
-            // Brace on the same line?
-            if (rootOpensBraceOnLine(line)) {
-                rootOpenLine = i;
-                break;
-            }
-            // Otherwise scan forward for the opening brace, stopping at the
-            // first `}` or second selector that would mean the `:root`
-            // declaration never opened a block.
-            for (let j = i + 1; j < stripped.length; j++) {
-                const next = stripped[j] ?? '';
-                if (/\{/.test(next)) {
-                    rootOpenLine = j;
-                    break;
-                }
-                if (/[};]/.test(next))
-                    break;
-            }
-            if (rootOpenLine !== -1)
-                break;
-        }
-    }
-    if (rootOpenLine === -1)
-        return -1;
-    // Depth-count starting from the `:root` opener. See findBlockCloseIndex.
-    return findBlockCloseIndex(stripped, rootOpenLine);
-}
-/**
- * Depth-counts braces from `startLine` (whose lines must already have
- * block comments stripped), returning the index of the line on which the
- * block opened there returns to its entry depth, i.e. the line carrying
- * the block's closing `}`, or -1 when the block never closes. The first
- * `{` encountered sets the entry depth, so the scan may start on the
- * selector/at-rule line itself rather than on the opener.
- */
-export function findBlockCloseIndex(stripped, startLine) {
-    let depth = 0;
-    let entryDepth = 0;
-    let enteredBlock = false;
-    for (let i = startLine; i < stripped.length; i++) {
-        const line = stripped[i] ?? '';
-        for (const ch of line) {
-            if (ch === '{') {
-                depth++;
-                if (!enteredBlock) {
-                    entryDepth = depth - 1;
-                    enteredBlock = true;
-                }
-            }
-            else if (ch === '}') {
-                depth--;
-            }
-        }
-        if (enteredBlock && depth === entryDepth) {
-            return i;
-        }
-    }
-    return -1;
-}
-/**
- * Finds the closing `}` of the outermost
- * `@media (prefers-color-scheme: dark)` block. Used as the fallback
- * landing site when the scaffold has no nested `:root { }`. The
- * insertion helper uses this index to splice a brand-new `:root`
- * wrapper containing the dark declaration, rather than dropping the
- * value.
- */
-export function findDarkMediaCloseIndex(lines) {
-    const stripped = stripBlockCommentsInLines(lines);
-    const darkMediaLine = stripped.findIndex((line) => /prefers-color-scheme:\s*dark/.test(line));
-    if (darkMediaLine === -1)
-        return -1;
-    return findBlockCloseIndex(stripped, darkMediaLine);
-}

package/dist/src/core/token-docs.d.ts

@@ -1,34 +0,0 @@
-/**
- * Documentation-table updates for `fireforge token add`. Extracted from
- * `token-manager.ts` so the CSS-mutation path and the Markdown-table path
- * each stay within the per-file line budget. Consumed only by token-manager.
- */
-/**
- * Minimal token shape the docs updater needs. Declared locally (rather than
- * importing `AddTokenOptions`) so this module has no edge back to
- * `token-manager.ts`. `AddTokenOptions` is structurally compatible.
- */
-export interface TokenDocInput {
-    tokenName: string;
-    value: string;
-    category: string;
-    mode: string;
-    description?: string | undefined;
-}
-/**
- * Adds a token row to the main token table, the unmapped table (for
- * literal values), and bumps the mode count table. Each sub-update runs
- * against a freshly parsed view of the document so that splice indices
- * stay valid as rewrites are layered.
- *
- * @param engineDir - Absolute path to the engine checkout
- * @param options - Token name, category and description to document
- * @param annotation - The mode annotation string the caller already computed
- *   (kept here as a parameter so this module needs no dependency on
- *   token-manager's `getModeAnnotation`).
- */
-export declare function addTokenToDocs(engineDir: string, options: TokenDocInput, annotation: string): Promise<{
-    docsAdded: boolean;
-    unmappedAdded: boolean;
-    countUpdated: boolean;
-}>;

package/dist/src/core/token-docs.js

@@ -1,102 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Documentation-table updates for `fireforge token add`. Extracted from
- * `token-manager.ts` so the CSS-mutation path and the Markdown-table path
- * each stay within the per-file line budget. Consumed only by token-manager.
- */
-import { join } from 'node:path';
-import { pathExists, readText, writeText } from '../utils/fs.js';
-import { findTableAfterHeading, findTableByColumns, insertRow, rewriteTableRows, updateCellByKey, } from './markdown-table.js';
-const TOKENS_DOC = 'docs/design/SRC_TOKENS.md';
-/**
- * Strips surrounding backticks from a cell, if present. Token cells are
- * usually wrapped in inline code fences (`` `--foo` ``) and the parser
- * returns them verbatim.
- */
-function stripInlineCode(cell) {
-    const trimmed = cell.trim();
-    if (trimmed.startsWith('`') && trimmed.endsWith('`') && trimmed.length >= 2) {
-        return trimmed.slice(1, -1);
-    }
-    return trimmed;
-}
-/**
- * Adds a token row to the main token table, the unmapped table (for
- * literal values), and bumps the mode count table. Each sub-update runs
- * against a freshly parsed view of the document so that splice indices
- * stay valid as rewrites are layered.
- *
- * @param engineDir - Absolute path to the engine checkout
- * @param options - Token name, category and description to document
- * @param annotation - The mode annotation string the caller already computed
- *   (kept here as a parameter so this module needs no dependency on
- *   token-manager's `getModeAnnotation`).
- */
-export async function addTokenToDocs(engineDir, options, annotation) {
-    const filePath = join(engineDir, '..', TOKENS_DOC);
-    if (!(await pathExists(filePath))) {
-        // Docs file is optional
-        return { docsAdded: false, unmappedAdded: false, countUpdated: false };
-    }
-    const originalContent = await readText(filePath);
-    let lines = originalContent.split('\n');
-    let docsAdded = false;
-    let unmappedAdded = false;
-    let countUpdated = false;
-    const isLiteral = !options.value.startsWith('var(');
-    const mapsTo = isLiteral ? '—' : options.value.replace(/^var\(([^)]+)\)/, '$1');
-    const tokenCell = `\`${options.tokenName}\``;
-    const valueCell = `\`${options.value}\``;
-    // --- Main token table: Category | Token | Value | Maps to | Mode ---
-    const mainTable = findTableByColumns(lines, ['Category', 'Token', 'Value', 'Mode']);
-    if (mainTable) {
-        // The doc convention allows the Category cell to be blank on
-        // continuation rows that belong to the previous category. Group rows
-        // by carrying the last non-empty Category value forward.
-        let lastGroupRowIndex = -1;
-        let currentCategory = '';
-        for (let i = 0; i < mainTable.rows.length; i++) {
-            const row = mainTable.rows[i];
-            if (!row)
-                continue;
-            const cell = row[0]?.trim() ?? '';
-            if (cell) {
-                currentCategory = cell;
-            }
-            if (currentCategory === options.category) {
-                lastGroupRowIndex = i;
-            }
-        }
-        if (lastGroupRowIndex !== -1) {
-            insertRow(mainTable, ['', tokenCell, valueCell, mapsTo, annotation], lastGroupRowIndex + 1);
-            lines = rewriteTableRows(lines, mainTable);
-            docsAdded = true;
-        }
-    }
-    // --- Unmapped table: populated for literal (non-var()) values only ---
-    if (isLiteral) {
-        const unmappedTable = findTableAfterHeading(lines, /not yet mapped|unmapped/i);
-        if (unmappedTable) {
-            insertRow(unmappedTable, [tokenCell, valueCell, options.description ?? ''], unmappedTable.rows.length);
-            lines = rewriteTableRows(lines, unmappedTable);
-            unmappedAdded = true;
-        }
-    }
-    // --- Mode behavior count table: Mode | Count ---
-    const modeTable = findTableByColumns(lines, ['Mode', 'Count']);
-    if (modeTable) {
-        const modeIndex = modeTable.headers.indexOf('Mode');
-        const countIndex = modeTable.headers.indexOf('Count');
-        const existing = modeTable.rows.find((row) => stripInlineCode(row[modeIndex] ?? '') === options.mode);
-        if (existing) {
-            const oldCount = parseInt(existing[countIndex] ?? '0', 10);
-            const updated = updateCellByKey(modeTable, 'Mode', existing[modeIndex] ?? options.mode, 'Count', String((Number.isNaN(oldCount) ? 0 : oldCount) + 1));
-            if (updated) {
-                lines = rewriteTableRows(lines, modeTable);
-                countUpdated = true;
-            }
-        }
-    }
-    await writeText(filePath, lines.join('\n'));
-    return { docsAdded, unmappedAdded, countUpdated };
-}

package/dist/src/core/token-inventory.d.ts

@@ -1,56 +0,0 @@
-/** One token declaration inside the base `:root` block. */
-export interface TokenInventoryEntry {
-    /** Custom-property name, including the leading `--`. */
-    name: string;
-    /** 1-based line number in the tokens CSS file. */
-    line: number;
-    /** Declared value, trimmed, without the trailing `;`. */
-    value: string;
-}
-/**
- * Tokens grouped under the banner that precedes them, in file order.
- * `category` is null for declarations that sit above the first banner.
- * That is a real state in a hand-edited file, and one the report must show
- * rather than silently drop.
- */
-export interface TokenCategoryInventory {
-    category: string | null;
-    tokens: TokenInventoryEntry[];
-}
-/** One block that declares a given token, with the value it declares. */
-export interface TokenBlockValue {
-    /**
-     * Selector trail of the declaring block, outermost first, joined with
-     * ` > `. For example `:root` or
-     * `@media (prefers-color-scheme: dark) > :root`.
-     */
-    block: string;
-    value: string;
-    /** 1-based line number of the declaration. */
-    line: number;
-}
-/**
- * Collects every base-`:root` token declaration grouped by the category
- * banner above it, in document order.
- *
- * Only the base block is walked: the dark `@media` and `:root[variant]`
- * companions mirror declarations rather than owning them, so listing them
- * would report the same token two or three times under no category at all.
- *
- * @param lines - Tokens CSS split into lines
- * @returns Categories in file order, each with its tokens in file order
- */
-export declare function collectTokenInventory(lines: string[]): TokenCategoryInventory[];
-/**
- * Every declaration of `tokenName`, in every block of the file, labelled by
- * the selector trail of the block that declares it.
- *
- * Not restricted to the base `:root`: the question `token show`
- * answers is "what does this token resolve to", and a token whose dark
- * override differs from its base value is the case worth seeing.
- *
- * @param lines - Tokens CSS split into lines
- * @param tokenName - Custom-property name including the leading `--`
- * @returns Declarations in file order
- */
-export declare function collectTokenBlockValues(lines: string[], tokenName: string): TokenBlockValue[];

package/dist/src/core/token-inventory.js

@@ -1,114 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Read-only inventory of the tokens CSS file: which categories exist, which
- * tokens each declares, and what a single token resolves to in every theme
- * block that mentions it.
- *
- * `token add` requires `--category`, so it needs a report of the categories
- * a project actually has; without one, the only way to name one correctly
- * is to hand-parse a neighbouring `= Category =` banner out of the file.
- * This module is that report. It reuses the banner and
- * category-region model from `token-category.ts` rather than parsing
- * tokens CSS a second way: two readers that disagree on what a banner is
- * would put `token list` and `token add` in different sections of the same
- * file.
- */
-import { findBaseRootBounds, maskCommentLines, parseTokenCategorySections, } from './token-category.js';
-/** Matches a custom-property declaration and captures its name and value. */
-const DECLARATION_PATTERN = /^\s*(--[A-Za-z0-9_-]+)\s*:\s*([^;]*);?/;
-/**
- * Collects every base-`:root` token declaration grouped by the category
- * banner above it, in document order.
- *
- * Only the base block is walked: the dark `@media` and `:root[variant]`
- * companions mirror declarations rather than owning them, so listing them
- * would report the same token two or three times under no category at all.
- *
- * @param lines - Tokens CSS split into lines
- * @returns Categories in file order, each with its tokens in file order
- */
-export function collectTokenInventory(lines) {
-    const bounds = findBaseRootBounds(lines);
-    if (bounds === undefined || bounds.close === -1)
-        return [];
-    const masked = maskCommentLines(lines);
-    const sections = parseTokenCategorySections(lines);
-    const headers = new Map(sections.map((section) => [section.categoryLine, section]));
-    const groups = [];
-    let current;
-    let sectionEnd = bounds.close;
-    for (let i = bounds.open + 1; i < bounds.close; i++) {
-        if (i >= sectionEnd)
-            current = undefined;
-        const section = headers.get(i);
-        if (section !== undefined) {
-            current = { category: section.name, tokens: [] };
-            sectionEnd = section.sectionEnd;
-            groups.push(current);
-            continue;
-        }
-        const match = DECLARATION_PATTERN.exec(masked[i] ?? '');
-        if (!match?.[1])
-            continue;
-        if (current === undefined) {
-            current = { category: null, tokens: [] };
-            sectionEnd = bounds.close;
-            groups.push(current);
-        }
-        current.tokens.push({ name: match[1], line: i + 1, value: (match[2] ?? '').trim() });
-    }
-    // A banner with no declarations under it is still a category `token add
-    // --category` accepts, so empty groups are kept.
-    return groups;
-}
-/**
- * Every declaration of `tokenName`, in every block of the file, labelled by
- * the selector trail of the block that declares it.
- *
- * Not restricted to the base `:root`: the question `token show`
- * answers is "what does this token resolve to", and a token whose dark
- * override differs from its base value is the case worth seeing.
- *
- * @param lines - Tokens CSS split into lines
- * @param tokenName - Custom-property name including the leading `--`
- * @returns Declarations in file order
- */
-export function collectTokenBlockValues(lines, tokenName) {
-    const masked = maskCommentLines(lines);
-    const trail = [];
-    const found = [];
-    for (let i = 0; i < masked.length; i++) {
-        const line = masked[i] ?? '';
-        const match = DECLARATION_PATTERN.exec(line);
-        if (match?.[1] === tokenName) {
-            found.push({
-                block: trail.length > 0 ? trail.join(' > ') : '(file scope)',
-                value: (match[2] ?? '').trim(),
-                line: i + 1,
-            });
-        }
-        // Brace tracking after the declaration test, so a one-line block cannot
-        // swallow the declaration it opens on. Selector text is whatever
-        // precedes the `{`. An empty selector (a continuation line) still
-        // needs a stack entry or the closing `}` pops the wrong one.
-        for (const char of line) {
-            if (char === '{') {
-                trail.push(selectorBefore(line, trail.length));
-            }
-            else if (char === '}') {
-                trail.pop();
-            }
-        }
-    }
-    return found;
-}
-/**
- * Selector text introducing the `depth`-th open brace on `line`. Falls back
- * to a positional label so the trail stays well-formed on a minified or
- * continuation line that opens a block with no visible selector.
- */
-function selectorBefore(line, depth) {
-    const open = line.indexOf('{');
-    const text = open === -1 ? '' : line.slice(0, open).trim();
-    return text.length > 0 ? text : `(block ${String(depth + 1)})`;
-}

package/dist/src/core/token-lint.d.ts

@@ -1,53 +0,0 @@
-/**
- * `fireforge token lint`: structural checks over the design-token system.
- *
- * - `token-lockstep`: a themed override block (the dark `@media` mirror, a
- *   `:root[variant]` block) declares only tokens the base `:root` declares.
- *   An override with no base is a token that exists only in one theme, so
- *   every other theme resolves it to nothing.
- * - `token-undeclared`: a `var(--<prefix>…)` reference in the tokens CSS or
- *   in a CSS file the patch queue touches names a token no block of the
- *   tokens CSS declares. Same-file declarations, declarations of a sheet
- *   that loads beside it (see `token-sibling-sheets.ts`), `furnace.json`
- *   `tokenAllowlist` and `runtimeVariables` are exempt, matching the
- *   `token-prefix-violation` rule's notion of a runtime channel. A
- *   reference with a fallback (`var(--x, 0)`) is optional by construction
- *   (a host hook, a channel set from JS) and is not reported.
- *
- * Built on `token-category.ts`'s base-block and comment-mask primitives, so
- * this report and `token add` agree on which block is the base.
- */
-/** One `token lint` finding. */
-export interface TokenLintFinding {
-    check: 'token-lockstep' | 'token-undeclared';
-    /** Engine-relative file. */
-    file: string;
-    /** 1-based line. */
-    line: number;
-    /** The custom property at fault. */
-    token: string;
-    message: string;
-}
-/** Every custom property the tokens CSS declares, in any block. */
-export declare function collectDeclaredTokenNames(lines: string[]): Set<string>;
-/**
- * Themed override declarations of `tokenPrefix` tokens that the base
- * `:root` block does not declare.
- *
- * @param lines - Tokens CSS split into lines
- * @param tokensCssPath - Engine-relative path, for the findings
- * @param tokenPrefix - Only tokens with this prefix are held to lockstep;
- *   a themed block may still override platform properties
- */
-export declare function lintTokenLockstep(lines: string[], tokensCssPath: string, tokenPrefix: string): TokenLintFinding[];
-/**
- * `var(--<prefix>…)` references naming a token the tokens CSS never
- * declares.
- *
- * @param file - Engine-relative path, for the findings
- * @param css - The file's content
- * @param tokenPrefix - Only references with this prefix are checked
- * @param declared - {@link collectDeclaredTokenNames} of the tokens CSS
- * @param exempt - `tokenAllowlist` and `runtimeVariables` names
- */
-export declare function lintUndeclaredTokenReferences(file: string, css: string, tokenPrefix: string, declared: ReadonlySet<string>, exempt: ReadonlySet<string>): TokenLintFinding[];