@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.21

package/dist/src/roots.js

@@ -1,672 +0,0 @@
-/**
- * The root set of one project: every declaration the analysis keeps live without a
- * reference, and why.
- *
- * Every root seeds REACHABILITY, and no root counts as a reference. A root of a kind
- * that names a caller is live under reference counting as well, which the sweep
- * decides; the published API only supposes a consumer, so a published export is live
- * under reachability and still a candidate under reference counting.
- */
-import { isExpressionWithTypeArguments, isFunctionLikeDeclaration, isPropertyAccessExpression, isQualifiedName, isTypeQueryNode, isTypeReferenceNode, isPropertyDeclaration, isVariableDeclaration, isVariableStatement, } from "@typescript/native/ast";
-import { aliasChains } from "./alias-chain.js";
-import { filesNamedBy, outsideChain, relativeSpecifiers, } from "./configuration-files.js";
-import { conventionEntries } from "./conventions.js";
-import { entryPoints } from "./entry-points.js";
-import { globExpression } from "./glob.js";
-import { nodeKey } from "./inventory.js";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-import { byPosition } from "./position.js";
-import { UNANSWERED } from "./query.js";
-import { sourceFilesOf } from "./source-files.js";
-import { typeQueryAliases } from "./type-query-alias.js";
-/** Whether one declaration is written below the directory of a published workspace member. */
-function inPublishedMember(held, id, root, members) {
-    const path = held.symbols.find((symbol) => symbol.id === id)?.position.path;
-    if (path === undefined || members === undefined) {
-        return false;
-    }
-    const file = resolvePath(root, path);
-    return [...members].some((dir) => file.startsWith(`${dir}/`));
-}
-/** The kind of root each role of a manifest entry makes. */
-const ENTRY_KINDS = {
-    import: "manifest-entry",
-    run: "manifest-binary",
-    script: "script",
-};
-/** The rules whose rooted files a manifest target is read back to by name. */
-const READ_BACK_RULES = new Set([
-    "configuration-file",
-    "configuration-string",
-    "html-entry",
-]);
-/** The extensions a manifest target's name drops: the ones a build writes. */
-const OUTPUT_EXTENSION = /\.(?:d\.ts|d\.mts|d\.cts|js|mjs|cjs|jsx)$/u;
-/** The extension a source file's name drops. */
-const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
-/** Whether no `package.json` sits between one file and the manifest's directory, which holds it. */
-function ofPackage(host, dir, file) {
-    for (let at = dirnamePath(file); at !== dir; at = dirnamePath(at)) {
-        if (relativePath(dir, at) === undefined ||
-            host.kindOf(joinPath(at, "package.json")) === "file") {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * The rooted files one manifest target reads back to by name: its path below the
- * manifest's directory, past its first directory where it names one, without its output
- * extension, is the name, and a rooted file of the manifest's own package is one whose
- * path below the same directory, without its source extension, ends with that name at a
- * directory boundary.
- */
-function readBackByName(host, entry, rooted) {
-    const dir = resolvePath(host.workingDirectory(), entry.dir);
-    const below = relativePath(dir, resolvePath(host.workingDirectory(), entry.path));
-    if (below === undefined || below === "") {
-        return [];
-    }
-    const cut = below.indexOf("/");
-    const name = (cut === -1 ? below : below.slice(cut + 1)).replace(OUTPUT_EXTENSION, "");
-    if (name === "") {
-        return [];
-    }
-    const found = new Map();
-    for (const file of rooted) {
-        const path = relativePath(dir, file.fileName)?.replace(SOURCE_EXTENSION, "");
-        if (path !== undefined &&
-            (path === name || path.endsWith(`/${name}`)) &&
-            ofPackage(host, dir, file.fileName)) {
-            found.set(file.fileName, file);
-        }
-    }
-    return [...found.values()];
-}
-/**
- * The program files a manifest target no program holds reaches: the target is a file
- * read as a configuration file outside the program is, and each file of the chain it
- * starts loads the program files its relative specifiers name, read through the emit
- * mapping, as a command's shim loads the compiled entry it runs.
- */
-function throughOutside(options, targetRoot, files, entry) {
-    const cwd = options.host.workingDirectory();
-    const path = resolvePath(cwd, entry.path);
-    if (options.parse === undefined ||
-        options.runFiles?.has(path) === true ||
-        options.host.kindOf(path) !== "file") {
-        return [];
-    }
-    const chain = outsideChain(options.host, targetRoot, files, options.parse, [
-        { path, manifestDir: resolvePath(cwd, entry.dir) },
-    ]);
-    const found = new Map();
-    for (const { file } of chain) {
-        for (const specifier of relativeSpecifiers(file)) {
-            for (const named of filesNamedBy(files, dirnamePath(file.fileName), specifier)) {
-                found.set(named.fileName, named);
-            }
-        }
-    }
-    return [...found.values()];
-}
-/** Whether a configured string carries either special character. */
-function isPattern(text) {
-    return text.includes("*") || text.includes("?");
-}
-/**
- * Whether ref matches a pattern whose only special characters are `*`, which stands
- * for any run of characters including the solidus, and `?`, which stands for exactly
- * one character counted as a code point. A star keeps the position it last stood at,
- * so the shortest run it can stand for is tried first.
- */
-function matchGlob(pattern, ref) {
-    let next = 0;
-    let star = -1;
-    let resume = 0;
-    let at = 0;
-    while (at < ref.length) {
-        if (next < pattern.length && (pattern[next] === "?" || pattern[next] === ref[at])) {
-            next += 1;
-            at += 1;
-        }
-        else if (next < pattern.length && pattern[next] === "*") {
-            star = next;
-            resume = at;
-            next += 1;
-        }
-        else if (star >= 0) {
-            resume += 1;
-            next = star + 1;
-            at = resume;
-        }
-        else {
-            return false;
-        }
-    }
-    while (next < pattern.length && pattern[next] === "*") {
-        next += 1;
-    }
-    return next === pattern.length;
-}
-/**
- * Whether one configured string names the symbol reference ref. A string carrying
- * neither special character names only the reference it spells.
- *
- * Both sides are read as code points: a character outside the basic plane is two
- * string units, and `?` stands for one character.
- */
-export function matchRef(pattern, ref) {
-    if (!isPattern(pattern)) {
-        return pattern === ref;
-    }
-    return matchGlob(Array.from(pattern), Array.from(ref));
-}
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    return a < b ? -1 : 1;
-}
-/** The members of one declaration, indexed by the container that holds them. */
-function childrenOf(held) {
-    const byParent = new Map();
-    for (const symbol of held.symbols) {
-        const siblings = byParent.get(symbol.parent);
-        if (siblings === undefined) {
-            byParent.set(symbol.parent, [symbol]);
-        }
-        else {
-            siblings.push(symbol);
-        }
-    }
-    return byParent;
-}
-/**
- * The roots one project holds, and every configured string that named nothing in it.
- *
- * A file a manifest member, an entry-file pattern or a tool's configuration names
- * is a root with everything its module exports: each name of the module's export
- * table, and where a name is a re-export, every link of the chain to the declaration
- * it carries, so a re-exported declaration is a root of the file that publishes it.
- * In a library, what a published file exports is rooted by the published API alone.
- * A file a runtime executes without reading its exports, a test file or a worker, is
- * a root by itself.
- */
-export function roots(project, held, targetRoot, options) {
-    const files = sourceFilesOf(project, targetRoot);
-    const declared = held.declarations;
-    const fileIds = new Map();
-    for (const file of files.byName.values()) {
-        const id = declared.get(nodeKey(file, file));
-        if (id !== undefined) {
-            fileIds.set(file.fileName, id);
-        }
-    }
-    const found = new Map();
-    const add = (id, kind, source) => {
-        found.set([id, kind, source].join("\u0000"), { id, kind, source });
-    };
-    const entered = [];
-    const enter = (file, kind, source, exports, names) => {
-        entered.push({ file, kind, source, exports, ...(names === undefined ? {} : { names }) });
-    };
-    const points = entryPoints(project, files, options.testFiles, options.host, targetRoot, options.parse, options.conventions?.selected);
-    const published = [];
-    const entries = [
-        ...options.manifest.entries.map((entry) => ({
-            entry,
-            publishes: options.publishedAPI &&
-                entry.published &&
-                (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
-        })),
-        ...(options.otherPackages ?? []).map((entry) => ({
-            entry,
-            publishes: entry.published &&
-                (options.publishedAPI || options.publishedMembers?.has(entry.dir) === true),
-        })),
-    ];
-    const scripted = entries.flatMap(({ entry }) => entry.role === "script" ? files.named(entry.path) : []);
-    const readBackTo = [
-        ...scripted,
-        ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
-    ];
-    const entryFilesOf = new Map();
-    const entryFiles = (entry) => {
-        const known = entryFilesOf.get(entry);
-        if (known !== undefined) {
-            return known;
-        }
-        const found = readEntryFiles(entry);
-        entryFilesOf.set(entry, found);
-        return found;
-    };
-    const readEntryFiles = (entry) => {
-        const named = files.named(entry.path);
-        if (named.length > 0 || entry.role === "script") {
-            return named;
-        }
-        const cwd = options.host.workingDirectory();
-        const shipped = files.namedAsOutput(resolvePath(cwd, entry.dir), resolvePath(cwd, entry.path));
-        if (shipped.length > 0) {
-            return shipped;
-        }
-        const byName = readBackByName(options.host, entry, readBackTo);
-        return byName.length > 0 ? byName : throughOutside(options, targetRoot, files, entry);
-    };
-    for (const { entry, publishes } of entries) {
-        if (publishes) {
-            published.push(...entryFiles(entry));
-        }
-    }
-    const publishedNames = new Set(published.map((file) => file.fileName));
-    const patterned = [];
-    for (const pattern of options.entryFiles) {
-        const expression = globExpression(pattern);
-        for (const [path, file] of files.byPath) {
-            if (expression.test(path)) {
-                patterned.push({ file, pattern });
-            }
-        }
-    }
-    const unmapped = [];
-    const mapped = patterned.map(({ file }) => file);
-    for (const { entry } of entries) {
-        const named = entryFiles(entry);
-        if (named.length === 0 && entry.role !== "script") {
-            unmapped.push(entry);
-        }
-        mapped.push(...named);
-        for (const file of named) {
-            const kind = ENTRY_KINDS[entry.role];
-            enter(file, kind, entry.member, !publishedNames.has(file.fileName));
-        }
-    }
-    const unmappedEntries = unmapped.filter((entry) => readBackByName(options.host, entry, mapped).length === 0);
-    for (const { file, pattern } of patterned) {
-        enter(file, "entry-file", pattern, true);
-    }
-    for (const { file, row } of options.conventions === undefined
-        ? []
-        : conventionEntries(options.conventions, files)) {
-        enter(file, "convention", row, true);
-    }
-    for (const point of points) {
-        enter(point.file, point.rule, point.source, point.exports, point.names);
-    }
-    for (const file of files.byPath.values()) {
-        for (const alias of typeQueryAliases(file)) {
-            const source = alias.type.getText().replace(/\s+/gu, " ");
-            for (const node of [alias.declaration, ...alias.containers]) {
-                const id = declared.get(nodeKey(file, node));
-                if (id !== undefined) {
-                    add(id, "type-query-alias", source);
-                }
-            }
-        }
-    }
-    const { tables: exportsOf, named, answered, } = exportTables(project, held, [
-        ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
-        ...published,
-    ]);
-    for (const entry of entered) {
-        const id = fileIds.get(entry.file.fileName);
-        if (id === undefined) {
-            continue;
-        }
-        add(id, entry.kind, entry.source);
-        if (entry.exports) {
-            const byName = named.get(entry.file.fileName);
-            const exported = entry.names === undefined || byName === undefined
-                ? (exportsOf.get(entry.file.fileName) ?? [])
-                : entry.names.flatMap((name) => byName.get(name) ?? []);
-            for (const one of exported) {
-                add(one, entry.kind, entry.source);
-            }
-        }
-    }
-    const tagged = releaseTagged(held, files).filter((id) => options.publishedAPI || inPublishedMember(held, id, targetRoot, options.publishedMembers));
-    const api = published.length > 0 || tagged.length > 0
-        ? publishedAPI(project, published, exportsOf, held, files.byPath, tagged)
-        : { ids: [], guessed: [] };
-    for (const id of api.ids) {
-        add(id, "published-api", "");
-    }
-    const unmatched = configured(held, options.patterns, add);
-    const sites = new Map(held.symbols.map((symbol) => [symbol.id, symbol.position]));
-    const ordered = [...found.values()].sort((a, b) => {
-        const left = sites.get(a.id);
-        const right = sites.get(b.id);
-        const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
-        return site || compare(a.kind, b.kind) || compare(a.source, b.source);
-    });
-    return {
-        liveUnderReachability: ordered,
-        unmatched,
-        unanswered: answered ? api.guessed : held.symbols.map((symbol) => symbol.id),
-        unmappedEntries,
-    };
-}
-/**
- * Every declaration each file's module exports, by the file's name: the declaration
- * each name of the export table is, and every link of a re-export's chain. A name
- * whose declaration is outside the project's own files names nothing here. One batch
- * resolves every file to its module and one request per module reads its export
- * table, star re-exports resolved into it. A file that is no module exports nothing.
- * `answered` is false where the checker left a table or a link of a chain unanswered.
- */
-function exportTables(project, held, wanted) {
-    const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
-    const tables = new Map();
-    const named = new Map();
-    let answered = true;
-    if (unique.length === 0) {
-        return { tables, named, answered };
-    }
-    const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
-    const chains = aliasChains(project, held);
-    const topLevel = (file) => {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        return held.symbols.filter((symbol) => symbol.parent === fileId).map((symbol) => symbol.id);
-    };
-    unique.forEach((file, index) => {
-        const module = modules[index];
-        if (module === undefined) {
-            tables.set(file.fileName, []);
-            return;
-        }
-        const table = module === UNANSWERED ? UNANSWERED : project.queries.exportsOfModule(module);
-        if (table === UNANSWERED) {
-            answered = false;
-            tables.set(file.fileName, topLevel(file));
-            return;
-        }
-        const ids = new Set();
-        const byName = new Map();
-        for (const exported of table) {
-            for (const target of chains.chainOf(exported)) {
-                answered &&= !target.guessed;
-                ids.add(target.id);
-                byName.set(exported.name, [...(byName.get(exported.name) ?? []), target.id]);
-            }
-        }
-        tables.set(file.fileName, [...ids]);
-        named.set(file.fileName, byName);
-    });
-    return { tables, named, answered };
-}
-/** A release tag of a documentation comment: `@` and its name, between white space or the ends. */
-const RELEASE_TAG = /(?:^|\s)@(?:public|beta|alpha)(?=\s|$)/u;
-/**
- * Whether the documentation comment of the statement that starts at `start`, the last
- * `/** *\/` comment before it with only white space between the two, holds a release tag.
- */
-function releaseTagIn(text, from, start) {
-    const leading = text.slice(from, start);
-    const open = leading.lastIndexOf("/**");
-    const close = open < 0 ? -1 : leading.indexOf("*/", open + 3);
-    if (close < 0 || leading.slice(close + 2).trim() !== "") {
-        return false;
-    }
-    return RELEASE_TAG.test(leading.slice(open + 3, close));
-}
-/** The exported top-level declarations of the program's files a release tag marks. */
-function releaseTagged(held, files) {
-    const exported = new Set(held.symbols.filter((symbol) => symbol.exported).map((one) => one.id));
-    const found = [];
-    for (const file of files.byPath.values()) {
-        for (const statement of file.statements) {
-            if (!releaseTagIn(file.text, statement.pos, statement.getStart())) {
-                continue;
-            }
-            const nodes = isVariableStatement(statement)
-                ? statement.declarationList.declarations
-                : [statement];
-            for (const node of nodes) {
-                const id = held.declarations.get(nodeKey(file, node));
-                if (id !== undefined && exported.has(id)) {
-                    found.push(id);
-                }
-            }
-        }
-    }
-    return found;
-}
-/** The kinds of container whose export table, not its members' visibility, says what it publishes. */
-const EXPORTING_CONTAINERS = new Set(["file", "namespace"]);
-/**
- * Every declaration a consumer of the library can name: what the published files export,
- * and below each the members a consumer writes, a namespace's exported ones and any other
- * declaration's public and protected ones. A declaration a published one's type names is
- * published too, and so is an exported declaration a release tag marks. A type name the
- * checker leaves unanswered publishes every declaration spelled as it is, as `guessed`. A
- * published file is not itself published.
- */
-function publishedAPI(project, published, exportsOf, held, byPath, tagged) {
-    const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
-    const children = childrenOf(held);
-    const nodes = declarationNodes(held, byPath);
-    const chains = aliasChains(project, held);
-    const reached = new Set();
-    const entered = new Set();
-    const guessed = new Set();
-    const pending = [];
-    const reach = (id) => {
-        const file = byId.get(id)?.kind === "file";
-        if (!(file ? entered : reached).has(id)) {
-            (file ? entered : reached).add(id);
-            pending.push(id);
-        }
-    };
-    for (const id of tagged) {
-        reach(id);
-    }
-    for (const file of published) {
-        for (const id of exportsOf.get(file.fileName) ?? []) {
-            reach(id);
-        }
-    }
-    while (pending.length > 0) {
-        const round = [];
-        for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-            round.push(next);
-            const exporting = EXPORTING_CONTAINERS.has(byId.get(next)?.kind ?? "");
-            for (const member of children.get(next) ?? []) {
-                const reachable = exporting
-                    ? member.exported
-                    : member.visibility !== "private" && member.visibility !== "private-name";
-                if (member.kind !== "type-parameter" && reachable) {
-                    reach(member.id);
-                }
-            }
-        }
-        const named = round.flatMap((id) => {
-            const symbol = byId.get(id);
-            return symbol === undefined || symbol.kind === "file" ? [] : nodes.typeNamesOf(symbol);
-        });
-        for (const symbol of inferredTypeSymbols(project, round.flatMap((id) => {
-            const symbol = byId.get(id);
-            return symbol === undefined ? [] : nodes.nodesOf(symbol);
-        }))) {
-            for (const target of chains.chainOf(symbol)) {
-                reach(target.id);
-            }
-        }
-        project.symbolsAt(named.map((node) => project.handle(node))).forEach((symbol, index) => {
-            if (symbol === UNANSWERED) {
-                for (const id of held.byName.get(named[index]?.getText() ?? "") ?? []) {
-                    guessed.add(id);
-                    reach(id);
-                }
-            }
-            else if (symbol !== undefined) {
-                for (const target of chains.chainOf(symbol)) {
-                    reach(target.id);
-                }
-            }
-        });
-    }
-    return { ids: [...reached], guessed: [...guessed] };
-}
-/** The type names declarations of the inventory write, each file walked once, when first asked. */
-function declarationNodes(held, byPath) {
-    const walked = new Map();
-    const nodesIn = (path) => {
-        const known = walked.get(path);
-        if (known !== undefined) {
-            return known;
-        }
-        const found = { byId: new Map(), nodes: new Set() };
-        const file = byPath.get(path);
-        if (file !== undefined) {
-            const visit = (node) => {
-                const id = held.declarations.get(nodeKey(file, node));
-                if (id !== undefined) {
-                    found.nodes.add(node);
-                    found.byId.set(id, [...(found.byId.get(id) ?? []), node]);
-                }
-                node.forEachChild(visit);
-            };
-            visit(file);
-        }
-        walked.set(path, found);
-        return found;
-    };
-    return {
-        typeNamesOf: (symbol) => {
-            const { byId, nodes } = nodesIn(symbol.position.path);
-            return (byId.get(symbol.id) ?? []).flatMap((declaration) => typeNamesOf(declaration, nodes));
-        },
-        nodesOf: (symbol) => nodesIn(symbol.position.path).byId.get(symbol.id) ?? [],
-    };
-}
-/** How deep the type arguments and constituents of an inferred type are followed. */
-const INFERRED_DEPTH = 4;
-/**
- * The declarations of the types the compiler infers where a declaration writes none: the
- * type of a variable or a property with no annotation, and the result of a function or a
- * method with no result annotation, each with the types its type arguments and its union
- * or intersection constituents name, to a fixed depth. A question the checker leaves
- * unanswered names nothing.
- */
-function inferredTypeSymbols(project, declarations) {
-    const { queries } = project;
-    const valued = declarations.flatMap((node) => (isVariableDeclaration(node) || isPropertyDeclaration(node)) &&
-        node.type === undefined &&
-        !isFunctionLikeDeclaration(node.initializer ?? node)
-        ? [node.name]
-        : []);
-    const types = [];
-    queries.typesAt(valued).forEach((type) => {
-        if (type !== UNANSWERED && type !== undefined) {
-            types.push(type);
-        }
-    });
-    for (const node of declarations) {
-        const signature = isFunctionLikeDeclaration(node)
-            ? node
-            : isVariableDeclaration(node) &&
-                node.type === undefined &&
-                node.initializer !== undefined &&
-                isFunctionLikeDeclaration(node.initializer)
-                ? node.initializer
-                : undefined;
-        if (signature === undefined || signature.type !== undefined || signature.body === undefined) {
-            continue;
-        }
-        const typed = queries.signatureOf(signature);
-        const result = typed === UNANSWERED || typed === undefined ? undefined : queries.returnTypeOf(typed);
-        if (result !== UNANSWERED && result !== undefined) {
-            types.push(result);
-        }
-    }
-    const found = new Map();
-    const seen = new Set();
-    const visit = (type, depth) => {
-        if (depth > INFERRED_DEPTH || seen.has(type)) {
-            return;
-        }
-        seen.add(type);
-        const symbol = queries.symbolOfType(type);
-        if (symbol !== UNANSWERED && symbol !== undefined) {
-            found.set(symbol.id, symbol);
-        }
-        const parts = queries.constituents(type);
-        const args = queries.typeArguments(type);
-        for (const next of [
-            ...(parts === UNANSWERED || (parts.length === 1 && parts[0] === type) ? [] : parts),
-            ...(args === UNANSWERED ? [] : args),
-        ]) {
-            visit(next, depth + 1);
-        }
-    };
-    types.forEach((type) => {
-        visit(type, 0);
-    });
-    return [...found.values()];
-}
-/**
- * The names of types one declaration's own syntax writes: in a type reference, a
- * heritage clause or a type query. A function body is not read, and neither is a
- * declaration nested in this one, which `nested` holds and which is read on its own.
- */
-function typeNamesOf(declaration, nested) {
-    const found = [];
-    const visit = (node) => {
-        if (node !== declaration && nested.has(node)) {
-            return;
-        }
-        if (isTypeReferenceNode(node)) {
-            found.push(isQualifiedName(node.typeName) ? node.typeName.right : node.typeName);
-        }
-        else if (isExpressionWithTypeArguments(node)) {
-            found.push(isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
-        }
-        else if (isTypeQueryNode(node)) {
-            found.push(isQualifiedName(node.exprName) ? node.exprName.right : node.exprName);
-        }
-        const body = isFunctionLikeDeclaration(node) ? node.body : undefined;
-        node.forEachChild((child) => {
-            if (child !== body) {
-                visit(child);
-            }
-        });
-    };
-    visit(declaration);
-    return found;
-}
-/**
- * Keeps every declaration the configuration names and returns every string that
- * named none, in configuration order. A string the configuration lists twice is one
- * configured root.
- */
-function configured(held, patterns, add) {
-    const unmatched = [];
-    for (const pattern of new Set(patterns)) {
-        const kind = isPattern(pattern) ? "pattern" : "configured";
-        let matched = false;
-        for (const symbol of held.symbols) {
-            if (matchRef(pattern, symbol.ref)) {
-                add(symbol.id, kind, pattern);
-                matched = true;
-            }
-        }
-        if (!matched) {
-            unmatched.push(pattern);
-        }
-    }
-    return unmatched;
-}
-/**
- * Every configured string that named no declaration in ANY project of the run, in
- * configuration order and each once.
- *
- * A finding about a configured root is about the configuration and not about a
- * declaration, so there is one per run: a string that names a declaration of one
- * project has named something, and the projects it named nothing in are not a
- * finding. A run with no project names nothing with any of them.
- */
-export function unmatchedEverywhere(patterns, perProject) {
-    return [...new Set(patterns)].filter((pattern) => perProject.every((project) => project.unmatched.includes(pattern)));
-}