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

package/dist/src/dependencies.js

@@ -8,14 +8,16 @@
  */
 import { isArrayLiteralExpression, isCallExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/ast";
 import { automaticTypes } from "./automatic-types.js";
-import { configurationFiles, declaredIn as declaredBeside, dependenciesNamed, moduleStrings, outsideChain, } from "./configuration-files.js";
+import { declaredIn as declaredBeside, dependenciesNamed, moduleStrings, outsideChain, } from "./entries/configuration-files.js";
 import { nodeKey } from "./inventory.js";
 import { packageScope } from "./load/package-scope.js";
 import { ancestors, dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
-import { manifestCommands, nodemonTexts } from "./manifest.js";
-import { commandFileTexts, workflowCommands } from "./workflow-steps.js";
+import { manifestCommands, nodemonTexts } from "./roots/manifest.js";
+import { writtenName } from "./platform-calls.js";
+import { callsPlatform } from "./platform-symbols.js";
+import { parenthesesRemoved } from "./unwrap.js";
 import { pathsNamed, preloadedPackages, readCommands, } from "./commands/read.js";
 import { heldNames } from "./text/named-files.js";
 import { bytewise } from "./text/compare.js";
@@ -202,10 +204,11 @@ function bindingsOf(node) {
  * Every package one project needs, and which declaration each use is written in.
  * One local walk and one batched resolution per file: a use of an import binding is
  * an identifier resolving to the binding's own symbol, so a local declaration that
- * shadows the name is not one. A string of a configuration file uses each dependency
- * the manifest beside the file declares that it spells.
+ * shadows the name is not one. A string of a configuration file, as the entry sources
+ * read them in `configuration`, uses each dependency the manifest beside the file
+ * declares that it spells.
  */
-export function projectNeeds(project, held, host, targetRoot, parse) {
+export function projectNeeds(project, held, host, targetRoot, parse, configuration, workflows) {
     const programPackages = new Set();
     for (const name of project.program.getSourceFileNames()) {
         const named = packageOfPath(name);
@@ -256,7 +259,6 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
         return names;
     };
     const files = sourceFilesOf(project, targetRoot);
-    const configuration = configurationFiles(host, targetRoot, files, parse);
     for (const { file, manifestDir } of configuration.modules) {
         const names = declaredAt(joinPath(manifestDir, MANIFEST));
         for (const { node, text } of moduleStrings(file)) {
@@ -271,7 +273,7 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
             }
         }
     }
-    const ranFiles = outsideChain(host, targetRoot, files, parse, scriptRunFiles(host, targetRoot, files));
+    const ranFiles = outsideChain(host, targetRoot, files, parse, scriptRunFiles(host, targetRoot, files, workflows));
     for (const { file, manifestDirs } of [...configuration.outside, ...ranFiles]) {
         for (const manifestDir of manifestDirs) {
             const names = declaredAt(joinPath(manifestDir, MANIFEST));
@@ -288,7 +290,7 @@ export function projectNeeds(project, held, host, targetRoot, parse) {
  * workflow step or git hook names, with the target root's: a path `pathsNamed` reads, below the
  * target root and in no `node_modules`.
  */
-function scriptRunFiles(host, targetRoot, files) {
+function scriptRunFiles(host, targetRoot, files, workflows) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const dirs = new Set([root]);
     for (const name of files.byName.keys()) {
@@ -300,12 +302,7 @@ function scriptRunFiles(host, targetRoot, files) {
         }
     }
     const named = new Map([
-        [
-            root,
-            workflowReadings(host, root)
-                .flatMap(pathsNamed)
-                .map((one) => one.path),
-        ],
+        [root, workflows.readings.flatMap(pathsNamed).map((one) => one.path)],
     ]);
     for (const dir of dirs) {
         const read = readDocument(host, joinPath(dir, MANIFEST));
@@ -341,19 +338,9 @@ function manifestUses(host, dir, manifest) {
     return { ...uses, held: [uses.held, ...texts].join("\n") };
 }
 /** What the target root's workflow steps, git hooks and recipes use, held with their files' whole text. */
-function workflowUses(host, targetRoot) {
-    const uses = usesOf(workflowReadings(host, targetRoot));
-    return { ...uses, held: [uses.held, ...commandFileTexts(host, targetRoot)].join("\n") };
-}
-/**
- * What the target root's workflow steps, git hooks, hook managers and recipes run, each held
- * with the directory the file writes for it.
- */
-function workflowReadings(host, targetRoot) {
-    return workflowCommands(host, targetRoot).map(({ text, dir, writtenDirectory }) => {
-        const reading = readCommands(text, dir);
-        return { ...reading, held: [reading.held, writtenDirectory ?? ""].join("\n") };
-    });
+function workflowUses(workflows) {
+    const uses = usesOf(workflows.readings);
+    return { ...uses, held: [uses.held, ...workflows.texts].join("\n") };
 }
 function usesOf(readings) {
     return {
@@ -439,7 +426,15 @@ function fileNeeds(project, held, file, { programPackages, automatic }, use) {
     if (names.size > 0 || automatic.globals.size > 0) {
         visit(file);
     }
-    const asked = [...specifiers, ...bindings.map(({ node }) => node), ...candidates, ...globals];
+    const loads = runtimeLoads(file);
+    const callees = loads.flatMap((load) => load.callees);
+    const asked = [
+        ...specifiers,
+        ...bindings.map(({ node }) => node),
+        ...candidates,
+        ...globals,
+        ...callees,
+    ];
     const handles = asked.map((node) => project.handle(node));
     const resolved = project.symbolsAt(handles);
     const packagesOf = new Map();
@@ -510,33 +505,69 @@ function fileNeeds(project, held, file, { programPackages, automatic }, use) {
     for (const reference of file.typeReferenceDirectives) {
         use(ownersOf(file, held, file), typePackages(reference.fileName, programPackages));
     }
-    for (const specifier of resolvedSpecifiers(file)) {
-        const named = packageOfSpecifier(specifier.text);
-        if (named !== undefined) {
+    // A callee the checker leaves unanswered may be a require, so its call holds the
+    // dependency it names by live code, as program.33 holds one.
+    const calleesAt = unresolvedAt + globals.length;
+    const decided = new Map();
+    const requires = new Set();
+    const unansweredCallees = new Set();
+    callees.forEach((callee, index) => {
+        const symbol = resolved[calleesAt + index];
+        if (symbol === UNANSWERED) {
+            unansweredCallees.add(callee);
+            return;
+        }
+        // The decision reads the callee's symbol and its written name, and nothing else of it.
+        const key = symbol === undefined ? undefined : `${symbol.id}\u0000${callee.text}`;
+        const answer = (key === undefined ? undefined : decided.get(key)) ??
+            callsPlatform(project, "require", callee, symbol, () => undefined);
+        if (key !== undefined) {
+            decided.set(key, answer);
+        }
+        if (answer) {
+            requires.add(callee);
+        }
+    });
+    for (const { specifier, named, callees: through } of loads) {
+        if (through.length === 0 || through.some((one) => requires.has(one))) {
             use(ownersOf(file, held, specifier), [named]);
         }
+        else if (through.some((one) => unansweredCallees.has(one))) {
+            use([PROJECT_OWNER], [named]);
+        }
     }
     return resolved.slice(0, specifiers.length).includes(UNANSWERED);
 }
 /**
- * The literal specifiers one file asks the runtime to resolve, through `import.meta.resolve`
- * or `require.resolve`, each of which needs the package it names installed.
+ * The calls one file may load or resolve a package with at run time, each of whose first
+ * argument is literal text naming a package: a `require()` call, which the compiler lists among
+ * a file's imports only in a JavaScript file and only through the bare name; a `.resolve` of
+ * another name, which needs it where that name is a `require`; and `import.meta.resolve` or
+ * a `.resolve` of the name `require`, whatever it names, a use where it stands.
  */
-function resolvedSpecifiers(file) {
+function runtimeLoads(file) {
     const found = [];
-    if (!file.text.includes(".resolve(")) {
-        return found;
-    }
     const visit = (node) => {
-        if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
-            const callee = node.expression;
+        if (isCallExpression(node)) {
             const [argument] = node.arguments;
-            const receiver = callee.expression;
-            const resolving = callee.name.text === "resolve" &&
-                ((isMetaProperty(receiver) && receiver.name.text === "meta") ||
-                    (isIdentifier(receiver) && receiver.text === "require"));
-            if (resolving && argument !== undefined && isLiteralText(argument)) {
-                found.push(argument);
+            if (argument !== undefined && isLiteralText(argument)) {
+                const named = packageOfSpecifier(argument.text);
+                const callee = parenthesesRemoved(node.expression);
+                const receiver = isPropertyAccessExpression(callee) && callee.name.text === "resolve"
+                    ? parenthesesRemoved(callee.expression)
+                    : undefined;
+                const stands = receiver !== undefined &&
+                    ((isMetaProperty(receiver) && receiver.name.text === "meta") ||
+                        (isIdentifier(receiver) && receiver.text === "require"));
+                const callees = stands
+                    ? []
+                    : [
+                        writtenName(callee),
+                        receiver === undefined ? undefined : writtenName(receiver),
+                    ].filter((one) => one !== undefined);
+                if (named !== undefined && (stands || callees.length > 0)) {
+                    found.push({ specifier: argument, named, callees });
+                }
             }
         }
         node.forEachChild(visit);
@@ -727,7 +758,7 @@ function addNeededPeers(declared, peers, needed, ran) {
  * manifest declares nothing, nor does a nested package's uninstalled dependency, because
  * no run requires a nested package to be installed.
  */
-export function dependenciesOf(host, targetRoot, perProject, candidates, members = [], unbuiltMembers = [], nested = []) {
+export function dependenciesOf(host, targetRoot, workflows, perProject, candidates, members = [], unbuiltMembers = [], nested = []) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
     const scopeOf = packageScope(host, targetRoot);
     const manifests = new Map([[root, MANIFEST]]);
@@ -744,7 +775,7 @@ export function dependenciesOf(host, targetRoot, perProject, candidates, members
             unbuilt.add(path);
         }
     }
-    const workflow = workflowUses(host, targetRoot);
+    const workflow = workflowUses(workflows);
     const declared = [];
     const ran = new Set();
     const peers = new Map();

package/dist/src/entries/build-scripts.js

@@ -0,0 +1,222 @@
+/**
+ * The files a bundler's JavaScript API builds from, read from the build scripts a
+ * manifest's scripts run: the strings an options object passes as the bundler's entries.
+ * A script is read without running it, so a value that is not written out, a computed
+ * path or an options object built at run time among them, names nothing.
+ */
+import { isArrowFunction, isCallExpression, isConstructorDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNewExpression, isSetAccessorDeclaration, isVariableDeclaration, } from "@typescript/native/ast";
+import { declarationOf, membersNamed, staticModule } from "./static-module.js";
+import { filesNamedBy } from "./configuration-files.js";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { unwrapped } from "../unwrap.js";
+import { holdsManifest, inInstalledPackages, manifestAt } from "../fs/manifest.js";
+import { globExpression } from "../text/glob.js";
+import { pathsNamed, readCommands } from "../commands/read.js";
+import { manifestCommands } from "../roots/manifest.js";
+import { extensionOf, MODULE_EXTENSIONS } from "../extensions.js";
+/**
+ * The bundlers whose build call names its entries: esbuild resolves `entryPoints` against
+ * `absWorkingDir` (https://esbuild.github.io/api/#working-directory), webpack `entry`
+ * against `context` (https://webpack.js.org/configuration/entry-context/), and Rollup
+ * `input` against the working directory, each the manifest's directory when its script runs.
+ */
+const BUNDLERS = [
+    {
+        module: "esbuild",
+        calls: ["build", "buildSync", "context"],
+        option: "entryPoints",
+        base: "absWorkingDir",
+        paths: true,
+    },
+    { module: "webpack", calls: ["default"], option: "entry", base: "context", paths: false },
+    { module: "rollup", calls: ["rollup", "watch"], option: "input", base: "", paths: true },
+];
+/** The one value an object writes last for a key, undefined where it writes none or may hide it. */
+function lastMember(object, key) {
+    return membersNamed(object, key)?.at(-1);
+}
+/**
+ * The path one entry value writes, read against `dir`: a literal, or a join of the
+ * script's own directory and literals, read against that directory.
+ */
+function pathOf(value, dir, scriptDir) {
+    if (value.kind === "text") {
+        const { text } = value;
+        const request = !text.startsWith("./") && !text.startsWith("../") && !text.startsWith("/");
+        return { path: resolvePath(dir, text), text, request };
+    }
+    if (value.kind === "directory") {
+        const joined = value.segments.join("/");
+        return { path: resolvePath(scriptDir, joined), text: joined, request: false };
+    }
+    return undefined;
+}
+/** The entry values one entries option writes: a value, an array of them, an object of them. */
+function entryValues(value) {
+    if (value.kind === "array") {
+        return value.elements.flatMap(entryValues);
+    }
+    if (value.kind === "object") {
+        const imported = lastMember(value, "import") ?? lastMember(value, "in");
+        if (imported !== undefined) {
+            return entryValues(imported);
+        }
+        return value.members.flatMap((member) => entryValues(member.value));
+    }
+    return [value];
+}
+/** The own files one entry string names, read as `api` reads it. */
+function entriesNamed(files, api, entry) {
+    if (!api.paths && entry.request) {
+        return [];
+    }
+    if (api.paths && /[*?[{]/u.test(entry.text)) {
+        const expression = globExpression(entry.path);
+        return [...files.byName.values()].filter((file) => expression.test(file.fileName));
+    }
+    const dir = dirnamePath(entry.path);
+    return filesNamedBy(files, dir, entry.path.slice(dir.length + 1));
+}
+/** Whether one node is a function, whose body runs only where something calls it. */
+function isFunction(node) {
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isArrowFunction(node) ||
+        isMethodDeclaration(node) ||
+        isConstructorDeclaration(node) ||
+        isGetAccessorDeclaration(node) ||
+        isSetAccessorDeclaration(node));
+}
+/**
+ * The calls one build script runs: those of its top level, and those of each function a
+ * call it runs calls or passes on, as a callee, an argument or a function called where it
+ * is written, a name read through to the function it declares.
+ */
+function runCalls(file, each) {
+    const ran = new Set();
+    const run = (fn) => {
+        if (!ran.has(fn)) {
+            ran.add(fn);
+            fn.forEachChild(visit);
+        }
+    };
+    const runs = (node) => {
+        const at = unwrapped(node);
+        const declared = isIdentifier(at) ? declarationOf(at) : undefined;
+        const fn = declared !== undefined && isVariableDeclaration(declared) && declared.initializer
+            ? unwrapped(declared.initializer)
+            : (declared ?? at);
+        if (isFunction(fn)) {
+            run(fn);
+        }
+    };
+    const visit = (node) => {
+        if (isFunction(node)) {
+            return;
+        }
+        if (isCallExpression(node) || isNewExpression(node)) {
+            if (isCallExpression(node)) {
+                each(node);
+            }
+            runs(node.expression);
+            for (const argument of node.arguments ?? []) {
+                runs(argument);
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+}
+/** The entries every bundler call one build script runs names, read against `dir`. */
+function scriptEntries(file, dir, files) {
+    const module = staticModule(file);
+    const building = new Map();
+    for (const api of BUNDLERS) {
+        for (const one of module.calls(api.module)) {
+            if (api.calls.includes(one.export)) {
+                building.set(one.call, api);
+            }
+        }
+    }
+    const scriptDir = dirnamePath(file.fileName);
+    const found = [];
+    runCalls(file, (call) => {
+        const api = building.get(call);
+        if (api === undefined) {
+            return;
+        }
+        for (const options of module.argument(call)) {
+            const entries = lastMember(options, api.option);
+            const base = api.base === "" ? undefined : lastMember(options, api.base);
+            const against = base === undefined ? { path: dir } : pathOf(base, dir, scriptDir);
+            if (entries === undefined || against === undefined) {
+                continue;
+            }
+            for (const value of entryValues(entries)) {
+                const named = pathOf(value, against.path, scriptDir);
+                if (named === undefined) {
+                    continue;
+                }
+                for (const entry of entriesNamed(files, api, named)) {
+                    found.push({ file: entry, source: named.text });
+                }
+            }
+        }
+    });
+    return found;
+}
+/** The modules one manifest's command strings run or name, by absolute path, each below the target root. */
+function scriptModules(host, root, dir) {
+    const manifest = manifestAt(host, dir);
+    const found = new Set();
+    for (const { command } of manifest === undefined ? [] : manifestCommands(host, dir, manifest)) {
+        for (const { path } of pathsNamed(readCommands(command, dir))) {
+            if (extensionOf(path, MODULE_EXTENSIONS) !== undefined &&
+                relativePath(root, path) !== undefined &&
+                !inInstalledPackages(path) &&
+                host.kindOf(path) === "file") {
+                found.add(path);
+            }
+        }
+    }
+    return [...found].sort(bytewise);
+}
+/**
+ * Every own file of one project a build script names as a bundler's entry: a module a
+ * script of a manifest at or above an own file runs, below the target root, read from
+ * the program where it holds the module and parsed alone otherwise, where a parser is given.
+ */
+export function buildScriptEntries(host, targetRoot, files, parse) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const dirs = new Set([root]);
+    for (const file of files.byName.values()) {
+        for (const dir of ancestors(dirnamePath(file.fileName), root)) {
+            if (dirs.has(dir)) {
+                break;
+            }
+            dirs.add(dir);
+        }
+    }
+    const found = [];
+    for (const dir of [...dirs].sort(bytewise)) {
+        if (!holdsManifest(host, dir)) {
+            continue;
+        }
+        for (const path of scriptModules(host, root, dir)) {
+            let script = files.byName.get(path);
+            if (script === undefined && parse !== undefined) {
+                try {
+                    script = parse(path, host.readFile(path));
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (script !== undefined) {
+                found.push(...scriptEntries(script, dir, files));
+            }
+        }
+    }
+    return found;
+}

package/dist/src/{configuration-files.js → entries/configuration-files.js}

@@ -6,19 +6,26 @@
  * every string either holds as it likes, so each one that spells a declared dependency
  * uses it and each relative one that names a source file of the program roots the file.
  */
-import { isCallExpression, isExportDeclaration, isIdentifier, isImportDeclaration, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
-import { bytewise } from "./text/compare.js";
-import { isRecord } from "./json-document.js";
-import { filesIn } from "./fs/tree.js";
-import { DEPENDENCY_SECTIONS, holdsManifest, inInstalledPackages, manifestAt, readJSON, } from "./fs/manifest.js";
-import { readCommands } from "./commands/read.js";
-import { manifestCommands } from "./manifest.js";
+import { isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/ast";
+import { relativeSpecifiers } from "./static-module.js";
+import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { bytewise } from "../text/compare.js";
+import { isRecord } from "../json-document.js";
+import { filesIn } from "../fs/tree.js";
+import { DEPENDENCY_SECTIONS, holdsManifest, inInstalledPackages, manifestAt, readJSON, } from "../fs/manifest.js";
+import { readCommands } from "../commands/read.js";
+import { manifestCommands } from "../roots/manifest.js";
+import { APPENDED_EXTENSIONS, extensionOf, MODULE_EXTENSIONS } from "../extensions.js";
+/** The extensions of a configuration module, as an expression's alternatives. */
+const MODULE_NAME = MODULE_EXTENSIONS.map((one) => one.slice(1)).join("|");
 /** A configuration module's name, each form with the spelling a root reports it by. */
 const MODULE_FORMS = [
-    { name: /^[\w-]+\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u, form: "<stem>.config.<ext>" },
     {
-        name: /^[\w-]+\.[\w-]+\.config\.(?:js|mjs|cjs|ts|mts|cts)$/u,
+        name: new RegExp(String.raw `^[\w-]+\.config\.(?:${MODULE_NAME})$`, "u"),
+        form: "<stem>.config.<ext>",
+    },
+    {
+        name: new RegExp(String.raw `^[\w-]+\.[\w-]+\.config\.(?:${MODULE_NAME})$`, "u"),
         form: "<stem>.<qualifier>.config.<ext>",
     },
     { name: /^\.[\w-]+rc\.(?:js|mjs|cjs)$/u, form: ".<stem>rc.<ext>" },
@@ -34,8 +41,6 @@ const COUNTERPARTS = [
     [".mjs", [".mts"]],
     [".cjs", [".cts"]],
 ];
-/** The extensions appended to a relative specifier from a configuration file, in order. */
-const APPENDED = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 /** The extensions the program's module resolution appends to a specifier written without one. */
 export const RESOLVED_EXTENSIONS = [
     ".ts",
@@ -65,8 +70,6 @@ export function configurationModuleForm(name) {
 export function isConfigurationDocumentName(name) {
     return DOCUMENT_NAME.test(name);
 }
-/** The extensions of a module a configuration flag may name. */
-const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
 /**
  * The files the command strings of the manifest in one directory name after a configuration
  * flag, as `commands/read.ts` reads them against the directory each command runs in, each a
@@ -200,47 +203,6 @@ export function configurationFiles(host, targetRoot, files, parse) {
             : outsideModules(host, root, [...dirs], files, manifestHeld, parse, named),
     };
 }
-/** The literal module specifier one `require(...)` or `import(...)` call names, if any. */
-function calledSpecifier(node) {
-    if (!isCallExpression(node) || node.arguments.length !== 1) {
-        return undefined;
-    }
-    const callee = node.expression;
-    const loads = callee.kind === SyntaxKind.ImportKeyword || (isIdentifier(callee) && callee.text === "require");
-    return loads ? node.arguments[0] : undefined;
-}
-/**
- * The relative specifiers one file's imports and re-exports name, and those its
- * `require(...)` and `import(...)` calls name by a literal.
- */
-export function relativeSpecifiers(file) {
-    const known = specifiersOf.get(file);
-    if (known !== undefined) {
-        return known;
-    }
-    const found = [];
-    const named = (specifier) => {
-        if (specifier !== undefined &&
-            (isStringLiteral(specifier) || isNoSubstitutionTemplateLiteral(specifier)) &&
-            RELATIVE_PREFIXES.some((prefix) => specifier.text.startsWith(prefix))) {
-            found.push(specifier.text);
-        }
-    };
-    const visit = (node) => {
-        named(calledSpecifier(node));
-        node.forEachChild(visit);
-    };
-    for (const statement of file.statements) {
-        named(isImportDeclaration(statement) || isExportDeclaration(statement)
-            ? statement.moduleSpecifier
-            : undefined);
-        visit(statement);
-    }
-    specifiersOf.set(file, found);
-    return found;
-}
-/** What {@link relativeSpecifiers} found in each file, which every project of a run reads alike. */
-const specifiersOf = new WeakMap();
 /**
  * The files no program holds that a chain from `seeds` reads: each seed, and each file
  * below the target root one imports, re-exports or loads by a relative specifier that no
@@ -261,7 +223,7 @@ export function outsideChain(host, targetRoot, files, parse, seeds) {
 export function specifierCandidates(dir, specifier) {
     const path = resolvePath(dir, specifier);
     const candidates = [];
-    if (APPENDED.some((extension) => path.endsWith(extension))) {
+    if (extensionOf(path, APPENDED_EXTENSIONS) !== undefined) {
         candidates.push(path);
     }
     for (const [extension, counterparts] of COUNTERPARTS) {
@@ -270,8 +232,8 @@ export function specifierCandidates(dir, specifier) {
             candidates.push(...counterparts.map((one) => stem + one));
         }
     }
-    candidates.push(...APPENDED.map((extension) => path + extension));
-    candidates.push(...APPENDED.map((extension) => joinPath(path, `index${extension}`)));
+    candidates.push(...APPENDED_EXTENSIONS.map((extension) => path + extension));
+    candidates.push(...APPENDED_EXTENSIONS.map((extension) => joinPath(path, `index${extension}`)));
     return candidates;
 }
 /** The file on disk one relative specifier from a configuration file reaches, or undefined. */