@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/dist/src/conventions.js

@@ -1,907 +0,0 @@
-/**
- * The convention rows a run applies, and the files they root. A row applies to a
- * manifest that declares its enabling package when the installed package's version is
- * in the row's range; its globs are read against that manifest's directory, with every
- * directory a configuration property moves read from the property's literal value.
- * No configuration file is run.
- */
-import { isArrayLiteralExpression, isBinaryExpression, isCallExpression, isClassDeclaration, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableStatement, SyntaxKind, } from "@typescript/native/ast";
-import { lineOf } from "./component-files.js";
-import { CONVENTION_ROWS, } from "./convention-rows.js";
-import { documentStrings } from "./configuration-files.js";
-import { ancestors, dirnamePath, joinPath, normalizePath, relativePath, resolvePath, } from "./paths.js";
-import { satisfies } from "./version-range.js";
-import { bytewise } from "./text/compare.js";
-import { isRecord } from "./json-document.js";
-import { unwrapped } from "./unwrap.js";
-import { filesIn } from "./fs/tree.js";
-import { DEPENDENCY_SECTIONS, INSTALLED_PACKAGES, MANIFEST, readJSON } from "./fs/manifest.js";
-import { globExpression } from "./text/glob.js";
-import { yamlDocument } from "./text/yaml.js";
-const JSON_EXTENSION = ".json";
-/**
- * A configuration file its tool reads as a YAML document, read as the JSON document it
- * denotes. Its nodes' offsets are that JSON text's, so no move may read one: a failure's
- * line would name the wrong line.
- */
-const YAML_NAME = /\.ya?ml$/u;
-/** A configuration file with no extension that its tool reads as a JSON document. */
-const JSON_RC = /^\.[\w-]+rc$/u;
-/** The sections an installed package is required by, so its absence fails the run. */
-const REQUIRED_SECTIONS = ["dependencies", "devDependencies"];
-function declares(manifest, name, sections = DEPENDENCY_SECTIONS) {
-    if (!isRecord(manifest)) {
-        return false;
-    }
-    return sections.some((section) => {
-        const held = manifest[section];
-        return isRecord(held) && Object.hasOwn(held, name);
-    });
-}
-/**
- * The version the installed package's manifest names, read from the nearest
- * `node_modules` at or above `dir` that holds it, `""` where that manifest names
- * none, or `undefined` where no `node_modules` holds it.
- */
-function installedVersion(host, dir, name) {
-    for (const at of ancestors(dir)) {
-        const path = joinPath(at, INSTALLED_PACKAGES, name, MANIFEST);
-        if (host.kindOf(path) === "file") {
-            const manifest = readJSON(host, path);
-            const version = isRecord(manifest) ? manifest["version"] : undefined;
-            return typeof version === "string" ? version : "";
-        }
-    }
-    return undefined;
-}
-/** The key one property is written with, where it is written as a name or as literal text. */
-function keyOf(property) {
-    if (!isPropertyAssignment(property) && !isShorthandPropertyAssignment(property)) {
-        return undefined;
-    }
-    const { name } = property;
-    const key = isComputedPropertyName(name) ? name.expression : name;
-    if ((isIdentifier(key) && key === name) ||
-        isStringLiteral(key) ||
-        isNoSubstitutionTemplateLiteral(key)) {
-        return key.text;
-    }
-    return undefined;
-}
-/** Whether one member's computed name is no literal, so it may set any key. */
-function computesKey(member) {
-    const name = member.name;
-    if (name === undefined || !isComputedPropertyName(name)) {
-        return false;
-    }
-    const key = name.expression;
-    return !(isStringLiteral(key) || isNumericLiteral(key) || isNoSubstitutionTemplateLiteral(key));
-}
-/** The values one file's top-level variable declarations bind, by name. */
-function declaredValues(file) {
-    const values = new Map();
-    for (const statement of file.statements) {
-        if (isVariableStatement(statement)) {
-            for (const declaration of statement.declarationList.declarations) {
-                if (isIdentifier(declaration.name) && declaration.initializer !== undefined) {
-                    values.set(declaration.name.text, declaration.initializer);
-                }
-            }
-        }
-    }
-    return values;
-}
-function isModuleExports(node) {
-    return (isPropertyAccessExpression(node) &&
-        isIdentifier(node.expression) &&
-        node.expression.text === "module" &&
-        node.name.text === "exports");
-}
-/**
- * Every expression or declaration one file exports as its default, in any module syntax.
- * A JSON module's default export is its document's value.
- */
-function defaultExports(file) {
-    if (file.fileName.endsWith(JSON_EXTENSION)) {
-        return file.statements.flatMap((statement) => isExpressionStatement(statement) ? [statement.expression] : []);
-    }
-    const found = [];
-    for (const statement of file.statements) {
-        if (isExportAssignment(statement)) {
-            found.push(statement.expression);
-        }
-        else if ((isFunctionDeclaration(statement) || isClassDeclaration(statement)) &&
-            statement.modifiers?.some((one) => one.kind === SyntaxKind.DefaultKeyword) === true) {
-            found.push(statement);
-        }
-        else if (isExportDeclaration(statement) &&
-            statement.moduleSpecifier === undefined &&
-            statement.exportClause !== undefined &&
-            isNamedExports(statement.exportClause)) {
-            for (const element of statement.exportClause.elements) {
-                if (element.name.text === "default") {
-                    found.push(element.propertyName ?? element.name);
-                }
-            }
-        }
-        else if (isExpressionStatement(statement) &&
-            isBinaryExpression(statement.expression) &&
-            statement.expression.operatorToken.kind === SyntaxKind.EqualsToken &&
-            isModuleExports(statement.expression.left)) {
-            found.push(statement.expression.right);
-        }
-    }
-    return found;
-}
-/** The declarations whose name is a binding of the scope they are written in. */
-const BINDING_KINDS = new Set([
-    SyntaxKind.VariableDeclaration,
-    SyntaxKind.Parameter,
-    SyntaxKind.BindingElement,
-    SyntaxKind.FunctionDeclaration,
-    SyntaxKind.ClassDeclaration,
-    SyntaxKind.ImportClause,
-    SyntaxKind.ImportSpecifier,
-    SyntaxKind.NamespaceImport,
-    SyntaxKind.ImportEqualsDeclaration,
-]);
-/** Whether one file declares a binding named `require` at any depth, which shadows the global. */
-function declaresRequire(file) {
-    let found = false;
-    const visit = (node) => {
-        const name = node.name;
-        if (name !== undefined &&
-            isIdentifier(name) &&
-            name.text === "require" &&
-            BINDING_KINDS.has(node.kind)) {
-            found = true;
-        }
-        if (!found) {
-            node.forEachChild(visit);
-        }
-    };
-    file.forEachChild(visit);
-    return found;
-}
-/**
- * The top-level `const`, `let` and `var` declarations that bind a `require` of one module,
- * written with the module's name as its one string-literal argument, in a file that
- * declares no binding named `require`: each binds as an import of the module does.
- */
-function requireBindings(file, module) {
-    const found = [];
-    for (const statement of file.statements) {
-        if (!isVariableStatement(statement)) {
-            continue;
-        }
-        for (const declaration of statement.declarationList.declarations) {
-            const value = declaration.initializer === undefined ? undefined : unwrapped(declaration.initializer);
-            const [argument, ...rest] = value !== undefined && isCallExpression(value) ? value.arguments : [];
-            if (value === undefined ||
-                !isCallExpression(value) ||
-                !isIdentifier(value.expression) ||
-                value.expression.text !== "require" ||
-                argument === undefined ||
-                rest.length > 0 ||
-                !isStringLiteral(argument) ||
-                argument.text !== module) {
-                continue;
-            }
-            if (isIdentifier(declaration.name) || isObjectBindingPattern(declaration.name)) {
-                found.push(declaration.name);
-            }
-        }
-    }
-    return found.length > 0 && declaresRequire(file) ? [] : found;
-}
-/**
- * The first argument of every call one file makes to one module's export, through a
- * named or a namespace import; `undefined` for a call with no argument.
- */
-function optionsArguments(file, call) {
-    const names = new Set();
-    const namespaces = new Set();
-    for (const name of requireBindings(file, call.module)) {
-        if (isIdentifier(name)) {
-            namespaces.add(name.text);
-            continue;
-        }
-        for (const element of name.elements) {
-            const local = element.name;
-            const exported = element.propertyName ?? local;
-            if (element.dotDotDotToken === undefined &&
-                local !== undefined &&
-                isIdentifier(local) &&
-                exported !== undefined &&
-                (isIdentifier(exported) || isStringLiteral(exported)) &&
-                exported.text === call.export) {
-                names.add(local.text);
-            }
-        }
-    }
-    for (const statement of file.statements) {
-        const bindings = isImportDeclaration(statement)
-            ? statement.importClause?.namedBindings
-            : undefined;
-        if (bindings === undefined ||
-            !isImportDeclaration(statement) ||
-            !isStringLiteral(statement.moduleSpecifier) ||
-            statement.moduleSpecifier.text !== call.module) {
-            continue;
-        }
-        if (isNamespaceImport(bindings)) {
-            namespaces.add(bindings.name.text);
-            continue;
-        }
-        for (const element of bindings.elements) {
-            if ((element.propertyName ?? element.name).text === call.export) {
-                names.add(element.name.text);
-            }
-        }
-    }
-    const found = [];
-    const visit = (node) => {
-        if (isCallExpression(node)) {
-            const callee = unwrapped(node.expression);
-            const named = isIdentifier(callee) && names.has(callee.text);
-            const throughNamespace = isPropertyAccessExpression(callee) &&
-                isIdentifier(callee.expression) &&
-                namespaces.has(callee.expression.text) &&
-                callee.name.text === call.export;
-            if (named || throughNamespace) {
-                found.push(node.arguments[0]);
-            }
-        }
-        node.forEachChild(visit);
-    };
-    file.forEachChild(visit);
-    return found;
-}
-/**
- * The object literal one expression stands for, read through the file's top-level
- * declarations and, where `throughCalls`, through a call's first argument: `undefined`
- * for a call with no argument, and any other node where the expression is not written
- * out as an object literal.
- */
-function objectOf(node, declared, throughCalls, seen = new Set()) {
-    const at = unwrapped(node);
-    if (isIdentifier(at)) {
-        const value = declared.get(at.text);
-        if (value !== undefined && !seen.has(at.text)) {
-            return objectOf(value, declared, throughCalls, new Set([...seen, at.text]));
-        }
-    }
-    else if (throughCalls && isCallExpression(at)) {
-        const [first] = at.arguments;
-        return first === undefined ? undefined : objectOf(first, declared, throughCalls, seen);
-    }
-    return at;
-}
-/** The text of a string literal or a template literal with no substitution, or undefined. */
-function literalText(node) {
-    const at = unwrapped(node);
-    return isStringLiteral(at) || isNoSubstitutionTemplateLiteral(at) ? at.text : undefined;
-}
-/**
- * The literal texts one value at a path's end writes: the literal itself, or, where
- * `elements`, each element of an array literal of literals. Undefined for any other value.
- */
-function literalTexts(held, elements) {
-    const one = literalText(held);
-    if (one !== undefined) {
-        return [one];
-    }
-    if (!elements || !isArrayLiteralExpression(held)) {
-        return undefined;
-    }
-    const texts = held.elements.map(literalText);
-    return texts.every((text) => text !== undefined) ? texts : undefined;
-}
-/**
- * Reads the values at one path of keys below one object literal into `values`, and
- * answers the first member that does not write its value out: a spread, a value that is
- * not a literal at the path's end, or one that is not an object literal before it.
- */
-function readPath(object, keys, values, elements) {
-    const [key, ...rest] = keys;
-    for (const member of object.properties) {
-        if (isSpreadAssignment(member) || computesKey(member)) {
-            return member;
-        }
-        if (keyOf(member) !== key) {
-            continue;
-        }
-        const held = isPropertyAssignment(member) ? unwrapped(member.initializer) : undefined;
-        if (rest.length === 0) {
-            const texts = held === undefined ? undefined : literalTexts(held, elements);
-            if (texts === undefined) {
-                return member;
-            }
-            values.push(...texts);
-        }
-        else {
-            if (held === undefined || !isObjectLiteralExpression(held)) {
-                return member;
-            }
-            const failed = readPath(held, rest, values, elements);
-            if (failed !== undefined) {
-                return failed;
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Every value one file writes at one property's path inside the objects it is read from,
- * as {@link readProperty} reads them, whatever else the path holds.
- */
-function valuesAt(file, property, call) {
-    const declared = declaredValues(file);
-    const objects = call === undefined
-        ? defaultExports(file).map((one) => objectOf(one, declared, true))
-        : optionsArguments(file, call).map((one) => one === undefined ? undefined : objectOf(one, declared, false));
-    const found = [];
-    const visit = (object, keys) => {
-        if (!isObjectLiteralExpression(object)) {
-            return;
-        }
-        const [key, ...rest] = keys;
-        for (const member of object.properties) {
-            if (!isPropertyAssignment(member) || keyOf(member) !== key) {
-                continue;
-            }
-            const held = unwrapped(member.initializer);
-            if (rest.length > 0) {
-                visit(held, rest);
-            }
-            else {
-                found.push(held);
-            }
-        }
-    };
-    for (const object of objects) {
-        if (object !== undefined) {
-            visit(object, property.split("."));
-        }
-    }
-    return found;
-}
-/** The string literals among values: each value itself, or each element of an array value. */
-function stringsAt(file, property, call) {
-    return valuesAt(file, property, call).flatMap((held) => {
-        if (literalText(held) !== undefined) {
-            return [held];
-        }
-        return isArrayLiteralExpression(held)
-            ? held.elements.map(unwrapped).filter((one) => literalText(one) !== undefined)
-            : [];
-    });
-}
-/** Whether one value holds a helper setting's value, as {@link HelperReading} states it. */
-function holdsValue(held, value) {
-    if (value === true) {
-        return held.kind === SyntaxKind.TrueKeyword;
-    }
-    if (literalText(held) === value) {
-        return true;
-    }
-    return (isArrayLiteralExpression(held) &&
-        held.elements.some((element) => {
-            const one = unwrapped(element);
-            const first = isArrayLiteralExpression(one) ? one.elements[0] : one;
-            return first !== undefined && literalText(first) === value;
-        }));
-}
-/** The directory one file's test-file strings are read against, as {@link TestFileReading} states it. */
-function testFileRoot(file, dir, reading) {
-    for (const property of reading.roots) {
-        const values = valuesAt(file, property, reading.call);
-        if (values.length > 0) {
-            const texts = new Set(values.map(literalText));
-            const [text] = texts;
-            return texts.size === 1 && text !== undefined ? resolvePath(dir, text) : undefined;
-        }
-    }
-    return dir;
-}
-/** The files an applied row's test-file properties name. */
-function testFilesNamed(host, parse, dir, readings, into) {
-    for (const reading of readings) {
-        for (const { file } of readingFiles(host, parse, dir, reading.files)) {
-            const at = testFileRoot(file, dir, reading);
-            if (at === undefined) {
-                continue;
-            }
-            for (const node of stringsAt(file, reading.property, reading.call)) {
-                const text = literalText(node);
-                if (text !== undefined && text !== "") {
-                    into.add(resolvePath(at, text));
-                }
-            }
-        }
-    }
-}
-/** The strings an applied row's selection keys hold, added per configuration file to `into`. */
-function selectedStrings(host, parse, dir, readings, into) {
-    for (const reading of readings) {
-        for (const { name, file } of readingFiles(host, parse, dir, reading.files)) {
-            const path = joinPath(dir, name);
-            const held = into.get(path) ?? { starts: new Set(), texts: [] };
-            for (const node of stringsAt(file, reading.property, reading.call)) {
-                held.starts.add(node.getStart());
-                held.texts.push(literalText(node) ?? "");
-            }
-            into.set(path, held);
-        }
-    }
-}
-/**
- * The dependencies one manifest declares that a string at any depth of one of its members
- * names, alone or followed by `/` and a subpath, a member's name aside.
- */
-function manifestKeyUses(manifest, keys) {
-    if (!isRecord(manifest)) {
-        return [];
-    }
-    const declared = DEPENDENCY_SECTIONS.flatMap((section) => {
-        const held = manifest[section];
-        return isRecord(held) ? Object.keys(held) : [];
-    });
-    const strings = keys.flatMap((key) => documentStrings(manifest[key]));
-    return declared.filter((name) => strings.some((text) => text === name || text.startsWith(`${name}/`)));
-}
-/** The extensions an entry a manifest entry key names without one may carry. */
-const ENTRY_EXTENSIONS = "{js,jsx,mjs,cjs,ts,tsx,mts,cts}";
-/** The characters that make a manifest string a pattern rather than a directory's name. */
-const PATTERN = /[*?{}[\]]/u;
-/**
- * The entry globs one applied row's manifest entry keys write, below the manifest's
- * directory: a directory's every module, or a file with or without an extension. A string
- * that leaves the directory names nothing.
- */
-function manifestEntryGlobs(manifest, keys) {
-    const at = (value, path) => {
-        const [key, ...rest] = path;
-        if (key === undefined) {
-            return [value];
-        }
-        if (!isRecord(value)) {
-            return [];
-        }
-        const next = key === "*" ? Object.values(value) : Object.hasOwn(value, key) ? [value[key]] : [];
-        return next.flatMap((one) => at(one, rest));
-    };
-    return keys.flatMap(({ key, directory }) => at(manifest, key.split(".")).flatMap((value) => documentStrings(value).flatMap((text) => {
-        const path = normalizePath(text)
-            .replace(/^(?:\.\/)+/u, "")
-            .replace(/\/+$/u, "");
-        if (path === "" || path === ".." || path.startsWith("../") || path.startsWith("/")) {
-            return [];
-        }
-        if (!directory) {
-            return [path, `${path}.${ENTRY_EXTENSIONS}`];
-        }
-        return PATTERN.test(path) ? [] : [`${path}/**/*.${ENTRY_EXTENSIONS}`];
-    })));
-}
-/**
- * Every value one file writes at one property's path inside the object it is read from:
- * the options argument of every call `call` names, or the file's default export. A string
- * literal or a template literal with no substitution is the value, and so is each element
- * of an array literal of them where `elements`. A read object, or an object along the
- * path, that is not written out as an object literal, or that spreads another object into
- * itself, is not a literal, and neither is any other value at the path.
- */
-export function readProperty(file, property, call, elements = false) {
-    const declared = declaredValues(file);
-    const objects = call === undefined
-        ? defaultExports(file).map((one) => objectOf(one, declared, true))
-        : optionsArguments(file, call).map((one) => one === undefined ? undefined : objectOf(one, declared, false));
-    const values = [];
-    for (const object of objects) {
-        if (object === undefined) {
-            continue;
-        }
-        const notLiteral = isObjectLiteralExpression(object)
-            ? readPath(object, property.split("."), values, elements)
-            : object;
-        if (notLiteral !== undefined) {
-            return { values, notLiteral };
-        }
-    }
-    return { values };
-}
-/** A directory below a manifest's, `.` for the directory itself, `undefined` outside it. */
-function below(dir, path) {
-    return normalizePath(path) === normalizePath(dir) ? "." : relativePath(dir, path);
-}
-/**
- * Every text a template stands for, each placeholder replaced by every directory its move
- * resolved to. A placeholder whose move resolved outside the manifest's directory leaves
- * the text standing for nothing.
- */
-function expand(template, resolved) {
-    const match = /<([A-Za-z]+)>/u.exec(template);
-    if (match === null) {
-        return [template];
-    }
-    const [placeholder, id = ""] = match;
-    const out = [];
-    for (const value of resolved.get(id) ?? []) {
-        if (value === undefined) {
-            continue;
-        }
-        const replaced = value === "." && template.startsWith(`${placeholder}/`, match.index)
-            ? template.replace(`${placeholder}/`, "")
-            : template.replace(placeholder, value);
-        out.push(...expand(replaced, resolved));
-    }
-    return out;
-}
-/** The configuration files in one directory that one glob names, by name. */
-function configurationFiles(host, dir, glob) {
-    const expression = globExpression(glob);
-    return filesIn(host, dir, (name) => expression.test(name));
-}
-function resolveMove(host, parse, dir, row, move, resolved) {
-    const set = [];
-    for (const reading of move.readings) {
-        for (const { name, text, file } of readingFiles(host, parse, dir, reading.files)) {
-            const read = readProperty(file, reading.property, reading.call);
-            if (read.notLiteral !== undefined) {
-                const line = lineOf(text, read.notLiteral.getStart());
-                return {
-                    failure: `${name}:${String(line)} sets ${reading.property}, which moves a directory ` +
-                        `the convention row ${row.name} reads, to a value that is not a string literal: ` +
-                        `write it as a literal, or name ${row.name} in ts.disabled_conventions and its ` +
-                        `files in ts.entry_files`,
-                };
-            }
-            set.push(...read.values);
-        }
-    }
-    const dirs = [];
-    for (const base of expand(move.base ?? ".", resolved)) {
-        const against = joinPath(dir, base);
-        const texts = set.length > 0 ? set : move.defaults.flatMap((one) => expand(one, resolved));
-        for (const text of texts) {
-            dirs.push(below(dir, resolvePath(against, text)));
-        }
-    }
-    return { dirs: [...new Set(dirs)] };
-}
-/** The texts each configuration file a reading names holds, parsed, in name order. */
-function readingFiles(host, parse, dir, files) {
-    const found = [];
-    for (const glob of files) {
-        for (const name of configurationFiles(host, dir, glob)) {
-            const path = joinPath(dir, name);
-            let text;
-            try {
-                text = host.readFile(path);
-            }
-            catch {
-                continue;
-            }
-            if (YAML_NAME.test(name)) {
-                const value = yamlDocument(text);
-                if (value !== undefined) {
-                    const json = JSON.stringify(value);
-                    found.push({ name, text: json, file: parse(`${path}${JSON_EXTENSION}`, json) });
-                }
-                continue;
-            }
-            found.push({
-                name,
-                text,
-                file: parse(JSON_RC.test(name) ? `${path}${JSON_EXTENSION}` : path, text),
-            });
-        }
-    }
-    return found;
-}
-/**
- * The dependencies one manifest declares that an applied row's short names use: the
- * package each literal value stands for, and, for a value that is not a literal, every
- * declared dependency the row's package name stands for with some value.
- */
-function shortNameUses(host, parse, dir, manifest, readings) {
-    const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
-        const held = isRecord(manifest) ? manifest[section] : undefined;
-        return isRecord(held) ? Object.keys(held) : [];
-    }));
-    const used = new Set();
-    for (const reading of readings) {
-        const [before = "", after = ""] = reading.package.split("{}");
-        for (const { file } of readingFiles(host, parse, dir, reading.files)) {
-            const read = readProperty(file, reading.property, reading.call, true);
-            for (const value of read.values) {
-                used.add(`${before}${value}${after}`);
-            }
-            if (read.notLiteral !== undefined) {
-                for (const name of declared) {
-                    if (name.length >= before.length + after.length &&
-                        name.startsWith(before) &&
-                        name.endsWith(after)) {
-                        used.add(name);
-                    }
-                }
-            }
-        }
-    }
-    return [...used].filter((name) => declared.has(name)).sort(bytewise);
-}
-/**
- * The package one value of a prefixed-name reading names, or none: ESLint's own naming,
- * https://github.com/eslint/eslintrc/blob/main/lib/shared/naming.js
- */
-function prefixedPackage(value, reading) {
-    const { prefix, marker } = reading;
-    let name;
-    if (marker === undefined) {
-        if (value.includes(":") || value.startsWith(".") || value.startsWith("/")) {
-            return undefined;
-        }
-        const parts = value.split("/");
-        name = (value.startsWith("@") ? parts.slice(0, 2) : parts.slice(0, 1)).join("/");
-    }
-    else {
-        if (!value.startsWith(marker) || !value.includes("/", marker.length)) {
-            return undefined;
-        }
-        name = value.slice(marker.length, value.lastIndexOf("/"));
-    }
-    if (name === "") {
-        return undefined;
-    }
-    if (!name.startsWith("@")) {
-        return name.startsWith(`${prefix}-`) ? name : `${prefix}-${name}`;
-    }
-    const [scope, rest] = name.split("/");
-    if (rest === undefined || rest === "" || rest === prefix) {
-        return `${scope ?? name}/${prefix}`;
-    }
-    return rest.startsWith(`${prefix}-`) ? name : `${scope ?? name}/${prefix}-${rest}`;
-}
-/** The declared dependencies an applied row's prefixed names use. */
-function prefixedNameUses(host, parse, dir, manifest, readings) {
-    const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
-        const held = isRecord(manifest) ? manifest[section] : undefined;
-        return isRecord(held) ? Object.keys(held) : [];
-    }));
-    const used = new Set();
-    for (const reading of readings) {
-        for (const { file } of readingFiles(host, parse, dir, reading.files)) {
-            for (const value of readProperty(file, reading.property, reading.call, true).values) {
-                const named = prefixedPackage(value, reading);
-                if (named !== undefined && declared.has(named)) {
-                    used.add(named);
-                }
-            }
-        }
-    }
-    return [...used].sort(bytewise);
-}
-/** The declared dependencies an applied row's helper settings use. */
-function helperUses(host, parse, dir, manifest, readings) {
-    const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
-        const held = isRecord(manifest) ? manifest[section] : undefined;
-        return isRecord(held) ? Object.keys(held) : [];
-    }));
-    return readings
-        .filter((reading) => declared.has(reading.package) &&
-        readingFiles(host, parse, dir, reading.files).some(({ file }) => valuesAt(file, reading.property, reading.call).some((held) => holdsValue(held, reading.value))))
-        .map((reading) => reading.package);
-}
-/**
- * The dependencies one manifest declares that an applied row's package keys use: each
- * whose name a string under a member of a key's name equals, or begins followed by `/` or
- * by `:` and a name. A member's own name is no such string.
- */
-function packageKeyUses(host, parse, dir, manifest, keys) {
-    const declared = DEPENDENCY_SECTIONS.flatMap((section) => {
-        const held = isRecord(manifest) ? manifest[section] : undefined;
-        return isRecord(held) ? Object.keys(held) : [];
-    });
-    const strings = [];
-    const collect = (node) => {
-        const text = literalText(node);
-        if (text !== undefined) {
-            strings.push(text);
-        }
-        else if (isPropertyAssignment(node)) {
-            collect(node.initializer);
-        }
-        else {
-            node.forEachChild(collect);
-        }
-    };
-    for (const { key, files } of keys) {
-        const visit = (node) => {
-            if (isPropertyAssignment(node) && keyOf(node) === key) {
-                collect(node.initializer);
-            }
-            node.forEachChild(visit);
-        };
-        for (const { file } of readingFiles(host, parse, dir, files)) {
-            const values = declaredValues(file);
-            for (const one of defaultExports(file)) {
-                const object = objectOf(one, values, true);
-                if (object !== undefined) {
-                    visit(object);
-                }
-            }
-        }
-    }
-    return declared.filter((name) => strings.some((text) => text === name ||
-        text.startsWith(`${name}/`) ||
-        (text.startsWith(`${name}:`) && text.length > name.length + 1)));
-}
-/**
- * What the rows decide over the manifests the analysis reads. A row `disabled` names
- * is skipped before anything is read for it.
- */
-export function readConventions(host, parse, manifests, disabled, rows = CONVENTION_ROWS) {
-    const applied = [];
-    const globs = [];
-    const generated = [];
-    const failures = [];
-    const uses = new Set();
-    const selected = new Map();
-    const testFiles = new Set();
-    for (const manifest of manifests) {
-        const declared = readJSON(host, joinPath(manifest.dir, MANIFEST));
-        const versions = new Map();
-        const missing = new Set();
-        for (const row of rows) {
-            if (disabled.includes(row.name) || !declares(declared, row.package)) {
-                continue;
-            }
-            if (!versions.has(row.package)) {
-                versions.set(row.package, installedVersion(host, manifest.dir, row.package));
-            }
-            const version = versions.get(row.package);
-            if (version === undefined) {
-                if (missing.has(row.package) ||
-                    manifest.nested === true ||
-                    !declares(declared, row.package, REQUIRED_SECTIONS)) {
-                    continue;
-                }
-                missing.add(row.package);
-                failures.push({
-                    dir: manifest.dir,
-                    failure: {
-                        failureClass: "missing-module",
-                        detail: `${manifest.path} declares ${row.package}, which no node_modules at or ` +
-                            `above its directory holds: run the package manager's install`,
-                    },
-                });
-                continue;
-            }
-            if (!satisfies(version, row.range)) {
-                continue;
-            }
-            const resolved = new Map();
-            let failed;
-            for (const move of row.moves) {
-                const result = resolveMove(host, parse, manifest.dir, row, move, resolved);
-                if ("failure" in result) {
-                    failed = result.failure;
-                    break;
-                }
-                resolved.set(move.id, result.dirs);
-            }
-            if (failed !== undefined) {
-                const where = dirnamePath(manifest.path);
-                failures.push({
-                    dir: manifest.dir,
-                    failure: {
-                        failureClass: "convention-not-literal",
-                        detail: where === "." ? failed : `${where}/${failed}`,
-                    },
-                });
-                continue;
-            }
-            applied.push({
-                name: row.name,
-                package: row.package,
-                version,
-                manifest: manifest.path,
-            });
-            for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
-                uses.add(name);
-            }
-            const prefixed = row.prefixedNames ?? [];
-            for (const name of prefixedNameUses(host, parse, manifest.dir, declared, prefixed)) {
-                uses.add(name);
-            }
-            const keys = row.packageKeys ?? [];
-            for (const name of packageKeyUses(host, parse, manifest.dir, declared, keys)) {
-                uses.add(name);
-            }
-            for (const name of manifestKeyUses(declared, row.manifestKeys ?? [])) {
-                uses.add(name);
-            }
-            for (const name of helperUses(host, parse, manifest.dir, declared, row.helpers ?? [])) {
-                uses.add(name);
-            }
-            selectedStrings(host, parse, manifest.dir, row.selections ?? [], selected);
-            testFilesNamed(host, parse, manifest.dir, row.testFiles ?? [], testFiles);
-            const excludes = [
-                ...new Set((row.excludes ?? []).flatMap((one) => expand(one, resolved))),
-            ].map(globExpression);
-            for (const below of new Set((row.generated ?? []).flatMap((one) => expand(one, resolved)))) {
-                generated.push({ dir: manifest.dir, row: row.name, below });
-            }
-            const written = [
-                ...row.entries.flatMap((entry) => expand(entry, resolved)),
-                ...manifestEntryGlobs(declared, row.manifestEntries ?? []),
-            ];
-            for (const glob of new Set(written)) {
-                globs.push({
-                    dir: manifest.dir,
-                    row: row.name,
-                    expression: globExpression(glob),
-                    excludes,
-                });
-            }
-        }
-    }
-    const unique = [...new Map(applied.map((one) => [JSON.stringify(one), one])).values()];
-    unique.sort((a, b) => bytewise(a.name, b.name) ||
-        bytewise(a.manifest, b.manifest) ||
-        bytewise(JSON.stringify(a), JSON.stringify(b)));
-    return {
-        applied: unique,
-        globs,
-        generated,
-        failures,
-        uses: [...uses].sort(bytewise),
-        selected,
-        testFiles,
-    };
-}
-/**
- * Every own file of one project below a directory an applied row names as generated, by
- * its path below the target root, with the name of the first such row.
- */
-export function generatedFiles(conventions, files) {
-    const found = new Map();
-    for (const { dir, row, below } of conventions.generated) {
-        const root = joinPath(dir, below);
-        for (const [path, file] of files.byPath) {
-            if (!found.has(path) && relativePath(root, file.fileName) !== undefined) {
-                found.set(path, row);
-            }
-        }
-    }
-    return found;
-}
-/** Every own file of one project an applied row's globs match, once per row. */
-export function conventionEntries(conventions, files) {
-    const found = new Map();
-    for (const glob of conventions.globs) {
-        for (const file of files.byName.values()) {
-            const matched = [file.fileName, ...files.writtenAs(file)].some((name) => {
-                const path = relativePath(glob.dir, name);
-                return (path !== undefined &&
-                    glob.expression.test(path) &&
-                    !glob.excludes.some((one) => one.test(path)));
-            });
-            if (matched) {
-                found.set(`${file.fileName}\u0000${glob.row}`, { file, row: glob.row });
-            }
-        }
-    }
-    return [...found.values()];
-}
-/**
- * The failures the rows met that hold for one configuration: those of a manifest whose
- * directory holds the configuration file or one of the files the project owns.
- */
-export function conventionFailuresFor(conventions, configFile, ownFiles) {
-    return conventions.failures
-        .filter(({ dir }) => below(dir, dirnamePath(configFile)) !== undefined ||
-        ownFiles.some((file) => relativePath(dir, file) !== undefined))
-        .map(({ failure }) => failure);
-}