@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.10

package/dist/src/discover.js

@@ -1,468 +0,0 @@
-import { DiagnosticCategory } from "@typescript/native/sync";
-import { baseUrlPaths } from "./base-url.js";
-import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
-import { SetupError } from "./setup-failure.js";
-import { writtenPath } from "./workspace-programs.js";
-/** Directory names discovery does not descend into. */
-export const IGNORED_DIRECTORIES = new Set(["node_modules", ".git"]);
-/** A compiler configuration file discovery recognises under a root. */
-const CONFIG_FILE = /^tsconfig.*\.json$/u;
-/**
- * A run that cannot read what it was asked to analyze. It ends the run with the
- * failure code and no finding list: a configuration file the compiler cannot read,
- * or a project carrying an error, leaves the analysis without the type information
- * every answer rests on, and a partial answer is never printed as a complete one.
- */
-export class DiscoveryError extends Error {
-    /** The diagnostics the compiler reported, in the order it reported them. */
-    diagnostics;
-    constructor(message, diagnostics) {
-        super(message);
-        this.name = "DiscoveryError";
-        this.diagnostics = diagnostics;
-    }
-}
-/** The category an error diagnostic carries, which the protocol sends as a number. */
-const ERROR_CATEGORY = DiagnosticCategory.Error;
-/** Whether one diagnostic is an error, which is what fails a run closed. */
-function isError(diagnostic) {
-    return diagnostic.category === ERROR_CATEGORY;
-}
-/**
- * One diagnostic as a line naming its file, its line and column, its code and its
- * message: `path:line:column: TScode: message`, the position left out where the
- * diagnostic names none and the file where it names none. `display` spells the
- * file's path; it answers the path itself where it is not given.
- */
-export function renderDiagnostic(located, display = (path) => path) {
-    const { diagnostic, at } = located;
-    const message = `TS${String(diagnostic.code)}: ${diagnostic.text}`;
-    if (diagnostic.fileName === undefined) {
-        return message;
-    }
-    const where = display(diagnostic.fileName);
-    return at === undefined
-        ? `${where}: ${message}`
-        : `${where}:${String(at.line)}:${String(at.column)}: ${message}`;
-}
-/** Each diagnostic with the line and column its offset falls on. */
-function locatedIn(diagnostics, locate) {
-    return diagnostics.map((diagnostic) => ({
-        diagnostic,
-        at: diagnostic.fileName === undefined ? undefined : locate(diagnostic.fileName, diagnostic.pos),
-    }));
-}
-/**
- * Every error a project's three diagnostic sets carry, in the order the compiler
- * reported them: a configuration whose options do not parse, a file whose syntax
- * does not, and a program that does not type-check. A resolved configuration
- * carries no diagnostics of its own, so a configuration written with an unreadable
- * option resolves and is refused here, once its project is open.
- */
-export function diagnosticErrors(sets) {
-    return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
-}
-/**
- * The codes of a type library and a lib the configuration names that the compiler
- * cannot find, which it reports while it gathers the program's files,
- * https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/compiler/processingDiagnostic.go,
- * and {@link MISSING_GLOBAL_TYPE}, which the checker reports.
- */
-const UNFOUND_LIBRARY = new Set([2318, 2688, 2726, 2727]);
-/**
- * The code of a global type the checker finds in no library the program holds. The checker
- * types every use of one against nothing and places no error in the file, so the analysis
- * skips each file of such a project whole.
- */
-export const MISSING_GLOBAL_TYPE = 2318;
-/** The errors one open project carries, each located in the file it names. */
-export function projectErrors(sets) {
-    // The compiler numbers its semantic messages from 2000 and its option messages from
-    // 5000. A file-less option error, a removed option or an output layout, leaves the
-    // program whole, and the compiler checks it all the same:
-    // https://github.com/microsoft/TypeScript/wiki/Coding-guidelines#diagnostic-message-codes
-    const semantic = sets.unplaced.filter((diagnostic) => isError(diagnostic) && diagnostic.code >= 2000 && diagnostic.code < 3000);
-    const unfound = semantic.filter(({ code }) => UNFOUND_LIBRARY.has(code));
-    const load = [
-        ...sets.configParsing.filter(isError),
-        ...semantic.filter(({ code }) => !UNFOUND_LIBRARY.has(code)),
-    ];
-    return {
-        load: locatedIn(load, sets.locate),
-        check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
-        unfound: load.length > 0 ? [] : locatedIn(unfound, sets.locate),
-    };
-}
-/**
- * The first line of one error about the target, every mention of the target root
- * spelled relative to it: a path below the root loses the root and its separator, and
- * the root itself is `.`.
- */
-export function targetRelative(text, targetRoot) {
-    const root = targetRoot.endsWith("/") ? targetRoot.slice(0, -1) : targetRoot;
-    const [first = ""] = text.split(/\r?\n/u);
-    const spelled = first.split(`${root}/`).join("").split(root).join(".").trim();
-    return spelled === "" ? "the configuration could not be built" : spelled;
-}
-/**
- * Whether one configuration is the analyzer's own guess: discovery derived it and the
- * scope did not name it. A guess that does not load is dropped; any other ends the run.
- */
-export function isGuess(discovery, configFile) {
-    return discovery.derived && !discovery.fromScope.includes(configFile);
-}
-/**
- * The configuration files below `root`, in ascending path order, skipping an
- * ignored directory. A directory that cannot be read is skipped: a tree the
- * analysis may not enter names no project.
- */
-function configFilesUnder(host, root) {
-    const found = [];
-    const pending = [root];
-    while (pending.length > 0) {
-        const dir = pending.pop();
-        if (dir === undefined) {
-            break;
-        }
-        let entries;
-        try {
-            entries = host.readDirectory(dir);
-        }
-        catch {
-            continue;
-        }
-        for (const entry of [...entries].sort((a, b) => (a.name < b.name ? -1 : 1))) {
-            const path = joinPath(dir, entry.name);
-            if (entry.directory) {
-                if (!IGNORED_DIRECTORIES.has(entry.name)) {
-                    pending.push(path);
-                }
-                continue;
-            }
-            if (CONFIG_FILE.test(entry.name)) {
-                found.push(path);
-            }
-        }
-    }
-    return found.sort();
-}
-/**
- * The configuration file the scope names for the target directly, where its path
- * names one rather than a directory. A target naming a directory is reached by the
- * walk over that directory instead. A consumer's projects are a consumer's, never the
- * target's, so no consumer path is read here.
- */
-function scopeConfigFiles(host, scope) {
-    return [scope.target.path]
-        .filter((path) => path.endsWith(".json"))
-        .map((path) => resolvePath(host.workingDirectory(), path));
-}
-/**
- * Every configuration file reached from `pending`, in the order discovery reads them:
- * each once, each followed by the configurations it references that `follows` admits,
- * transitively. A configuration the compiler cannot read ends the run naming it, unless
- * `unreadable` is given, which is then told the configuration and why, and the walk
- * goes on without it.
- */
-function derivedFrom(engine, host, pending, follows, unreadable) {
-    const seen = new Set();
-    const found = [];
-    while (pending.length > 0) {
-        const configFile = pending.shift();
-        if (configFile === undefined) {
-            break;
-        }
-        const path = resolvePath(host.workingDirectory(), configFile);
-        if (seen.has(path)) {
-            continue;
-        }
-        seen.add(path);
-        const read = readConfiguration(engine, path);
-        if ("reason" in read) {
-            if (unreadable === undefined) {
-                throw new DiscoveryError(`${path} cannot be read as a compiler configuration: ${read.reason}`, []);
-            }
-            unreadable(path, read.reason);
-            continue;
-        }
-        found.push(path);
-        pending.push(...read.references.filter(follows));
-    }
-    return found;
-}
-/**
- * The compiler configurations one consumer is loaded through: every one under its
- * root that is not inside an ignored directory, and the configurations each of those
- * references, transitively, in that order. A root that is absent, that is no
- * directory, or that holds no configuration ends the run naming it, because a
- * finding computed without a declared consumer would claim a reference set the run
- * never read.
- */
-export function consumerProjects(engine, host, root) {
-    const kind = host.kindOf(root);
-    if (kind === "absent") {
-        throw new SetupError([
-            {
-                setupClass: "missing-consumer",
-                detail: `the scope declares the consumer ${root}, and nothing is at that path: check the consumer out at ${root} and install its dependencies`,
-            },
-        ]);
-    }
-    if (kind !== "directory") {
-        throw new DiscoveryError(`the consumer ${root} is not a directory`, []);
-    }
-    const found = derivedFrom(engine, host, configFilesUnder(host, root), () => true);
-    if (found.length === 0) {
-        throw new DiscoveryError(`the consumer ${root} holds no compiler configuration, so none of its references can be read`, []);
-    }
-    return found;
-}
-/**
- * The name a derived project carries: its configuration file's path below the target
- * root, or the absolute path of a file outside it.
- */
-function derivedId(targetRoot, configFile) {
-    return relativePath(targetRoot, configFile) ?? configFile;
-}
-/**
- * The code of a configuration whose `extends` chain returns to a configuration it already
- * passed. The parse reports it and returns, and a snapshot opened from it never answers:
- * https://github.com/microsoft/TypeScript/issues/64754
- */
-const CIRCULAR_EXTENDS = 18000;
-/** The configuration files one parsed configuration's own `extends` names by path. */
-function extendedPaths(parsed, configFile) {
-    const { raw } = parsed;
-    const named = typeof raw === "object" && raw !== null ? Reflect.get(raw, "extends") : [];
-    return (Array.isArray(named) ? named : [named])
-        .filter((one) => typeof one === "string")
-        .filter((one) => one.startsWith("./") || one.startsWith("../") || isAbsolutePath(one))
-        .map((one) => resolvePath(dirnamePath(configFile), one));
-}
-/**
- * The `extends` chain from `configFile` to the first configuration it reaches twice, each
- * link by path, or undefined where no chain written by path returns.
- */
-function extendsCycle(engine, configFile, parsed) {
-    const walk = (chain, at) => {
-        for (const next of extendedPaths(at, chain.at(-1) ?? configFile)) {
-            if (chain.includes(next)) {
-                return [...chain, next];
-            }
-            let read;
-            try {
-                read = engine.parseConfigFile(next);
-            }
-            catch {
-                continue;
-            }
-            const cycle = walk([...chain, next], read);
-            if (cycle !== undefined) {
-                return cycle;
-            }
-        }
-        return undefined;
-    };
-    return walk([configFile], parsed);
-}
-/** The configuration files one parsed configuration's `references` name. */
-function referencesOf(parsed) {
-    // The parse answers a directory reference as the directory; the compiler reads a
-    // path not ending `.json` as its `tsconfig.json`:
-    // https://github.com/microsoft/typescript-go/blob/89d5d5b2849a0db0957065889ca58536fa6d2e4a/internal/core/projectreference.go#L18
-    return (parsed.projectReferences ?? []).map(({ path }) => path.endsWith(".json") ? path : joinPath(path, "tsconfig.json"));
-}
-/** Why one parsed configuration's own `extends` chain cannot be opened, where it is circular. */
-function circularity(engine, configFile, parsed) {
-    const chain = extendsCycle(engine, configFile, parsed);
-    if (chain === undefined && !parsed.errors.some(({ code }) => code === CIRCULAR_EXTENDS)) {
-        return undefined;
-    }
-    return `TS${String(CIRCULAR_EXTENDS)}: Circularity detected while resolving configuration: ${(chain ?? [configFile]).join(" -> ")}`;
-}
-/**
- * Why a configuration the `references` reach, transitively, cannot be opened, where one's
- * `extends` chain is circular: the compiler opens every referenced project with the one
- * that references it.
- */
-function referencedCircularity(engine, references, visited) {
-    for (const reference of references) {
-        if (visited.has(reference)) {
-            continue;
-        }
-        visited.add(reference);
-        let parsed;
-        try {
-            parsed = engine.parseConfigFile(reference);
-        }
-        catch {
-            continue;
-        }
-        const reason = circularity(engine, reference, parsed) ??
-            referencedCircularity(engine, referencesOf(parsed), visited);
-        if (reason !== undefined) {
-            return reason;
-        }
-    }
-    return undefined;
-}
-/**
- * The configuration files one configuration's `references` name, or why the compiler
- * cannot read the configuration: it throws, or its `extends` chain or that of a
- * configuration it references is circular, which the analysis refuses before any
- * snapshot is asked to open it.
- */
-function readConfiguration(engine, configFile) {
-    try {
-        const parsed = engine.parseConfigFile(configFile);
-        const references = referencesOf(parsed);
-        const reason = circularity(engine, configFile, parsed) ??
-            referencedCircularity(engine, references, new Set([configFile]));
-        return reason === undefined ? { references } : { reason };
-    }
-    catch (error) {
-        return { reason: error instanceof Error ? error.message : String(error) };
-    }
-}
-/**
- * The references of one compiler configuration file, or ends the run naming it: a
- * project opened from a configuration the compiler cannot read would be analyzed with
- * no type information.
- */
-function parseOrRefuse(engine, configFile, named) {
-    const read = readConfiguration(engine, configFile);
-    if ("reason" in read) {
-        throw new DiscoveryError(`${named} cannot be read as a compiler configuration: ${read.reason}`, []);
-    }
-    return read.references;
-}
-/**
- * The projects a build matrix declares, in its order, each entry a file below the target
- * root: an entry naming an absent file, a directory or a file the compiler cannot read
- * ends the run naming it, and one naming an earlier entry's file adds nothing. A
- * reference below the root the matrix does not name ends the run naming both, because the
- * compiler builds a referenced project's sources into the referencing program without
- * reporting their diagnostics. A reference outside the root is an outside project.
- */
-function declaredProjects(engine, host, targetRoot, entries) {
-    const seen = new Set();
-    const projects = [];
-    const references = new Map();
-    for (const entry of entries) {
-        const configFile = joinPath(targetRoot, entry.project);
-        const named = `the project ${JSON.stringify(entry.id)} (${configFile})`;
-        const kind = host.kindOf(configFile);
-        if (kind !== "file") {
-            throw new DiscoveryError(kind === "absent"
-                ? `${named} does not exist`
-                : `${named} is a directory, and a project names its compiler configuration file`, []);
-        }
-        if (seen.has(configFile)) {
-            continue;
-        }
-        seen.add(configFile);
-        references.set(configFile, parseOrRefuse(engine, configFile, named));
-        projects.push({ id: entry.id, configFile });
-    }
-    for (const project of projects) {
-        const unnamed = references
-            .get(project.configFile)
-            ?.find((path) => !seen.has(path) && relativePath(targetRoot, path) !== undefined);
-        if (unnamed !== undefined) {
-            throw new DiscoveryError(`the project ${JSON.stringify(project.id)} (${project.configFile}) references ` +
-                `${unnamed}, which the build matrix does not name. A referenced project is built ` +
-                "into the program that references it, so the matrix names it too", []);
-        }
-    }
-    return {
-        projects,
-        derived: false,
-        notBuilt: [],
-        configFiles: projects.map((project) => project.configFile),
-        fromScope: [],
-    };
-}
-/**
- * The projects a run derives where the matrix declares none, in discovery order: the
- * paths the scope names, every compiler configuration under the target root outside an
- * ignored directory, then each configuration below the root those reference,
- * transitively, each once. A reference outside the root is an outside project, whose
- * sources the compiler builds into the referencing program. A configuration the scope
- * names ends the run where it cannot be read; one the walk found is dropped and named.
- */
-function derivedProjects(engine, host, scope) {
-    const targetRoot = scope.target.path;
-    const fromScope = scopeConfigFiles(host, scope);
-    const notBuilt = [];
-    const rootDir = resolvePath(host.workingDirectory(), fromScope.length > 0 ? dirnamePath(targetRoot) : targetRoot);
-    const configFiles = derivedFrom(engine, host, [...fromScope, ...configFilesUnder(host, targetRoot)], (reference) => relativePath(rootDir, reference) !== undefined, (configFile, reason) => {
-        if (fromScope.includes(configFile)) {
-            throw new DiscoveryError(`${configFile} cannot be read as a compiler configuration: ${reason}`, []);
-        }
-        notBuilt.push({
-            id: derivedId(targetRoot, configFile),
-            configFile,
-            error: targetRelative(reason, resolvePath(host.workingDirectory(), targetRoot)),
-        });
-    });
-    const projects = configFiles.map((configFile) => ({
-        id: derivedId(targetRoot, configFile),
-        configFile,
-    }));
-    return { projects, derived: true, notBuilt, configFiles, fromScope };
-}
-/**
- * Every project one run analyzes.
- *
- * The project entries of the build matrix, where it holds any, are the projects:
- * exactly those, in the order the matrix lists them, each named by its declared
- * identifier, as {@link declaredProjects} reads them. A matrix holding no project
- * entry, the empty one included, leaves discovery to derive the projects from the
- * scope and the target tree. A platform entry names a configuration of another
- * language and plays no part here.
- *
- * A configuration file the compiler cannot read is never analyzed. One the matrix or
- * the scope names ends the run with the failure code; a guess is dropped and named in
- * {@link Discovery.notBuilt}. What a configuration's own contents say is read once its
- * project is open, by {@link diagnosticErrors}, because a resolution carries none.
- *
- * Nothing reads a build output: a project is the files its configuration names, so a
- * package whose sources ship as TypeScript is analyzed as it stands.
- */
-export function discoverProjects(engine, host, scope, configurations = []) {
-    const declared = configurations.filter((entry) => entry.shape === "project");
-    if (declared.length > 0) {
-        return declaredProjects(engine, host, scope.target.path, declared);
-    }
-    return derivedProjects(engine, host, scope);
-}
-/**
- * How the snapshot reads each configuration of `configFiles` that sets `baseUrl` and
- * `programs` does not already describe: a configuration only the snapshot holds, which
- * extends it and states the `paths` {@link baseUrlPaths} gives, so its imports resolve as
- * the compilers before version 7 resolve them. A configuration the compiler cannot read is
- * left for its project to refuse.
- */
-export function withBaseUrlPaths(engine, host, configFiles, programs) {
-    const found = new Map(programs);
-    for (const configFile of configFiles) {
-        if (found.has(configFile)) {
-            continue;
-        }
-        let paths;
-        try {
-            paths = baseUrlPaths(engine.parseConfigFile(configFile).options);
-        }
-        catch {
-            continue;
-        }
-        if (paths !== undefined) {
-            found.set(configFile, {
-                kind: "configuration",
-                file: writtenPath(host, configFile),
-                text: `${JSON.stringify({ extends: configFile, compilerOptions: { paths } }, null, 2)}\n`,
-            });
-        }
-    }
-    return found;
-}

package/dist/src/glob.js

@@ -1,65 +0,0 @@
-/**
- * Glob patterns over the paths of the target's own files, as the configuration
- * writes them. Both `ts.test_files` and `ts.entry_files` name files this way, and
- * one grammar answers for both.
- *
- * A configured root is not written in this grammar. It names a symbol reference
- * rather than a path, `*` there spans the solidus and a brace list means nothing,
- * so that rule is written where it is read.
- */
-/**
- * One literal run of a pattern, with every character the expression syntax claims
- * escaped.
- *
- * The set is the syntax characters and the solidus, and it is closed: an escape of any
- * other character is refused outright by the expression syntax under the unicode flag,
- * so escaping a hyphen, which needs none outside a character class, would refuse every
- * pattern that names a hyphenated path.
- */
-function quoted(text) {
-    return text.replaceAll(/[.*+?^${}()|[\]\\/]/gu, (character) => `\\${character}`);
-}
-/**
- * The expression one glob pattern denotes. `**` spans path separators while `*` and `?`
- * do not, a brace list is an alternation of its members, and every other character
- * stands for itself.
- */
-export function globExpression(pattern) {
-    let source = "^";
-    let at = 0;
-    while (at < pattern.length) {
-        const rest = pattern.slice(at);
-        if (rest.startsWith("**/")) {
-            source += "(?:[^/]*/)*";
-            at += 3;
-            continue;
-        }
-        if (rest.startsWith("**")) {
-            source += ".*";
-            at += 2;
-            continue;
-        }
-        const character = pattern[at] ?? "";
-        at += 1;
-        if (character === "*") {
-            source += "[^/]*";
-            continue;
-        }
-        if (character === "?") {
-            source += "[^/]";
-            continue;
-        }
-        if (character === "{") {
-            const close = pattern.indexOf("}", at);
-            if (close < 0) {
-                source += "\\{";
-                continue;
-            }
-            source += `(?:${pattern.slice(at, close).split(",").map(quoted).join("|")})`;
-            at = close + 1;
-            continue;
-        }
-        source += quoted(character);
-    }
-    return new RegExp(`${source}$`, "u");
-}

package/dist/src/pnpm-workspace.js

@@ -1,120 +0,0 @@
-/**
- * The `packages` list of a `pnpm-workspace.yaml`. The document is read as far as that
- * one key needs and no further: a top-level `packages` key holding a block sequence or
- * a one-line flow sequence of plain or quoted strings. Any other value of the key is
- * refused rather than guessed at, because a list read wrong names the wrong packages.
- */
-/** The characters a plain scalar may not start with. */
-const INDICATORS = new Set(["[", "]", "{", "}", ",", "&", "*", "!", "|", ">", "%", "@", "`", "#"]);
-/** One line with its comment removed, a `#` inside quotes kept. */
-function uncommented(line) {
-    let quote;
-    for (let at = 0; at < line.length; at += 1) {
-        const character = line[at];
-        if (quote !== undefined) {
-            if (character === quote) {
-                quote = undefined;
-            }
-            continue;
-        }
-        if (character === "'" || character === '"') {
-            quote = character;
-        }
-        else if (character === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
-            return line.slice(0, at).trimEnd();
-        }
-    }
-    return line.trimEnd();
-}
-/** One scalar as written, or `undefined` where it is not a string this reader reads. */
-function scalarOf(text) {
-    const value = text.trim();
-    if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
-        const inner = value.slice(1, -1);
-        return /'(?!')/u.test(inner.replaceAll("''", "")) ? undefined : inner.replaceAll("''", "'");
-    }
-    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
-        const inner = value.slice(1, -1);
-        return inner.includes("\\") || inner.includes('"') ? undefined : inner;
-    }
-    if (value === "" ||
-        INDICATORS.has(value[0] ?? "") ||
-        value.startsWith("'") ||
-        value.startsWith('"')) {
-        return undefined;
-    }
-    if (value.startsWith("- ") || value.startsWith("? ") || /:(?:\s|$)/u.test(value)) {
-        return undefined;
-    }
-    return value;
-}
-/** The entries of a one-line flow sequence, or `undefined` where one does not read. */
-function flowOf(text) {
-    const inner = text.slice(1, -1).trim();
-    if (inner === "") {
-        return [];
-    }
-    const entries = inner.split(",");
-    if (entries.length > 1 && entries.at(-1)?.trim() === "") {
-        entries.pop();
-    }
-    const found = [];
-    for (const entry of entries) {
-        const value = scalarOf(entry);
-        if (value === undefined) {
-            return undefined;
-        }
-        found.push(value);
-    }
-    return found;
-}
-const KEY = /^(?:packages|'packages'|"packages")\s*:(?:\s(.*))?$/u;
-/** The `packages` list one `pnpm-workspace.yaml` text declares. */
-export function pnpmPackages(text) {
-    const lines = text.split(/\r?\n/u).map(uncommented);
-    const keys = lines.flatMap((line, at) => (KEY.test(line) ? [at] : []));
-    const [at] = keys;
-    if (at === undefined) {
-        return { kind: "absent" };
-    }
-    if (keys.length > 1) {
-        return { kind: "refused", reason: "the packages key is declared more than once" };
-    }
-    const rest = (KEY.exec(lines[at] ?? "")?.[1] ?? "").trim();
-    if (rest !== "") {
-        const listed = rest.startsWith("[") && rest.endsWith("]") ? flowOf(rest) : undefined;
-        return listed === undefined
-            ? {
-                kind: "refused",
-                reason: `packages holds ${JSON.stringify(rest)}, not a sequence of strings`,
-            }
-            : { kind: "listed", patterns: listed };
-    }
-    const patterns = [];
-    for (const line of lines.slice(at + 1)) {
-        if (line.trim() === "") {
-            continue;
-        }
-        const item = /^(\s*)-(?:\s+(.*))?$/u.exec(line);
-        if (item === null) {
-            if (/^\s/u.test(line)) {
-                return {
-                    kind: "refused",
-                    reason: `packages holds ${JSON.stringify(line.trim())}, not a sequence item`,
-                };
-            }
-            break;
-        }
-        const value = scalarOf(item[2] ?? "");
-        if (value === undefined) {
-            return {
-                kind: "refused",
-                reason: `the packages item ${JSON.stringify(line.trim())} is not a plain or quoted string`,
-            };
-        }
-        patterns.push(value);
-    }
-    return patterns.length === 0
-        ? { kind: "refused", reason: "packages holds no sequence" }
-        : { kind: "listed", patterns };
-}

package/dist/src/setup-failure.js

@@ -1,23 +0,0 @@
-/**
- * A setup failure: a file or a component the analysis needs and the project does not
- * provide. Each one names what is missing and the fix, on one line of the error stream
- * that starts with its class.
- */
-/** The failure as the one line of the error stream that names it. */
-export function setupLine(failure) {
-    return `setup failure: ${failure.setupClass}: ${failure.detail}`;
-}
-/**
- * A run that met a setup failure where none may be dropped: in a configuration the
- * configuration document or the scope declares, in a declared consumer, or in every
- * configuration discovery derived. It ends the run with the failure code and no finding
- * list.
- */
-export class SetupError extends Error {
-    failures;
-    constructor(failures) {
-        super(failures.map(setupLine).join("\n"));
-        this.name = "SetupError";
-        this.failures = failures;
-    }
-}