@cplieger/deadset-ts 5.1.0 → 5.2.0

package/dist/src/generated-file.js

@@ -1,8 +1,74 @@
 /**
- * The generated-file class on TypeScript: every declaration in a file below a directory
- * an applied convention row names as generated is retained, because the framework owns
- * the file and a deletion there is undone at the next generation.
+ * The generated-file class on TypeScript: every declaration in a file that marks itself
+ * generated, or below a directory an applied convention row names as generated, is
+ * retained, because a generator owns the file and a deletion there is undone at the next
+ * generation.
  */
+/** The generated-code header, matched against each line of a leading comment. */
+const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
+/** The documentation tag `@generated` as a word of a comment. */
+const GENERATED_TAG = /(?<![\w@$])@generated(?![\w$-])/u;
+/** The comments before a text's first token, a leading hashbang line skipped. */
+function leadingComments(text) {
+    const comments = [];
+    let at = text.startsWith("\uFEFF") ? 1 : 0;
+    if (text.startsWith("#!", at)) {
+        const end = text.indexOf("\n", at);
+        at = end === -1 ? text.length : end + 1;
+    }
+    for (;;) {
+        while (at < text.length && /\s/u.test(text.charAt(at))) {
+            at++;
+        }
+        if (text.startsWith("//", at)) {
+            const end = text.slice(at).search(/[\r\n\u2028\u2029]/u);
+            const stop = end === -1 ? text.length : at + end;
+            comments.push(text.slice(at, stop));
+            at = stop;
+        }
+        else if (text.startsWith("/*", at)) {
+            const end = text.indexOf("*/", at + 2);
+            if (end === -1) {
+                return comments;
+            }
+            comments.push(text.slice(at, end + 2));
+            at = end + 2;
+        }
+        else {
+            return comments;
+        }
+    }
+}
+/** The detail a file's leading comments mark it generated by, or undefined where they mark nothing. */
+export function generatedByComment(text) {
+    const comments = leadingComments(text);
+    if (comments.some((one) => one.split(/\r?\n/u).some((line) => HEADER_LINE.test(line)))) {
+        return "generated by the header line its leading comments hold";
+    }
+    if (comments.some((one) => GENERATED_TAG.test(one))) {
+        return "generated by the @generated tag its leading comments hold";
+    }
+    return undefined;
+}
+/**
+ * Every own file of one project that is generated, by its path below the target root,
+ * with the detail a retention in it names: its leading comments' mark, else the row
+ * naming its directory as generated.
+ */
+export function generatedFilesOf(files, byRow) {
+    const found = new Map();
+    for (const [path, file] of files.byPath) {
+        const row = byRow.get(path);
+        const detail = generatedByComment(file.text) ??
+            (row === undefined
+                ? undefined
+                : `generated below a directory the convention row ${row} names`);
+        if (detail !== undefined) {
+            found.set(path, detail);
+        }
+    }
+    return found;
+}
 /** The generated-file detector, recording each file's first line. */
 export function generatedFile(input) {
     const generated = input.generated;
@@ -10,15 +76,9 @@ export function generatedFile(input) {
         return [];
     }
     return input.held.symbols.flatMap((symbol) => {
-        const row = generated.get(symbol.position.path);
-        return symbol.kind === "file" || row === undefined
+        const detail = generated.get(symbol.position.path);
+        return symbol.kind === "file" || detail === undefined
             ? []
-            : [
-                {
-                    id: symbol.id,
-                    detail: `generated below a directory the convention row ${row} names`,
-                    site: { path: symbol.position.path, line: 1, column: 1 },
-                },
-            ];
+            : [{ id: symbol.id, detail, site: { path: symbol.position.path, line: 1, column: 1 } }];
     });
 }

package/dist/src/graph.js

@@ -33,10 +33,10 @@ const SWEPT = {
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
  * tool reads the configuration it loads and the files its strings name, a runtime runs a
- * test file, a setup file, a worker, a command and a script, the manifest names what
- * enters the package, an alias global stands for the export it names, and an entry file,
- * a configured root and a pattern assert a caller. A library's published API only supposes
- * a consumer the run may not see, so it is live under reachability alone.
+ * test file, a setup file, a worker, a page's module script, a command and a script, the
+ * manifest names what enters the package, an alias global stands for the export it names,
+ * and an entry file, a configured root and a pattern assert a caller. A library's
+ * published API only supposes an unseen consumer, so it is live under reachability alone.
  */
 const NAMES_A_CALLER = {
     "entry-file": true,
@@ -55,6 +55,7 @@ const NAMES_A_CALLER = {
     "mutation-testing": true,
     "browser-tests": true,
     worker: true,
+    "html-entry": true,
 };
 /** Whether the sweep judges a declaration of one kind. */
 export function swept(kind) {
@@ -94,7 +95,7 @@ export function graphOf(symbols, references, roots, testFiles, supportFiles = []
             }
         }
         const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-        if (reference.consumer !== undefined) {
+        if (reference.consumer !== undefined || reference.unheld === true) {
             consumed.push(edge);
             continue;
         }

package/dist/src/html-entries.js

@@ -0,0 +1,137 @@
+/**
+ * The files the module scripts of the target's HTML files load. An HTML file is read as
+ * text and no markup is parsed, so a `<script>` inside a comment is read as well.
+ */
+import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/unstable/ast";
+import { resolveRelativeSpecifier } from "./configuration-files.js";
+import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.js";
+/** The directory no HTML file is read below. */
+const SKIPPED = "node_modules";
+/** A `<script` start tag, its attribute text captured. */
+const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
+/** The end tag an inline module script's content runs to. */
+const SCRIPT_END = /<\/script\s*>/iu;
+/** One attribute: a name, then a double-quoted, single-quoted or unquoted value. */
+const ATTRIBUTE = /([^\s"'=<>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/gu;
+/** A value that names a resource on another origin, or by another scheme. */
+const ELSEWHERE = /^(?:\/\/|[A-Za-z][A-Za-z\d+.-]*:)/u;
+/** The prefixes an inline script's specifier names a file of the target with. */
+const FILE_PREFIXES = ["/", "./", "../"];
+/** Every HTML file below `dir`, outside every `node_modules` directory, by absolute path. */
+function htmlFiles(host, dir) {
+    let entries;
+    try {
+        entries = host.readDirectory(dir);
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const entry of entries) {
+        const path = joinPath(dir, entry.name);
+        if (entry.directory) {
+            if (entry.name !== SKIPPED) {
+                found.push(...htmlFiles(host, path));
+            }
+        }
+        else if (entry.name.endsWith(".html")) {
+            found.push(path);
+        }
+    }
+    return found.sort();
+}
+/** Each attribute of one start tag's attribute text, by its lowercase name. */
+function attributes(text) {
+    const found = new Map();
+    for (const match of text.matchAll(ATTRIBUTE)) {
+        const [, name = "", double, single, bare] = match;
+        const key = name.toLowerCase();
+        if (!found.has(key)) {
+            found.set(key, double ?? single ?? bare ?? "");
+        }
+    }
+    return found;
+}
+/** The specifiers of the import and re-export declarations one inline script holds. */
+function specifiersOf(parse, fileName, content) {
+    return parse(fileName, content).statements.flatMap((statement) => {
+        const specifier = isImportDeclaration(statement) || isExportDeclaration(statement)
+            ? statement.moduleSpecifier
+            : undefined;
+        return specifier !== undefined && isStringLiteral(specifier) ? [specifier.text] : [];
+    });
+}
+/**
+ * Every value a module script of one HTML file names a file by: a `src` attribute's
+ * value, or each specifier an inline script imports or re-exports that starts with `/`,
+ * `./` or `../`.
+ */
+function scriptValues(parse, path, text) {
+    const values = [];
+    for (const match of text.matchAll(SCRIPT_TAG)) {
+        const held = attributes(match[1] ?? "");
+        if (held.get("type") !== "module") {
+            continue;
+        }
+        const src = held.get("src");
+        if (src !== undefined) {
+            values.push(src);
+            continue;
+        }
+        if (parse === undefined) {
+            continue;
+        }
+        const start = match.index + match[0].length;
+        const rest = text.slice(start);
+        const end = rest.search(SCRIPT_END);
+        const content = end === -1 ? rest : rest.slice(0, end);
+        values.push(...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter((specifier) => FILE_PREFIXES.some((prefix) => specifier.startsWith(prefix))));
+    }
+    return values;
+}
+/** The directory of the nearest `package.json` at or above `dir`, inside `root`, else `root`. */
+function manifestDirectory(host, root, dir) {
+    for (let at = dir; relativePath(root, at) !== undefined; at = dirnamePath(at)) {
+        if (host.kindOf(joinPath(at, "package.json")) === "file") {
+            return at;
+        }
+        if (at === root) {
+            break;
+        }
+    }
+    return root;
+}
+/**
+ * The own files the module scripts of every HTML file below the target root load. A value
+ * starting with a single `/` is read against the nearest manifest's directory, any other
+ * against the HTML file's own, and either resolves as a configuration file's relative
+ * specifier does. A value naming another origin or scheme, or no source file of the
+ * program, loads nothing here.
+ */
+export function htmlEntries(host, targetRoot, files, parse) {
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    const found = [];
+    for (const path of htmlFiles(host, root)) {
+        let text;
+        try {
+            text = host.readFile(path);
+        }
+        catch {
+            continue;
+        }
+        const dir = dirnamePath(path);
+        for (const value of scriptValues(parse, path, text)) {
+            if (ELSEWHERE.test(value)) {
+                continue;
+            }
+            const reached = value.startsWith("/")
+                ? resolveRelativeSpecifier(host, manifestDirectory(host, root, dir), `.${value}`)
+                : resolveRelativeSpecifier(host, dir, value);
+            const file = reached === undefined ? undefined : files.byName.get(reached);
+            if (file !== undefined) {
+                found.push({ file, source: value });
+            }
+        }
+    }
+    return found;
+}

package/dist/src/inventory.js

@@ -213,7 +213,18 @@ function nameNodeOf(node) {
  * needs the declaration this enumeration made for it.
  */
 export function nodeKey(file, node) {
-    return `${file.fileName}:${String(node.pos)}:${String(node.end)}`;
+    return `${file.fileName}:${String(node.pos)}:${String(node.end)}:${String(node.kind)}`;
+}
+/** `export default`, up to the keyword that stands where an unnamed default export's name would. */
+const DEFAULT_EXPORT = /^export\s+(?=default\b)/u;
+/**
+ * Where an unnamed declaration is placed: at `default` when it is the default export, so it
+ * never shares the file's own position, else at its first token.
+ */
+function unnamedStart(node) {
+    const start = node.getStart();
+    const prefix = DEFAULT_EXPORT.exec(node.getText());
+    return prefix === null ? start : start + prefix[0].length;
 }
 /** The kind a class element takes: a method, or a property or accessor. */
 function classMemberKind(node) {
@@ -287,12 +298,11 @@ export function inventory(project, host, targetRoot) {
         }
     }
     function declare(node, owner, kind, name, named) {
-        const at = name ?? node;
         const record = keep({
             file: owner.file,
             node,
             module: owner.module,
-            position: renderPosition(owner.file, targetRoot, at.getStart()),
+            position: renderPosition(owner.file, targetRoot, name?.getStart() ?? unnamedStart(node)),
             endLine: renderPosition(owner.file, targetRoot, Math.max(node.end - 1, 0)).line,
             kind,
             parentChain: owner.kind === "file" ? [] : chainOf(owner),

package/dist/src/kinds.js

@@ -40,7 +40,7 @@ const ROWS = [
         code: "DS1004",
         name: "test-only-use",
         languages: ["go", "ts"],
-        rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only test code imports, is a test reference, and a declaration of test-support code is never reported under this code.",
+        rule: "A symbol with zero production references and at least one test reference: an unused-exported, unused-unexported or unused-member candidate whose test reference count is not zero, reported once under this code. A reference from a consumer's test files is a test reference unless the configuration counts consumer tests as production. A reference from test-support code, a package or file that only tests reach, is a test reference. A declaration of test-support code that test code references is reported under this code at the reachability class possible, as grammar/analysis.md states. Such a declaration that is an interface is reported under DS1201 instead.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",
@@ -144,7 +144,7 @@ const ROWS = [
         code: "DS1301",
         name: "write-only-symbol",
         languages: ["go", "ts"],
-        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, or an import binding the writes alone use. The finding's message names each such declaration.",
+        rule: "A package-level or module-level variable, struct field, class member, type member or collection that production code writes and never reads. In production mode a read from a test file counts as no read. A write from a loaded consumer's code counts as a read, because the deletion the finding names would break a consumer the target does not own. A write in a consumer's test file counts as a read in the run that counts test references. It counts in a production sweep only where the configuration counts consumer tests as production. A comparison of struct values reads every field of the type: in Go, a value of a struct type used as an operand of `==` or `!=`, as a map key, or as a `switch` tag or `case` expression is a read of every field of that type, transitively through the fields of every struct type it holds, recorded at the comparison, because equality reads every field and a field that decides equality carries information. In Go a type argument the program instantiates a type parameter with, where the parameter's constraint is `comparable` or embeds it, is compared as an operand of `==` of that type is, recorded at the instantiation, so the struct values `slices.Equal`, `slices.Index` or `maps.Equal` compares have every field read. `reflect.DeepEqual` is not a comparison under this rule. In TypeScript a comparison of two object references reads no member, because `===` compares identity and never a member. In TypeScript a property of an object literal writes the member of the same name that the literal's contextual type declares, whether or not the compiler checks the literal for excess properties. Where that contextual type is a union or an intersection, the property writes the member of that name on each constituent that declares one. So a literal that a declaration annotates, a function returns, a call passes or a `satisfies` expression checks writes the members of the type it is given. A store through the value a field or a member holds reads that field or member rather than writing it, because the store lands in storage every other holder of the value reads. In Go that store is an assignment, an increment, a compound assignment or a `delete` whose target is reached through a struct field holding a map, a slice or a pointer. Examples are `s.f[k] = v`, `s.f.x = v` and `delete(s.f, k)`. The same store through a field holding an array or a struct is a store into the field itself. TypeScript holds every object by reference, so an element or property store through a member's value reads the member. The finding names each write position, so the deletion set is visible. Deleting the subject and its writes also deletes every declaration whose only uses they hold. Such a declaration is a type parameter of the subject's declaring type that the subject's type alone names, an import binding the writes alone use, or a declaration whose every use is in the type annotation of the subject or of another subject this rule reports, or in the writes those findings name. The finding's message names each such declaration, and no finding is reported about the declaration itself.",
         defaultSeverity: "deny",
         maxClass: "certain",
         fixability: "deletable",

package/dist/src/manifest.js

@@ -1,11 +1,10 @@
 /**
  * The entry points a package manifest names, which are roots because something
  * outside the analyzed program reaches them: a consumer importing the package, or a
- * shell running its command or one of its scripts.
- *
- * One call reads one manifest, the one in the directory it is given.
+ * shell running its command or one of its scripts. {@link readManifest} reads one
+ * directory's manifest, {@link packageEntries} those of the packages below the target root.
  */
-import { isAbsolutePath, joinPath, resolvePath } from "./paths.js";
+import { dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
 /** The manifest's own name. */
 const MANIFEST = "package.json";
 /** The three members that name an entry point beside `exports` and `bin`. */
@@ -140,7 +139,37 @@ export function readManifest(host, targetRoot) {
         }
     }
     return {
-        entries: found.map((entry) => ({ ...entry, path: resolvePath(targetRoot, entry.path) })),
+        entries: found.map((entry) => ({
+            ...entry,
+            path: resolvePath(targetRoot, entry.path),
+            dir: targetRoot,
+        })),
         declaresExports: manifest["exports"] !== undefined,
     };
 }
+/**
+ * The entry points every package manifest between the target root and each compiler
+ * configuration names: each directory holding a `package.json` that a configuration sits
+ * in or below, the target root and `known` excluded, whose manifests the run reads
+ * otherwise. Each entry is spelled under its manifest's path below the target root, and
+ * is published by its own manifest's rule, as the target's own entries are.
+ */
+export function packageEntries(host, targetRoot, configFiles, known) {
+    const dirs = new Set();
+    for (const configFile of configFiles) {
+        for (let dir = dirnamePath(resolvePath(targetRoot, configFile)); dir !== targetRoot && relativePath(targetRoot, dir) !== undefined; dir = dirnamePath(dir)) {
+            if (!known.has(dir) && host.kindOf(joinPath(dir, MANIFEST)) === "file") {
+                dirs.add(dir);
+            }
+        }
+    }
+    return [...dirs].sort().flatMap((dir) => {
+        const manifest = readManifest(host, dir);
+        const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
+        return manifest.entries.map((entry) => ({
+            ...entry,
+            member: `${where} ${entry.member}`,
+            published: entry.published && (!manifest.declaresExports || entry.member.startsWith("exports")),
+        }));
+    });
+}

package/dist/src/matrix.js

@@ -4,7 +4,7 @@
  * and intersected, with the dead components computed once over every configuration.
  */
 import { componentsOf } from "./components.js";
-import { graphOf } from "./graph.js";
+import { graphOf, OUTSIDE } from "./graph.js";
 import { byPosition } from "./position.js";
 import { sweep } from "./sweep.js";
 /** Two strings ordered bytewise. */
@@ -102,6 +102,7 @@ export function sweepMatrix(matrix, input) {
     const union = matrix.union;
     const dead = union.symbols.map(() => false);
     const testOfDeadCode = union.symbols.map(() => false);
+    const heldBy = union.symbols.map(() => undefined);
     const candidates = [];
     union.symbols.forEach((symbol, at) => {
         const held = matrix.heldIn[at] ?? [];
@@ -111,23 +112,28 @@ export function sweepMatrix(matrix, input) {
         }
         const all = found.filter((candidate) => candidate !== undefined);
         const admitted = all.every((candidate) => candidate.testOfDeadCode);
+        const testRefs = union.made[at]?.test ?? 0;
+        const heldByTests = heldBy[union.parent[at] ?? OUTSIDE] ??
+            (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
         dead[at] = true;
         testOfDeadCode[at] = admitted;
+        heldBy[at] = heldByTests;
         candidates.push({
             id: symbol.id,
             productionRefs: union.made[at]?.production ?? 0,
-            testRefs: union.made[at]?.test ?? 0,
+            testRefs,
             relation: all.every((candidate) => candidate.relation === "reference-counting")
                 ? "reference-counting"
                 : "reachability",
             testOfDeadCode: admitted,
             configurations: held,
+            heldByTests,
         });
     });
     return {
         liveUnder: liveAnywhere(union.symbols, per),
         candidates,
-        components: componentsOf(union, dead, testOfDeadCode),
+        components: componentsOf(union, dead.map((one, at) => one && heldBy[at] === undefined), testOfDeadCode),
     };
 }
 /**

package/dist/src/namespace-objects.js

@@ -0,0 +1,158 @@
+/**
+ * Module namespace objects: the binding of a namespace import, the value an `await` of a
+ * dynamic `import()` produces, the first parameter of the first callback passed to `then`
+ * on one, and a `const` binding initialized with one of these. A use reads the exports it
+ * names and no other: a property access by name or by a literal index, or a destructured
+ * property, names one export, and any other use may read every export.
+ */
+import { isArrowFunction, isAwaitExpression, isBindingElement, isCallExpression, isElementAccessExpression, isExpressionStatement, isFunctionExpression, isIdentifier, isImportDeclaration, isNamespaceImport, isNoSubstitutionTemplateLiteral, isObjectBindingPattern, isParenthesizedExpression, isPropertyAccessExpression, isQualifiedName, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVoidExpression, NodeFlags, SyntaxKind, } from "@typescript/native/unstable/ast";
+function isLiteralText(node) {
+    return isStringLiteral(node) || isNoSubstitutionTemplateLiteral(node);
+}
+/** The outermost expression one node is, through the parentheses written around it. */
+function parenthesized(node) {
+    let at = node;
+    while (isParenthesizedExpression(at.parent)) {
+        at = at.parent;
+    }
+    return at;
+}
+/** Whether one call is a dynamic `import()` whose argument is literal text. */
+function isLiteralImport(node) {
+    if (!isCallExpression(node) || node.expression.kind !== SyntaxKind.ImportKeyword) {
+        return false;
+    }
+    const [argument] = node.arguments;
+    return argument !== undefined && isLiteralText(argument);
+}
+/** The node a `const` binding's name is visible below: the block or file its statement is in. */
+function scopeOf(declaration) {
+    const statement = declaration.parent.parent;
+    return statement.parent;
+}
+/** Every identifier below `scope` that spells `name`, other than `declared` and a member's name. */
+function occurrences(scope, name, declared) {
+    const found = [];
+    const visit = (node) => {
+        if (isIdentifier(node)) {
+            const parent = node.parent;
+            const member = (isPropertyAccessExpression(parent) && parent.name === node) ||
+                (isQualifiedName(parent) && parent.right === node) ||
+                (isBindingElement(parent) && parent.propertyName === node);
+            if (node !== declared && node.text === name && !member) {
+                found.push(node);
+            }
+            return;
+        }
+        node.forEachChild(visit);
+    };
+    scope.forEachChild(visit);
+    return found;
+}
+/**
+ * Every use of the namespace objects one file holds, keyed by the node the use is written
+ * at, that reads more than a name the checker resolves: an indexed read by a literal, and
+ * any use that may read every export. A shadowing declaration of a binding's name inside
+ * its scope is read as the binding, which can only keep an export live.
+ */
+export function namespaceUses(file) {
+    const uses = new Map();
+    const binding = (name, scope, specifier, seen) => {
+        if (seen.has(name)) {
+            return;
+        }
+        seen.add(name);
+        for (const one of occurrences(scope, name.text, name)) {
+            value(one, specifier, seen);
+        }
+    };
+    /** One use of a namespace object's value, at `node`. */
+    const value = (node, specifier, seen) => {
+        const at = parenthesized(node);
+        const parent = at.parent;
+        if (isExpressionStatement(parent) || isVoidExpression(parent)) {
+            return;
+        }
+        if ((isPropertyAccessExpression(parent) && parent.expression === at) ||
+            (isQualifiedName(parent) && parent.left === at)) {
+            return;
+        }
+        if (isElementAccessExpression(parent) && parent.expression === at) {
+            const index = parent.argumentExpression;
+            uses.set(node, isLiteralText(index) ? { kind: "indexed", literal: index } : { kind: "whole", specifier });
+            return;
+        }
+        if (isVariableDeclaration(parent) && parent.initializer === at) {
+            const pattern = parent.name;
+            if (isObjectBindingPattern(pattern)) {
+                const named = pattern.elements.every((element) => element.dotDotDotToken === undefined &&
+                    element.propertyName?.kind !== SyntaxKind.ComputedPropertyName);
+                if (!named) {
+                    uses.set(node, { kind: "whole", specifier });
+                }
+                return;
+            }
+            const list = parent.parent;
+            if (isIdentifier(pattern) &&
+                isVariableDeclarationList(list) &&
+                (list.flags & NodeFlags.Const) !== 0) {
+                binding(pattern, scopeOf(parent), specifier, seen);
+                return;
+            }
+        }
+        uses.set(node, { kind: "whole", specifier });
+    };
+    /** One use of a dynamic `import()` call, at `call`. */
+    const imported = (call, specifier, seen) => {
+        const at = parenthesized(call);
+        const parent = at.parent;
+        if (isExpressionStatement(parent) || isVoidExpression(parent)) {
+            return;
+        }
+        if (isAwaitExpression(parent)) {
+            value(parent, specifier, seen);
+            return;
+        }
+        const then = parent.parent;
+        if (isPropertyAccessExpression(parent) &&
+            parent.expression === at &&
+            parent.name.text === "then" &&
+            isCallExpression(then) &&
+            then.expression === parent) {
+            const [callback] = then.arguments;
+            if (callback !== undefined && (isArrowFunction(callback) || isFunctionExpression(callback))) {
+                const [first] = callback.parameters;
+                if (first === undefined || isObjectBindingPattern(first.name)) {
+                    return;
+                }
+                if (isIdentifier(first.name)) {
+                    binding(first.name, callback, specifier, seen);
+                    return;
+                }
+            }
+        }
+        uses.set(call, { kind: "whole", specifier });
+    };
+    const visit = (node) => {
+        if (isImportDeclaration(node)) {
+            const clause = node.importClause;
+            const bindings = clause?.namedBindings;
+            if (clause !== undefined &&
+                clause.phaseModifier !== SyntaxKind.TypeKeyword &&
+                bindings !== undefined &&
+                isNamespaceImport(bindings)) {
+                binding(bindings.name, file, node.moduleSpecifier, new Set());
+            }
+            return;
+        }
+        if (isLiteralImport(node) && isCallExpression(node)) {
+            const [argument] = node.arguments;
+            if (argument !== undefined) {
+                imported(node, argument, new Set());
+            }
+        }
+        node.forEachChild(visit);
+    };
+    file.forEachChild(visit);
+    return uses;
+}