@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/source/tree.js

@@ -0,0 +1,337 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Reading a checkout's source: the owned files and override records as they
+ * are in the working tree (tracked files and untracked files git does not
+ * ignore, under the source and metadata roots), judged against the pristine
+ * repository. Every command that reads owned changes starts here; nothing is
+ * captured or retained, so two clean checkouts of one commit read the same.
+ *
+ * The result is the set of owned entries plus every problem found. A
+ * blocking problem leaves a path's owned content undefined (a link, a case
+ * collision, an unreadable record), so its path is not an entry and
+ * materialization and export refuse; the other problems (an undeclared
+ * edit, a stale record) are reported by `status` and `verify` while the
+ * entry still has a definite meaning.
+ */
+import { basename, join, relative } from 'node:path';
+import { checkAttributes, listFiles, listTree, status } from '../git/index.js';
+import { ExitCode, FireForgeError, toError } from '../kernel/errors.js';
+import { pathInfo, toPosixPath } from '../kernel/fs.js';
+import { readJsonIfExists } from '../kernel/json.js';
+import { mapLimit } from '../kernel/time.js';
+import { ancestorsOf, compareText, defaultComponent, enginePathProblem, foldCase, overrideRecordSchema, unownableReason, } from './records.js';
+const BLOCKING = new Set([
+    'unmerged',
+    'tombstone-has-file',
+    'case-collision',
+    'unsupported-kind',
+    'path-conflict',
+    'invalid-path',
+    'invalid-record',
+]);
+/** Files read at once. */
+const READ_CONCURRENCY = 32;
+/** Files operating systems and editors drop beside source; ignoring them loses nothing. */
+const DISPOSABLE = /^(?:\.DS_Store|Thumbs\.db|desktop\.ini|\._.*|\..*\.swp|.*~)$/;
+/** Attributes that make git commit other bytes than the working tree holds. */
+const FILTERING_ATTRIBUTES = ['text', 'eol', 'filter', 'ident', 'working-tree-encoding'];
+/** Files at the top of the source root that configure git for it, not the engine. */
+const SOURCE_CONTROL_FILES = new Set(['.gitattributes', '.gitignore']);
+function problem(kind, path, message, hint) {
+    return { kind, path, message, hint, blocking: BLOCKING.has(kind) };
+}
+/**
+ * Where the project's source lives in its git checkout.
+ *
+ * @param project - A source-mode project
+ * @throws `source-not-in-git` (exit code 4) when the project is not in a git checkout
+ */
+export function layoutOf(project) {
+    const worktree = project.checkout.worktree;
+    if (worktree === undefined) {
+        throw new FireForgeError('source-not-in-git', `${project.root} is not in a git checkout; source mode keeps owned files as tracked files.`, { exitCode: ExitCode.GIT_ERROR, hint: 'Run "git init" in the project.' });
+    }
+    const prefix = toPosixPath(relative(worktree, project.root));
+    const inside = (directory) => prefix === '' ? directory : `${prefix}/${directory}`;
+    return {
+        worktree,
+        source: inside(project.config.source.root),
+        metadata: inside(project.config.source.metadataRoot),
+    };
+}
+/** The worktree-relative file of an override record. */
+export function recordFile(layout, path) {
+    return `${layout.metadata}/overrides/${path}.json`;
+}
+function isUnmerged(entry) {
+    const pair = `${entry.index}${entry.worktree}`;
+    return pair.includes('U') || pair === 'AA' || pair === 'DD';
+}
+/** Lists the source and metadata roots: tracked and untracked files, ignored ones reported. */
+async function listRoots(layout, projectPrefix) {
+    const scope = [layout.source, layout.metadata];
+    const [tracked, changes, ignored] = await Promise.all([
+        listFiles(layout.worktree, { paths: scope }),
+        status(layout.worktree, { paths: scope }),
+        listFiles(layout.worktree, { which: 'ignored', paths: scope }),
+    ]);
+    const problems = [];
+    for (const path of ignored) {
+        if (DISPOSABLE.test(basename(path)))
+            continue;
+        problems.push(problem('ignored', projectPrefix(path), 'is ignored by git, so it is not owned and a commit would not hold it', 'Correct .gitignore, or delete the file.'));
+    }
+    const files = new Set(tracked);
+    const sources = new Map();
+    const records = new Map();
+    const sourcePrefix = `${layout.source}/`;
+    const overridesPrefix = `${layout.metadata}/overrides/`;
+    // The engine path of an owned file or record, so a problem with it removes that path's entry.
+    const enginePathOf = (file) => file.startsWith(sourcePrefix)
+        ? file.slice(sourcePrefix.length)
+        : file.startsWith(overridesPrefix) && file.endsWith('.json')
+            ? file.slice(overridesPrefix.length, -'.json'.length)
+            : projectPrefix(file);
+    for (const entry of changes) {
+        if (entry.index === '?')
+            files.add(entry.path);
+        if (isUnmerged(entry)) {
+            problems.push(problem('unmerged', enginePathOf(entry.path), 'has an unresolved merge conflict', 'Resolve it and "git add" the file.'));
+        }
+    }
+    for (const file of [...files].sort(compareText)) {
+        if (file.startsWith(sourcePrefix)) {
+            const path = file.slice(sourcePrefix.length);
+            if (!SOURCE_CONTROL_FILES.has(path))
+                sources.set(path, file);
+        }
+        else if (file.startsWith(overridesPrefix)) {
+            const name = file.slice(overridesPrefix.length);
+            if (name.endsWith('.json'))
+                records.set(name.slice(0, -'.json'.length), file);
+            else {
+                problems.push(problem('invalid-record', projectPrefix(file), 'is not an override record (records end in .json)', 'Move it out of the overrides directory.'));
+            }
+        }
+    }
+    return { sources, records, problems };
+}
+async function readRecord(layout, file) {
+    try {
+        return await readJsonIfExists(join(layout.worktree, file), overrideRecordSchema);
+    }
+    catch (error) {
+        return { error: toError(error).message };
+    }
+}
+/** Reads the owned files' kinds and modes and parses every record. */
+async function readInventory(layout, listing, problems) {
+    const files = new Map();
+    const records = new Map();
+    const blocked = new Set();
+    const block = (entry) => {
+        problems.push(entry);
+        blocked.add(entry.path);
+    };
+    await mapLimit([...listing.sources], READ_CONCURRENCY, async ([path, file]) => {
+        const pathError = enginePathProblem(path) ?? unownableReason(path);
+        if (pathError !== undefined) {
+            block(problem('invalid-path', path, pathError, 'Rename or remove the file.'));
+            return;
+        }
+        const absolute = join(layout.worktree, file);
+        const info = await pathInfo(absolute);
+        if (info === undefined)
+            return;
+        if (info.kind !== 'file') {
+            block(problem('unsupported-kind', path, `is a ${info.kind === 'directory' ? 'submodule or directory' : info.kind}; only regular files can be owned`, 'Replace it with a regular file, or remove it.'));
+            return;
+        }
+        const mode = (info.mode & 0o111) !== 0 ? '100755' : '100644';
+        files.set(path, {
+            absolute,
+            mode,
+            size: info.size,
+            mtimeMs: info.mtimeMs,
+            ctimeMs: info.ctimeMs,
+            ino: info.ino,
+        });
+    });
+    await mapLimit([...listing.records], READ_CONCURRENCY, async ([path, file]) => {
+        const pathError = enginePathProblem(path) ?? unownableReason(path);
+        const record = pathError === undefined
+            ? await readRecord(layout, file)
+            : { error: `names an engine path that ${pathError}` };
+        if (record === undefined)
+            return;
+        if ('error' in record) {
+            block(problem('invalid-record', path, record.error, `Correct or remove ${file}.`));
+            return;
+        }
+        records.set(path, record);
+    });
+    const folded = new Map();
+    for (const path of [...new Set([...files.keys(), ...records.keys()])].sort(compareText)) {
+        const key = foldCase(path);
+        const other = folded.get(key);
+        if (other !== undefined && other !== path) {
+            for (const each of [other, path]) {
+                block(problem('case-collision', each, `collides with ${each === path ? other : path} on a case-insensitive file system`, 'Rename one of them.'));
+            }
+        }
+        else
+            folded.set(key, path);
+    }
+    return { files, records, blocked };
+}
+/** The pristine entries of the given paths and their ancestors. */
+async function pristineEntries(pristine, paths) {
+    const wanted = new Set(paths);
+    for (const path of paths)
+        for (const ancestor of ancestorsOf(path))
+            wanted.add(ancestor);
+    if (wanted.size === 0)
+        return new Map();
+    const entries = await listTree(pristine.repo, pristine.commit, {
+        paths: [...wanted],
+        recursive: false,
+    });
+    return new Map(entries.map((entry) => [entry.path, entry]));
+}
+function regularMode(entry) {
+    return entry?.type === 'blob' && (entry.mode === '100644' || entry.mode === '100755')
+        ? entry.mode
+        : undefined;
+}
+/** One path's entry and problems, from its owned file, its record and its pristine entry. */
+function judgePath(path, inventory, upstreamOf, pristine) {
+    const file = inventory.files.get(path);
+    const record = inventory.records.get(path);
+    const found = upstreamOf(path);
+    const mode = regularMode(found);
+    const upstream = found !== undefined && mode !== undefined ? { blob: found.oid, mode } : undefined;
+    const component = record?.component ?? defaultComponent(path);
+    if (found !== undefined && upstream === undefined) {
+        const what = found.type === 'tree' ? 'a directory' : `an entry of mode ${found.mode}`;
+        return {
+            problems: [
+                problem(found.type === 'tree' ? 'path-conflict' : 'unsupported-kind', path, `is ${what} upstream; only regular upstream files can be overridden`, 'Move the owned file or record elsewhere.'),
+            ],
+        };
+    }
+    if (record === undefined) {
+        if (file === undefined)
+            return { problems: [] };
+        if (upstream !== undefined) {
+            return {
+                entry: { path, kind: 'modify', component, upstream, file },
+                problems: [
+                    problem('undeclared', path, 'exists upstream but has no override record', `Move the file aside, run "fireforge override ${path}", then reapply the edit.`),
+                ],
+            };
+        }
+        const blocker = ancestorsOf(path).find((ancestor) => upstreamOf(ancestor)?.type === 'blob' && inventory.records.get(ancestor)?.kind !== 'delete');
+        if (blocker !== undefined) {
+            return {
+                problems: [
+                    problem('path-conflict', path, `cannot be created: upstream has a file at ${blocker}`, `Move the file, or delete ${blocker} with "fireforge override --delete ${blocker}".`),
+                ],
+            };
+        }
+        return { entry: { path, kind: 'create', component, file }, problems: [] };
+    }
+    const problems = [];
+    if (upstream === undefined) {
+        problems.push(problem('stale', path, 'has an override record but is no longer upstream', file === undefined
+            ? `Remove the record with "fireforge restore ${path}".`
+            : `Delete its override record to keep the owned file as a created file, or drop both with "fireforge restore ${path}".`));
+        return file === undefined
+            ? { problems }
+            : { entry: { path, kind: 'create', component, file }, problems };
+    }
+    if (record.base.commit !== pristine.commit ||
+        record.base.blob !== upstream.blob ||
+        record.base.mode !== upstream.mode) {
+        problems.push(problem('stale', path, 'has an override record whose base is not the pinned upstream file', 'Move the project to its pin with "fireforge rebase", which merges and updates records.'));
+    }
+    if (record.kind === 'delete') {
+        if (file !== undefined) {
+            return {
+                problems: [
+                    ...problems,
+                    problem('tombstone-has-file', path, 'is deleted by its record but has an owned file', 'Delete the owned file to keep the deletion, or set the record\'s "kind" to "override".'),
+                ],
+            };
+        }
+        return { entry: { path, kind: 'delete', component, record, upstream }, problems };
+    }
+    if (file === undefined) {
+        problems.push(problem('orphaned', path, 'has an override record but no owned file', `Restore the file, or remove the record with "fireforge restore ${path}".`));
+        return { problems };
+    }
+    return { entry: { path, kind: 'modify', component, record, upstream, file }, problems };
+}
+/** ADR files records name that do not exist. */
+async function missingAdrs(project, records) {
+    const found = [];
+    for (const [path, record] of records) {
+        if (record.adr === undefined)
+            continue;
+        if ((await pathInfo(join(project.root, record.adr)))?.kind === 'file')
+            continue;
+        found.push(problem('adr-missing', path, `names the decision record ${record.adr}, which does not exist`, 'Add the decision record, or correct "adr" in the override record.'));
+    }
+    return found;
+}
+/** Owned files whose committed bytes git attributes could change. */
+async function filteredFiles(layout, entries) {
+    const byFile = new Map(entries.flatMap((entry) => entry.file === undefined ? [] : [[`${layout.source}/${entry.path}`, entry.path]]));
+    const attributes = await checkAttributes(layout.worktree, [...byFile.keys()], FILTERING_ATTRIBUTES);
+    const specified = (value) => value !== undefined && value !== 'unspecified' && value !== 'unset';
+    const found = [];
+    for (const [file, row] of attributes) {
+        const text = row['text'];
+        const filtered = text === 'set' ||
+            text === 'auto' ||
+            (text === 'unspecified' && specified(row['eol'])) ||
+            ['filter', 'ident', 'working-tree-encoding'].some((name) => specified(row[name]));
+        if (!filtered)
+            continue;
+        found.push(problem('filtered', byFile.get(file) ?? file, 'has git attributes that could change its bytes when committed', `Add "* -text" to ${layout.source}/.gitattributes.`));
+    }
+    return found;
+}
+/**
+ * Reads the checkout's owned files and override records and judges them
+ * against the pristine repository.
+ *
+ * @param project - A source-mode project
+ * @param pristine - The pinned pristine repository
+ */
+export async function readSourceTree(project, pristine) {
+    const layout = layoutOf(project);
+    const rootPrefix = toPosixPath(relative(layout.worktree, project.root));
+    const projectPath = (path) => rootPrefix === '' ? path : path.slice(rootPrefix.length + 1);
+    const listing = await listRoots(layout, projectPath);
+    const problems = [...listing.problems];
+    const inventory = await readInventory(layout, listing, problems);
+    for (const each of listing.problems)
+        if (each.blocking)
+            inventory.blocked.add(each.path);
+    const paths = [...new Set([...inventory.files.keys(), ...inventory.records.keys()])]
+        .filter((path) => !inventory.blocked.has(path))
+        .sort(compareText);
+    const upstream = await pristineEntries(pristine, paths);
+    const entries = [];
+    for (const path of paths) {
+        const judged = judgePath(path, inventory, (each) => upstream.get(each), pristine);
+        problems.push(...judged.problems);
+        if (judged.entry !== undefined && !judged.problems.some((each) => each.blocking)) {
+            entries.push(judged.entry);
+        }
+    }
+    problems.push(...(await missingAdrs(project, inventory.records)));
+    problems.push(...(await filteredFiles(layout, entries)));
+    problems.sort((a, b) => compareText(a.path, b.path) || compareText(a.kind, b.kind));
+    return { project, pristine, layout, entries, problems };
+}

package/dist/src/syntax/css.js

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * CSS: a stylesheet read just far enough to judge and edit it. The rule
+ * blocks (with their selectors and positions), the comments, the property
+ * declarations, `var()` references and raw colours in values. Comments and
+ * string contents never count as structure. Lines and columns are
+ * zero-based. The text is never regenerated: edits splice lines.
+ */
+function blank(text) {
+    return text.replace(/[^\n]/g, ' ');
+}
+/**
+ * Blanks comments and string contents, remembering where the comments
+ * were. A linear scan; an unclosed `/*` runs to the end of the text.
+ */
+function mask(text) {
+    const parts = [];
+    const plain = [];
+    const comments = [];
+    let copied = 0;
+    let plainCopied = 0;
+    let i = 0;
+    while (i < text.length) {
+        const char = text.charAt(i);
+        if (char === '/' && text.charAt(i + 1) === '*') {
+            const close = text.indexOf('*/', i + 2);
+            const end = close === -1 ? text.length : close + 2;
+            parts.push(text.slice(copied, i), blank(text.slice(i, end)));
+            plain.push(text.slice(plainCopied, i), blank(text.slice(i, end)));
+            comments.push({ start: i, end });
+            copied = plainCopied = i = end;
+        }
+        else if (char === '"' || char === "'") {
+            let end = i + 1;
+            while (end < text.length && text.charAt(end) !== char && text.charAt(end) !== '\n') {
+                end += text.charAt(end) === '\\' ? 2 : 1;
+            }
+            if (text.charAt(end) === char) {
+                parts.push(text.slice(copied, i + 1), blank(text.slice(i + 1, end)));
+                copied = end;
+                i = end + 1;
+            }
+            else {
+                i++;
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    parts.push(text.slice(copied));
+    plain.push(text.slice(plainCopied));
+    return { code: parts.join(''), plain: plain.join(''), comments };
+}
+/**
+ * Blanks block comments with spaces, keeping newlines and offsets. A `/*`
+ * inside a string is not a comment; an unclosed one runs to the end.
+ *
+ * @param text - Stylesheet text
+ */
+export function blankCssComments(text) {
+    return mask(text).plain;
+}
+const DECLARATION = /^\s*(--[\w-]+|-?[a-zA-Z][\w-]*)\s*:/;
+/**
+ * Parses a stylesheet. Never throws: a block that never closes has `close`
+ * -1, and text it does not understand is skipped. A statement inside a block
+ * ended by `;` or `}` is a declaration; one ended by `{` is a selector or
+ * an at-rule prelude, so `a:hover { … }` is never read as a declaration.
+ *
+ * @param text - CSS text
+ */
+export function parseCss(text) {
+    const { code, plain, comments: spans } = mask(text);
+    const starts = [0];
+    for (let i = text.indexOf('\n'); i !== -1; i = text.indexOf('\n', i + 1))
+        starts.push(i + 1);
+    const lineOf = (offset) => {
+        let low = 0;
+        let high = starts.length - 1;
+        while (low < high) {
+            const mid = (low + high + 1) >> 1;
+            if ((starts[mid] ?? 0) <= offset)
+                low = mid;
+            else
+                high = mid - 1;
+        }
+        return low;
+    };
+    const column = (offset) => offset - (starts[lineOf(offset)] ?? 0);
+    const blocks = [];
+    const declarations = [];
+    const stack = [];
+    let statement = 0;
+    let parens = 0;
+    const flush = (end) => {
+        const found = DECLARATION.exec(code.slice(statement, end));
+        const block = stack.at(-1);
+        if (found === null || block === undefined)
+            return;
+        const name = found[1] ?? '';
+        const valueStart = statement + found[0].length;
+        declarations.push({
+            name,
+            value: plain.slice(valueStart, end).trim(),
+            line: lineOf(statement + found[0].indexOf(name)),
+            block,
+            valueStart,
+            valueEnd: end,
+        });
+    };
+    for (let i = 0; i < code.length; i++) {
+        const char = code.charAt(i);
+        if (char === '(')
+            parens++;
+        else if (char === ')')
+            parens = Math.max(0, parens - 1);
+        else if (parens > 0)
+            continue;
+        else if (char === '{') {
+            const block = {
+                selector: plain.slice(statement, i).replace(/\s+/g, ' ').trim(),
+                open: lineOf(i),
+                openCol: column(i),
+                close: -1,
+                closeCol: -1,
+                parent: stack.at(-1),
+            };
+            blocks.push(block);
+            stack.push(block);
+            statement = i + 1;
+        }
+        else if (char === ';') {
+            flush(i);
+            statement = i + 1;
+        }
+        else if (char === '}') {
+            flush(i);
+            const block = stack.pop();
+            if (block !== undefined) {
+                block.close = lineOf(i);
+                block.closeCol = column(i);
+            }
+            statement = i + 1;
+        }
+    }
+    return {
+        lines: text.split('\n'),
+        code: code.split('\n'),
+        blocks,
+        declarations,
+        comments: spans.map((span) => ({
+            text: text.slice(span.start + 2, Math.max(span.start + 2, span.end - 2)),
+            start: lineOf(span.start),
+            end: lineOf(span.end - 1),
+        })),
+        lineOf,
+    };
+}
+/**
+ * The custom-property declarations of a stylesheet (`--name: value`).
+ *
+ * @param sheet - A parsed stylesheet
+ */
+export function customProperties(sheet) {
+    return sheet.declarations.filter((declaration) => declaration.name.startsWith('--'));
+}
+/**
+ * The `var()` references of a stylesheet, outside comments and strings.
+ *
+ * @param sheet - A parsed stylesheet
+ */
+export function cssVarReferences(sheet) {
+    const found = [];
+    for (const [line, text] of sheet.code.entries()) {
+        for (const match of text.matchAll(/var\(\s*(--[\w-]+)\s*(,)?/g)) {
+            found.push({ name: match[1] ?? '', line, fallback: match[2] !== undefined });
+        }
+    }
+    return found;
+}
+/**
+ * The `var()` references to custom properties that are not design tokens:
+ * not under `prefix`, not `accepted` by exact name, and not declared in the
+ * stylesheet itself. Every occurrence, in file order.
+ *
+ * @param sheet - A parsed stylesheet
+ * @param prefix - The token prefix, such as `--brand-`
+ * @param accepted - Further names accepted by exact name
+ */
+export function foreignVariables(sheet, prefix, accepted) {
+    const declared = new Set(customProperties(sheet).map((declaration) => declaration.name));
+    return cssVarReferences(sheet).filter(({ name }) => !name.startsWith(prefix) && !accepted.has(name) && !declared.has(name));
+}
+const RAW_COLOR = /(?<![\w-])#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{3,4})(?![\w-])|\b(?:rgba?|hsla?)\s*\(/g;
+/**
+ * The raw colours (hex, `rgb()`, `hsl()`) written in declaration values. A
+ * `#` in a selector (`#add-button`), a string, a comment or a `url()` is
+ * not a colour.
+ *
+ * @param sheet - A parsed stylesheet
+ */
+export function rawColors(sheet) {
+    const code = sheet.code.join('\n');
+    const found = [];
+    for (const declaration of sheet.declarations) {
+        const value = code
+            .slice(declaration.valueStart, declaration.valueEnd)
+            .replace(/\burl\([^)]*\)/gi, (url) => blank(url));
+        for (const match of value.matchAll(RAW_COLOR)) {
+            found.push({ line: sheet.lineOf(declaration.valueStart + match.index), text: match[0] });
+        }
+    }
+    return found;
+}

package/dist/src/syntax/fragments.js

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Shared CSS fragment markers. A component stylesheet names a fragment of
+ * shared rules with a directive on its own line; its deployed copy has the
+ * fragment inlined after the directive and fenced by a matching end line:
+ *
+ *     /* @fireforge-include base-button.css *\/
+ *     ...the fragment's text...
+ *     /* @fireforge-end-include base-button.css *\/
+ */
+const INCLUDE = /^\s*\/\*\s*@fireforge-include\s+([\w./-]+)\s*\*\/\s*$/;
+const END = /^\s*\/\*\s*@fireforge-end-include\s+([\w./-]+)\s*\*\/\s*$/;
+/**
+ * The fragment a line includes, or undefined when it is no include directive.
+ *
+ * @param line - One line of a stylesheet
+ */
+export function fragmentInclude(line) {
+    return INCLUDE.exec(line)?.[1];
+}
+/**
+ * The end marker of a fragment.
+ *
+ * @param name - The fragment
+ */
+export function fragmentEnd(name) {
+    return `/* @fireforge-end-include ${name} */`;
+}
+/**
+ * The fenced expansions of a stylesheet's lines: each directive and the
+ * line of its matching end marker. A directive without one is not fenced.
+ *
+ * @param lines - The stylesheet's lines
+ * @returns Zero-based `[directive, end]` line pairs, in order
+ */
+export function fragmentExpansions(lines) {
+    const fenced = [];
+    for (let index = 0; index < lines.length; index++) {
+        const name = fragmentInclude(lines[index] ?? '');
+        if (name === undefined)
+            continue;
+        const end = lines.findIndex((line, at) => at > index && END.exec(line)?.[1] === name);
+        if (end === -1)
+            continue;
+        fenced.push([index, end]);
+        index = end;
+    }
+    return fenced;
+}
+/**
+ * The fragment names a stylesheet includes, in order, each once.
+ *
+ * @param css - Stylesheet text
+ */
+export function fragmentIncludes(css) {
+    const names = [];
+    for (const line of css.split('\n')) {
+        const name = fragmentInclude(line);
+        if (name !== undefined && !names.includes(name))
+            names.push(name);
+    }
+    return names;
+}

package/dist/src/syntax/index.js

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * The languages the fork's files are written in, parsed once for every
+ * module that reads them: JavaScript through acorn, CSS (comments,
+ * declarations, `var()` references, raw colours), the shared-fragment
+ * markers of component stylesheets.
+ */
+export { blankCssComments, cssVarReferences, customProperties, foreignVariables, parseCss, rawColors, } from './css.js';
+export { fragmentEnd, fragmentExpansions, fragmentInclude, fragmentIncludes } from './fragments.js';
+export { blankJsComments, blankJsCommentsParsed, importSpecifiers, isStringLiteral, jsTokens, lineAt, lineIndent, lineStart, parseEither, parseJs, relativeImportLines, walkJs, } from './js.js';