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

package/dist/src/entries/conventions.js

@@ -11,7 +11,7 @@ import { documentStrings } from "./configuration-files.js";
 import { readCommands } from "../commands/read.js";
 import { nodeTestGlobs, } from "./test-runners.js";
 import { documentModule, membersNamed, staticModule, textsOf, valuesAt, } from "./static-module.js";
-import { ancestors, dirnamePath, joinPath, normalizePath, relativePath, resolvePath, } from "../paths.js";
+import { ancestors, cannotStartPackageName, 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";
@@ -425,7 +425,7 @@ function prefixedPackage(value, reading) {
     const { prefix, marker } = reading;
     let name;
     if (marker === undefined) {
-        if (value.includes(":") || value.startsWith(".") || value.startsWith("/")) {
+        if (value.includes(":") || cannotStartPackageName(value)) {
             return undefined;
         }
         const parts = value.split("/");

package/dist/src/entries/html-entries.js

@@ -5,7 +5,7 @@
  */
 import { isExportDeclaration, isImportDeclaration, isStringLiteral, } from "@typescript/native/ast";
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { ancestors, dirnamePath, joinPath, resolvePath } from "../paths.js";
+import { ancestors, dirnamePath, hasURLScheme, isAbsolutePath, isExplicitPath, joinPath, resolvePath, } from "../paths.js";
 import { filesBelow } from "../fs/tree.js";
 import { holdsManifest } from "../fs/manifest.js";
 /** A `<script` start tag, its attribute text captured. */
@@ -14,12 +14,8 @@ const SCRIPT_TAG = /<script(?=[\s>/])([^>]*)>/giu;
 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 `type` values a classic script carries, compared in lowercase. */
 const CLASSIC_TYPES = new Set(["text/javascript", "application/javascript"]);
-/** The prefixes an inline script's specifier names a file of the target with. */
-const FILE_PREFIXES = ["/", "./", "../"];
 /** Each attribute of one start tag's attribute text, by its lowercase name. */
 function attributes(text) {
     const found = new Map();
@@ -69,7 +65,7 @@ function scriptValues(parse, path, text) {
         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))));
+        values.push(...specifiersOf(parse, `${path}.${String(start)}.ts`, content).filter(isExplicitPath));
     }
     return values;
 }
@@ -98,18 +94,19 @@ export function htmlEntries(host, targetRoot, files, parse) {
         }
         const dir = dirnamePath(path);
         for (const value of scriptValues(parse, path, text)) {
-            if (ELSEWHERE.test(value)) {
+            // A value with a scheme, or one starting `//`, names a resource on another origin.
+            if (value.startsWith("//") || hasURLScheme(value)) {
                 continue;
             }
-            const base = value.startsWith("/") ? manifestDirectory(host, root, dir) : dir;
-            const relative = value.startsWith("/") ? `.${value}` : value;
+            const base = isAbsolutePath(value) ? manifestDirectory(host, root, dir) : dir;
+            const relative = isAbsolutePath(value) ? `.${value}` : value;
             const reached = resolveRelativeSpecifier(host, base, relative);
             const file = reached === undefined ? undefined : files.byName.get(reached);
             if (file !== undefined) {
                 found.push({ file, source: value });
                 continue;
             }
-            const served = value.startsWith("/")
+            const served = isAbsolutePath(value)
                 ? files.outputDirs.filter((outDir) => outDir === dir)
                 : [];
             const emitting = [base, ...served].flatMap((against) => files.named(resolvePath(against, relative)));

package/dist/src/entries/mdx-entries.js

@@ -4,7 +4,7 @@
  * is an import declaration, which an MDX compiler hoists into the module it builds.
  */
 import { resolveRelativeSpecifier } from "./configuration-files.js";
-import { dirnamePath, joinPath, resolvePath } from "../paths.js";
+import { dirnamePath, joinPath, resolvePath, startsRelativePath } from "../paths.js";
 import { filesBelow } from "../fs/tree.js";
 /** The extensions of a document whose imports an MDX compiler reads. */
 const DOCUMENT = /\.mdx?$/u;
@@ -122,7 +122,7 @@ function importedBy(text) {
         }
         const matched = open === undefined ? IMPORT_LINE.exec(line) : null;
         const specifier = matched?.[2];
-        if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+        if (specifier !== undefined && startsRelativePath(specifier)) {
             found.push({ specifier, names: clauseNames(matched?.[1] ?? "") });
         }
     }

package/dist/src/entries/static-module.js

@@ -7,6 +7,7 @@
 import { isArrayLiteralExpression, isBindingElement, isExternalModuleReference, isImportClause, isImportEqualsDeclaration, isImportSpecifier, isStringLiteralLikeNode, isCallExpression, isClassDeclaration, isClassExpression, isComputedPropertyName, isExportAssignment, isExportDeclaration, isExpressionStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isIdentifier, isImportDeclaration, isNamedExports, isNamespaceImport, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isSpreadAssignment, isStringLiteral, isVariableDeclaration, isVariableStatement, isSourceFile, isBlock, isModuleBlock, isCaseBlock, isCatchClause, isForStatement, isForInStatement, isForOfStatement, isVariableDeclarationList, isMetaProperty, isAssignmentOperator, isBinaryExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isShorthandPropertyAssignment, isSpreadElement, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { commonJSModuleValue } from "../inventory/commonjs.js";
 import { callsPlatformBy, lexicalBinding, writtenName } from "../platform-calls.js";
+import { startsRelativePath } from "../paths.js";
 import { unwrapped } from "../unwrap.js";
 /** A JSON or YAML document's value, which carries no positions. */
 export function documentValue(value) {
@@ -443,7 +444,7 @@ export function relativeSpecifiers(file) {
     }
     const found = [];
     const named = (specifier) => {
-        if (specifier?.startsWith("./") === true || specifier?.startsWith("../") === true) {
+        if (specifier !== undefined && startsRelativePath(specifier)) {
             found.push(specifier);
         }
     };

package/dist/src/facts.js

@@ -1,13 +1,13 @@
 /**
  * The facts document `--facts` writes, `bindings.1` and `bindings.2`: the run's generated
- * files under the one decision the generated-file class reads. It carries no binding
- * record, so it states `evaluated: false`.
+ * files under the one decision the generated-file class reads, and the binding identities
+ * they publish. No binding state is computed, so it states `evaluated: false` (`bindings.10`).
  */
 import { FACTS_VERSION } from "./contract/contract.generated.js";
 import { LANGUAGE, PRODUCT } from "./product.js";
 import { bytewise } from "./text/compare.js";
 /** The facts document of one run, as the text written to the path `--facts` names. */
-export function factsDocument(version, generated) {
+export function factsDocument(version, generated, bindings) {
     const document = {
         facts_version: FACTS_VERSION,
         analyzer: { name: PRODUCT, version },
@@ -32,7 +32,7 @@ export function factsDocument(version, generated) {
                     schema_files: fact.generator.schemaFiles,
                 }),
         })),
-        bindings: [],
+        bindings,
     };
     return `${JSON.stringify(document, null, 2)}\n`;
 }

package/dist/src/findings/completion.js

@@ -79,12 +79,13 @@ function testedByIn(input) {
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A member an `in` expression tests by name, and one a function outside the
- * analysis fills, is `possible`.
+ * consumer set. A member an `in` expression tests by name, one a function outside the
+ * analysis fills, and one {@link possiblyLoaded} names, is `possible`.
  */
 function reachabilityClasses(input) {
     const tested = testedByIn(input);
     const filled = input.boundary.filledOutside ?? new Set();
+    const possible = possiblyLoaded(input);
     const published = publishedIds(input.swept.matrix.union);
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
@@ -93,7 +94,7 @@ function reachabilityClasses(input) {
             ? "certain"
             : "probable";
     return (id) => {
-        if (tested.has(id) || filled.has(id)) {
+        if (tested.has(id) || filled.has(id) || possible.has(id)) {
             return "possible";
         }
         return published.has(id) ? outside : "certain";
@@ -137,6 +138,35 @@ function testCeilings(input, classOf) {
         ? testTargets(union, id).reduce((lowest, target) => capped(lowest, classOf(target)), "certain")
         : "certain";
 }
+/**
+ * What only a bundler's retry of an import Node leaves unresolved names (program.38), and each
+ * dead declaration that reaches through dead declarations, as confidence.20 reads what only
+ * tests reach: each is dead only while no loader the analysis does not see loads the file.
+ */
+function possiblyLoaded(input) {
+    const seeds = input.boundary.possiblyLoaded ?? new Set();
+    if (seeds.size === 0) {
+        return seeds;
+    }
+    const union = input.swept.matrix.union;
+    const dead = new Set(input.swept.sweep.candidates.map((one) => one.id));
+    const reached = new Set();
+    const pending = union.symbols.flatMap((symbol, at) => (seeds.has(symbol.id) ? [at] : []));
+    for (let at = pending.pop(); at !== undefined; at = pending.pop()) {
+        const symbol = union.symbols[at];
+        if (symbol === undefined || reached.has(symbol.id)) {
+            continue;
+        }
+        reached.add(symbol.id);
+        for (const edge of union.out[at] ?? []) {
+            const to = union.symbols[edge.to];
+            if (to !== undefined && dead.has(to.id)) {
+                pending.push(edge.to);
+            }
+        }
+    }
+    return reached;
+}
 /**
  * The subjects dead only because production code only tests use is: each declaration the
  * sweep marks test-used, each `DS1602` file of such code, and each test of dead code every
@@ -281,6 +311,7 @@ export function completed(input, findings, kinds = KINDS) {
     const union = swept.matrix.union;
     const positions = new Map(union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]));
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
+    const fileIds = new Map(union.symbols.flatMap((one) => (one.kind === "file" ? [[one.position.path, one.id]] : [])));
     const classOf = reachabilityClasses(input);
     const ceilingOf = testCeilings(input, classOf);
     const testUsed = testUsedSubjects(input);
@@ -365,7 +396,12 @@ export function completed(input, findings, kinds = KINDS) {
         const counts = candidate === undefined
             ? union.made[at]
             : { production: candidate.productionRefs, test: candidate.testRefs };
-        const ownClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const ownClass = judged !== undefined
+            ? classOf(judged.id)
+            : (finding.reachabilityClass ??
+                (finding.code === CODE.fileNeverImported
+                    ? classOf(fileIds.get(finding.position.path) ?? "")
+                    : "certain"));
         const used = judged !== undefined
             ? candidate !== undefined && testUsed.declarations.has(judged.id)
             : finding.code === CODE.fileNeverImported && testUsed.files.has(finding.position.path);

package/dist/src/{implementations.js → findings/implementations.js}

@@ -7,9 +7,9 @@
  */
 import { isClassDeclaration, isHeritageClause, isInterfaceDeclaration, isMethodDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.js";
-import { nodeKey } from "./inventory.js";
-import { must, Unanswerable } from "./query.js";
+import { aliasChains } from "../alias-chain.js";
+import { nodeKey } from "../inventory.js";
+import { must, Unanswerable } from "../query.js";
 /** The interfaces, the classes and the `implements` entries of one project's own files. */
 function walk(project, held) {
     const interfaces = [];

package/dist/src/{in-operands.js → findings/in-operands.js}

@@ -4,8 +4,8 @@
  * links the read to a declaration, so only a text match can tell which member it reads.
  */
 import { isBinaryExpression, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { sourceFilesOf } from "./source-files.js";
-import { bytewise } from "./text/compare.js";
+import { sourceFilesOf } from "../source-files.js";
+import { bytewise } from "../text/compare.js";
 /**
  * The text of each string literal, or template literal with no substitution, written as
  * the left operand of an `in` expression in a file of the project that is no test file.

package/dist/src/framework-lifecycle.js

@@ -1,9 +1,10 @@
 /**
- * The framework-lifecycle class: a member a `ts.lifecycle_contracts` entry lists is held
- * back on each class that is the entry's component, being a class a decorator or a call
- * the entry's `components` name is attached to or passes, or one extending, directly or
- * through a chain, a class its `bases` name. A component's members are its type's, so a
- * member a base class declares answers for every subclass.
+ * The framework-lifecycle class: a member a lifecycle contract lists is held back on each
+ * class that is the contract's component, being a class a decorator or a call the
+ * contract's `components` name is attached to or passes, or one extending, directly or
+ * through a chain, a class its `bases` name. The contracts are the platform's custom
+ * elements and each `ts.lifecycle_contracts` entry. A component's members are its type's,
+ * so a member a base class declares answers for every subclass.
  */
 import { isClassDeclaration, isClassExpression, isHeritageClause, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
@@ -13,6 +14,29 @@ import { entriesAt, names, namesADeclaration, resolveEntries, spelledEntry, } fr
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";
+/**
+ * The platform's own contract (references-ts.38): `CustomElementRegistry.define` reads
+ * these members off the class it registers, its constructor's and its prototype's
+ * (https://html.spec.whatwg.org/multipage/custom-elements.html#dom-customelementregistry-define),
+ * and calls each callback as a custom element reaction.
+ */
+const CUSTOM_ELEMENTS = {
+    components: [{ global: "CustomElementRegistry.define" }],
+    members: [
+        "observedAttributes:static",
+        "disabledFeatures:static",
+        "formAssociated:static",
+        "connectedCallback",
+        "disconnectedCallback",
+        "connectedMoveCallback",
+        "adoptedCallback",
+        "attributeChangedCallback",
+        "formAssociatedCallback",
+        "formResetCallback",
+        "formDisabledCallback",
+        "formStateRestoreCallback",
+    ],
+};
 /** Every contract's components and bases, resolved in one pass over the entries. */
 function resolveContracts(project, held, contracts) {
     const entries = contracts.flatMap((contract) => [
@@ -155,16 +179,17 @@ function byBases(project, held, chains, contracts) {
 }
 /**
  * The framework-lifecycle detector: each member a contract lists, on each class that
- * is a component of that contract's framework, recorded where the class was found to
- * be one.
+ * is a component of that contract's framework, recorded once per place where the class
+ * was found to be one.
  */
 export function frameworkLifecycle(input) {
     const { project, held, targetRoot } = input;
-    if (input.ts.lifecycle_contracts.length === 0) {
+    const declared = [CUSTOM_ELEMENTS, ...input.ts.lifecycle_contracts];
+    const contracts = resolveContracts(project, held, declared);
+    if (contracts.every((one) => one.components.length === 0 && one.bases.length === 0)) {
         return [];
     }
     const chains = aliasChains(project, held);
-    const contracts = resolveContracts(project, held, input.ts.lifecycle_contracts);
     const components = [
         ...byComponents(project, held, chains, contracts),
         ...byBases(project, held, chains, contracts),
@@ -173,22 +198,24 @@ export function frameworkLifecycle(input) {
         return [];
     }
     const ids = new Set(components.map((one) => one.id));
-    const sides = input.ts.lifecycle_contracts.some((contract) => contract.members.some((name) => name.endsWith(":static")))
+    const sides = declared.some((contract) => contract.members.some((name) => name.endsWith(":static")))
         ? ["instance", "static"]
         : ["instance"];
     const members = sides.map((side) => classMembers(project, held, ids, side));
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
-    const found = [];
+    const found = new Map();
     for (const component of components) {
         const listed = new Set(component.contract.members);
         const site = renderPosition(component.site.getSourceFile(), targetRoot, component.site.getStart());
         for (const member of members.flatMap((side) => side.get(component.id) ?? [])) {
             const symbol = byId.get(member.id);
             const spelled = symbol === undefined ? undefined : memberComponent(symbol, byId);
-            if (spelled !== undefined && listed.has(spelled)) {
-                found.push({ id: member.id, detail: component.detail, site });
+            // A configured contract may name the platform's registry too; one record answers both.
+            const key = `${member.id}\0${component.detail}\0${site.path}:${String(site.line)}:${String(site.column)}`;
+            if (spelled !== undefined && listed.has(spelled) && !found.has(key)) {
+                found.set(key, { id: member.id, detail: component.detail, site });
             }
         }
     }
-    return found;
+    return [...found.values()];
 }

package/dist/src/graph.js

@@ -4,6 +4,7 @@
  * nothing, so a sweep over it is a function of the values it was built from, and the
  * inventory's order is the order every set a sweep answers reads in.
  */
+import { madeByTestCode } from "./tests/file-class.js";
 /** The position of a declaration the inventory does not hold. */
 export const OUTSIDE = -1;
 /**
@@ -79,24 +80,31 @@ export function graphOf(symbols, references, roots, testFiles, supportFiles = []
     const at = (id) => index.get(id) ?? OUTSIDE;
     const tests = new Set(testFiles);
     const out = symbols.map(() => []);
-    const made = symbols.map(() => ({ production: 0, test: 0 }));
+    const made = symbols.map(() => ({ production: 0, test: 0, consumerTest: 0 }));
     const consumed = [];
     for (const reference of references) {
         const to = at(reference.to);
         if (to === OUTSIDE) {
             continue;
         }
+        const test = madeByTestCode(reference, supports);
         const counts = made[to];
         if (counts !== undefined) {
-            if (reference.test) {
+            if (test) {
                 counts.test += 1;
+                counts.consumerTest += reference.consumer === undefined ? 0 : 1;
             }
             else {
                 counts.production += 1;
             }
         }
-        const edge = { to, test: reference.test, evaluation: reference.use === "evaluation" };
-        if (reference.consumer !== undefined || reference.unheld === true) {
+        const edge = {
+            to,
+            test,
+            evaluation: reference.use === "evaluation",
+            consumer: reference.consumer !== undefined,
+        };
+        if (edge.consumer || reference.unheld === true) {
             consumed.push(edge);
             continue;
         }

package/dist/src/import-bindings.js

@@ -2,7 +2,7 @@
  * The import bindings of one file: the names its import declarations bind, which only
  * the file itself can read.
  */
-import { isExportSpecifier, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isJsxElement, isJsxFragment, isJsxSelfClosingElement, isNamespaceImport, SyntaxKind, } from "@typescript/native/ast";
+import { isExportDeclaration, isExportSpecifier, isExternalModuleReference, isImportDeclaration, isImportEqualsDeclaration, isJsxElement, isJsxFragment, isJsxSelfClosingElement, isNamedExports, isNamespaceImport, SyntaxKind, } from "@typescript/native/ast";
 /** The extensions of the files whose import bindings are judged: no markup can read them. */
 const JUDGED = /\.(?:[mc]?ts|tsx|[mc]?js|jsx)$/u;
 /** The compiler's `jsx` settings whose emit calls no factory the file must hold. */
@@ -13,41 +13,86 @@ const DOC_COMMENT = /\/\*\*[\s\S]*?\*\//gu;
 const DOC_REFERENCE = /\{[^{}]*\}|@see\s+[A-Za-z_$][\w$.]*/gu;
 /** The factory a pragma comment names: `@jsx h` or `@jsxFrag Fragment`. */
 const PRAGMA = /@jsx(?:Frag)?\s+([A-Za-z_$][\w$]*)/gu;
+const bindingsCache = new WeakMap();
 /**
- * The names one file's import declarations bind: the default, named and namespace names of
- * an `import` declaration, and the name of an `import x = require()` declaration that is
- * not exported. None is judged in a declaration file or a component file.
+ * Every name one import declaration binds, in source order: the default, named and
+ * namespace names of an `import` declaration and the name of an `import x = …` declaration.
+ * A namespace import and an import assignment bind a whole module.
  */
-export function importBindings(file) {
-    if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
-        return [];
+export function declarationBindings(declaration) {
+    if (isImportEqualsDeclaration(declaration)) {
+        return [
+            {
+                name: declaration.name,
+                equals: {
+                    exported: (declaration.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword),
+                    external: isExternalModuleReference(declaration.moduleReference),
+                },
+            },
+        ];
     }
+    const clause = declaration.importClause;
     const found = [];
-    for (const statement of file.statements) {
-        if (isImportDeclaration(statement)) {
-            const clause = statement.importClause;
-            if (clause?.name !== undefined) {
-                found.push(clause.name);
-            }
-            const named = clause?.namedBindings;
-            if (named !== undefined && isNamespaceImport(named)) {
-                found.push(named.name);
-            }
-            else if (named !== undefined) {
-                for (const element of named.elements) {
-                    found.push(element.name);
-                }
-            }
-        }
-        else if (isImportEqualsDeclaration(statement) &&
-            isExternalModuleReference(statement.moduleReference) &&
-            isIdentifier(statement.name) &&
-            !(statement.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword)) {
-            found.push(statement.name);
+    if (clause?.name !== undefined) {
+        found.push({ name: clause.name, imported: "default" });
+    }
+    const named = clause?.namedBindings;
+    if (named !== undefined && isNamespaceImport(named)) {
+        found.push({ name: named.name });
+    }
+    else if (named !== undefined) {
+        for (const element of named.elements) {
+            found.push({ name: element.name, imported: element.propertyName?.text ?? element.name.text });
         }
     }
     return found;
 }
+/** Every name one file's top-level import declarations bind, in source order. */
+export function bindingsOf(file) {
+    const known = bindingsCache.get(file);
+    if (known !== undefined) {
+        return known;
+    }
+    const found = file.statements.flatMap((statement) => isImportDeclaration(statement) || isImportEqualsDeclaration(statement)
+        ? declarationBindings(statement)
+        : []);
+    bindingsCache.set(file, found);
+    return found;
+}
+/**
+ * The export names an import or a re-export declaration reads from the module it names,
+ * `undefined` standing for the whole module where a namespace or a star reads it; none for
+ * any other node.
+ */
+export function importedNames(node) {
+    if (isImportDeclaration(node)) {
+        return declarationBindings(node).map((binding) => binding.imported);
+    }
+    if (!isExportDeclaration(node)) {
+        return [];
+    }
+    const clause = node.exportClause;
+    return clause === undefined || !isNamedExports(clause)
+        ? [undefined]
+        : clause.elements.map((one) => (one.propertyName ?? one.name).text);
+}
+/** The export names {@link importedNames} gives one node, without the whole module. */
+export function namesImported(node) {
+    return importedNames(node).flatMap((name) => name ?? []);
+}
+/**
+ * The bindings of one file that are judged as imports: those of {@link bindingsOf} but an
+ * `import x = …` that is exported or names no external module. None is judged in a
+ * declaration file or a component file.
+ */
+export function importBindings(file) {
+    if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
+        return [];
+    }
+    return bindingsOf(file).flatMap((binding) => binding.equals !== undefined && (binding.equals.exported || !binding.equals.external)
+        ? []
+        : [binding.name]);
+}
 /** Whether one identifier names a binding in a local export, which reads it whatever it resolves to. */
 export function exportsLocally(use) {
     return isExportSpecifier(use.parent);