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

package/src/generated-file.ts

@@ -1,12 +1,26 @@
 /**
  * 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.
+ * generated, below a directory an applied convention row names as generated, or minified,
+ * is retained, because a generator owns the file and a deletion there is undone at the next
+ * generation. The same decision is each `generated` entry of the facts document.
  */
 
+import {
+  isIdentifier,
+  isImportDeclaration,
+  isPropertyAssignment,
+  isStringLiteralLikeNode,
+  isVariableStatement,
+  NodeFlags,
+  type Node,
+  type SourceFile,
+} from "@typescript/native/ast";
+import { GENERATORS } from "./contract/contract.generated.ts";
 import type { DetectorInput, Evidence } from "./exempt.ts";
+import { minifiedBy } from "./javascript-file.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { bytewise } from "./text/compare.ts";
+import { satisfies } from "./version-range.ts";
 
 /** The generated-code header, matched against each line of a leading comment. */
 const HEADER_LINE = /^\/\/ Code generated .* DO NOT EDIT\.$/u;
@@ -23,9 +37,44 @@ const GENERATED_WORD = /\bgenerated\b/iu;
 /** The phrases a generator's notice asks a reader not to edit the file by. */
 const KEEP_OUT = /\b(?:do not edit|will be overwritten|should not make any changes)\b/iu;
 
-/** The comments before a text's first token, a leading hashbang line skipped. */
-function leadingComments(text: string): readonly string[] {
-  const comments: string[] = [];
+/** What decided a file generated, as the facts document's `evidence` names it. */
+type GeneratedEvidence = "header" | "tag" | "notice" | "convention" | "minified";
+
+/** The generator row one generated file matches, with the version and the schema files its output states. */
+interface GeneratorMatch {
+  readonly row: string;
+  readonly version?: string;
+  readonly schemaFiles: readonly string[];
+}
+
+/** Why one file is generated, and which generator wrote it. */
+export interface GeneratedFact {
+  readonly evidence: GeneratedEvidence;
+  /** The 1-based line of the comment line that marks the file; 1 for a row or a minified file. */
+  readonly line: number;
+  /** The marking line's text, the convention row's name, or what decided the file minified. */
+  readonly detail: string;
+  readonly generator?: GeneratorMatch;
+}
+
+/** One line of a leading comment, with its 1-based line in the file. */
+interface CommentLine {
+  readonly text: string;
+  readonly line: number;
+}
+
+/** The comments before a text's first token, a leading hashbang line skipped, each as its lines. */
+function leadingComments(text: string): readonly (readonly CommentLine[])[] {
+  const comments: CommentLine[][] = [];
+  const lineAt = (offset: number): number =>
+    text.slice(0, offset).split(/\r\n|[\n\r\u2028\u2029]/u).length;
+  const lines = (from: number, to: number): CommentLine[] => {
+    const first = lineAt(from);
+    return text
+      .slice(from, to)
+      .split(/\r\n|[\n\r\u2028\u2029]/u)
+      .map((one, index) => ({ text: one, line: first + index }));
+  };
   let at = text.startsWith("\uFEFF") ? 1 : 0;
   if (text.startsWith("#!", at)) {
     const end = text.indexOf("\n", at);
@@ -38,14 +87,14 @@ function leadingComments(text: string): readonly string[] {
     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));
+      comments.push(lines(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));
+      comments.push(lines(at, end + 2));
       at = end + 2;
     } else {
       return comments;
@@ -53,49 +102,201 @@ function leadingComments(text: string): readonly string[] {
   }
 }
 
-/** The detail a file's leading comments mark it generated by, or undefined where they mark nothing. */
-export function generatedByComment(text: string): string | undefined {
-  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";
+/** The mark one file's leading comments make it generated by, or undefined where they mark nothing. */
+export function generatedMark(text: string): Omit<GeneratedFact, "generator"> | undefined {
+  const lines = leadingComments(text).flat();
+  const header = lines.find((one) => HEADER_LINE.test(one.text));
+  if (header !== undefined) {
+    return { evidence: "header", line: header.line, detail: header.text };
+  }
+  const tag = lines.find((one) => GENERATED_TAG.test(one.text));
+  if (tag !== undefined) {
+    return { evidence: "tag", line: tag.line, detail: tag.text };
   }
-  if (comments.some((one) => GENERATED_TAG.test(one))) {
-    return "generated by the @generated tag its leading comments hold";
+  const [first] = lines;
+  if (first !== undefined && GENERATED_BY.test(first.text)) {
+    return { evidence: "notice", line: first.line, detail: first.text };
   }
-  const notice = comments.join("\n");
-  if (
-    GENERATED_BY.test(comments[0] ?? "") ||
-    (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice))
-  ) {
-    return "generated by the notice its leading comments hold";
+  const notice = lines.map((one) => one.text).join("\n");
+  if (GENERATED_WORD.test(notice) && KEEP_OUT.test(notice)) {
+    const marked = lines.find((one) => GENERATED_WORD.test(one.text) || KEEP_OUT.test(one.text));
+    return marked === undefined
+      ? undefined
+      : { evidence: "notice", line: marked.line, detail: marked.text };
+  }
+  return undefined;
+}
+
+/** What one form's first group captures, for each line the form matches. */
+function after(lines: readonly CommentLine[], form: RegExp): readonly string[] {
+  return lines.flatMap((one) => form.exec(one.text)?.[1] ?? []);
+}
+
+/**
+ * Where each plugin's output states its version and its schema files, as `references-ts.36`
+ * states: a plugin missing here states no version, and one with no schema form names none.
+ */
+const STATEMENTS: Readonly<Record<string, { version?: RegExp; schemaFiles?: RegExp }>> = {
+  "protoc-gen-es": {
+    version: /^\/\/ @generated by protoc-gen-es (\S+)/u,
+    schemaFiles: /^\/\/ @generated from file (\S+)/u,
+  },
+  "protoc-gen-connect-es": {
+    version: /^\/\/ @generated by protoc-gen-connect-es (\S+)/u,
+    schemaFiles: /^\/\/ @generated from file (\S+)/u,
+  },
+  "protobuf-ts": {
+    version: /^\/\/ @generated by protobuf-ts (\S+)/u,
+    schemaFiles: /^\/\/ @generated from protobuf file "([^"]+)"/u,
+  },
+  "ts-proto": {
+    version: /^\/\/\s+protoc-gen-ts_proto\s+(\S+)$/u,
+    schemaFiles: /^\/\/ source: (.+)$/u,
+  },
+  "protoc-gen-grpc-web": {
+    version: /^\/\/\s+protoc-gen-grpc-web\s+(\S+)$/u,
+    schemaFiles: /^\/\/ source: (.+)$/u,
+  },
+  "protoc-gen-js": { schemaFiles: /^\/\/ source: (.+)$/u },
+  "ts-protoc-gen": { schemaFiles: /^\/\/ file: (.+)$/u },
+};
+
+/** A ts-proto service path literal: `/<package>.<service>/<method>`. */
+const SERVICE_PATH = /^\/(?:\w+\.)+\w+\/\w+$/u;
+
+/** Whether one ts-proto file writes a service path, as `references-ts.36` reads one. */
+function writesServicePath(file: SourceFile): boolean {
+  const named = file.statements.some(
+    (statement) =>
+      isVariableStatement(statement) &&
+      (statement.declarationList.flags & NodeFlags.Const) !== 0 &&
+      statement.declarationList.declarations.some(
+        (one) =>
+          isIdentifier(one.name) &&
+          one.name.text.endsWith("ServiceName") &&
+          one.initializer !== undefined &&
+          isStringLiteralLikeNode(one.initializer),
+      ),
+  );
+  let found = named;
+  const visit = (node: Node): void => {
+    if (found) {
+      return;
+    }
+    if (
+      isPropertyAssignment(node) &&
+      isIdentifier(node.name) &&
+      node.name.text === "path" &&
+      isStringLiteralLikeNode(node.initializer) &&
+      SERVICE_PATH.test(node.initializer.text)
+    ) {
+      found = true;
+      return;
+    }
+    node.forEachChild(visit);
+  };
+  file.forEachChild(visit);
+  return found;
+}
+
+/** Whether one file imports a module by its specifier. */
+function imports(file: SourceFile, module: string): boolean {
+  return file.statements.some(
+    (statement) =>
+      isImportDeclaration(statement) &&
+      isStringLiteralLikeNode(statement.moduleSpecifier) &&
+      statement.moduleSpecifier.text === module,
+  );
+}
+
+/** The option sets the rows of `references-ts.36` name, by row; every other row's is met by any output. */
+const OPTION_SETS: Readonly<Record<string, (file: SourceFile) => boolean>> = {
+  "ts-proto-2-output-schema": (file) => imports(file, "ts-proto-descriptors"),
+  "ts-proto-2": writesServicePath,
+  "ts-proto-2-types": (file) => !writesServicePath(file),
+};
+
+/** The first generator row one file matches, in `generators.json`'s order, as `bindings.3` reads it. */
+export function generatorOf(file: SourceFile): GeneratorMatch | undefined {
+  const lines = leadingComments(file.text).flat();
+  for (const row of GENERATORS) {
+    const header = new RegExp(row.header, "u");
+    if (!lines.some((one) => header.test(one.text))) {
+      continue;
+    }
+    const statements = STATEMENTS[row.plugin] ?? {};
+    const [version] = statements.version === undefined ? [] : after(lines, statements.version);
+    if (
+      "versions" in row &&
+      (version === undefined ||
+        !satisfies(
+          version.replace(/^v/u, ""),
+          `>=${row.versions.min.replace(/^v/u, "")} <=${row.versions.max.replace(/^v/u, "")}`,
+        ))
+    ) {
+      continue;
+    }
+    if (OPTION_SETS[row.id]?.(file) === false) {
+      continue;
+    }
+    const schemaFiles =
+      statements.schemaFiles === undefined
+        ? []
+        : [
+            ...new Set(
+              after(lines, statements.schemaFiles).filter((one) => one.endsWith(".proto")),
+            ),
+          ].sort(bytewise);
+    return { row: row.id, ...(version === undefined ? {} : { version }), schemaFiles };
   }
   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.
+ * Every own file of one project that is generated, by its path below the target root, with
+ * what decided it: its leading comments' mark, else the row naming its directory as
+ * generated, else its minified name or text; and the generator row it matches.
  */
 export function generatedFilesOf(
   files: SourceFiles,
   byRow: ReadonlyMap<string, string>,
-): ReadonlyMap<string, string> {
-  const found = new Map<string, string>();
+): ReadonlyMap<string, GeneratedFact> {
+  const found = new Map<string, GeneratedFact>();
   for (const [path, file] of files.byPath) {
     const row = byRow.get(path);
-    const detail =
-      generatedByComment(file.text) ??
+    const minified = row === undefined ? minifiedBy(file.fileName, file.text) : undefined;
+    const fact =
+      generatedMark(file.text) ??
       (row === undefined
-        ? undefined
-        : `generated below a directory the convention row ${row} names`);
-    if (detail !== undefined) {
-      found.set(path, detail);
+        ? minified === undefined
+          ? undefined
+          : { evidence: "minified" as const, line: 1, detail: minified }
+        : { evidence: "convention" as const, line: 1, detail: row });
+    if (fact === undefined) {
+      continue;
     }
+    const generator = generatorOf(file);
+    found.set(path, generator === undefined ? fact : { ...fact, generator });
   }
   return found;
 }
 
+/** The detail a retention in a generated file names, from what decided the file. */
+function retentionDetail(fact: GeneratedFact): string {
+  switch (fact.evidence) {
+    case "header":
+      return "generated by the header line its leading comments hold";
+    case "tag":
+      return "generated by the @generated tag its leading comments hold";
+    case "notice":
+      return "generated by the notice its leading comments hold";
+    case "convention":
+      return `generated below a directory the convention row ${fact.detail} names`;
+    case "minified":
+      return "generated as a minified JavaScript file";
+  }
+}
+
 /** The generated-file detector, recording each file's first line. */
 export function generatedFile<Brand>(input: DetectorInput<Brand>): readonly Evidence[] {
   const generated = input.generated;
@@ -103,9 +304,15 @@ export function generatedFile<Brand>(input: DetectorInput<Brand>): readonly Evid
     return [];
   }
   return input.held.symbols.flatMap((symbol): Evidence[] => {
-    const detail = generated.get(symbol.position.path);
-    return symbol.kind === "file" || detail === undefined
+    const fact = generated.get(symbol.position.path);
+    return symbol.kind === "file" || fact === undefined
       ? []
-      : [{ id: symbol.id, detail, site: { path: symbol.position.path, line: 1, column: 1 } }];
+      : [
+          {
+            id: symbol.id,
+            detail: retentionDetail(fact),
+            site: { path: symbol.position.path, line: 1, column: 1 },
+          },
+        ];
   });
 }

package/src/git-ignore.ts

@@ -1,13 +1,15 @@
 /**
- * Which files the `.gitignore` files of a tree ignore, read as git reads them:
+ * Which files git ignores below a tree's root, read as git reads its ignore files:
  * https://git-scm.com/docs/gitignore#_pattern_format
  */
 
-import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
-import { dirnamePath, joinPath, relativePath } from "./paths.ts";
+import { ancestors, dirnamePath, joinPath, relativePath } from "./paths.ts";
+import { message } from "./product.ts";
+import { gitignoreExpression } from "./text/glob.ts";
+import { repositoryOf } from "./fs/tree.ts";
 
-/** One pattern line of a `.gitignore` file. */
+/** One pattern line of an ignore file. */
 interface Rule {
   readonly negated: boolean;
   /** Whether the pattern ends with `/`, so it matches a directory alone. */
@@ -16,7 +18,7 @@ interface Rule {
   readonly expression: RegExp;
 }
 
-/** The rules one `.gitignore` text writes, in order. */
+/** The rules one ignore file's text writes, in order. */
 function rulesOf(text: string): readonly Rule[] {
   const rules: Rule[] = [];
   for (const raw of text.split(/\r?\n/u)) {
@@ -25,7 +27,7 @@ function rulesOf(text: string): readonly Rule[] {
       continue;
     }
     const negated = line.startsWith("!");
-    line = negated || line.startsWith("\\") ? line.slice(1) : line;
+    line = negated ? line.slice(1) : line;
     const directoryOnly = line.endsWith("/");
     line = line.replace(/\/+$/u, "");
     if (line === "") {
@@ -38,43 +40,65 @@ function rulesOf(text: string): readonly Rule[] {
     rules.push({
       negated,
       directoryOnly,
-      expression: globExpression(anchored ? pattern : `**/${pattern}`),
+      expression: gitignoreExpression(anchored ? pattern : `**/${pattern}`),
     });
   }
   return rules;
 }
 
+/** Told each ignore file that exists and cannot be read, with why. */
+type UnreadIgnoreFile = (path: string, reason: string) => void;
+
+function rulesIn(host: Host, path: string, unread: UnreadIgnoreFile): readonly Rule[] {
+  try {
+    return rulesOf(host.readFile(path));
+  } catch (error: unknown) {
+    if (host.kindOf(path) !== "absent") {
+      unread(path, message(error));
+    }
+    return [];
+  }
+}
+
 /**
- * Whether the `.gitignore` files at and below `root` ignore one absolute path. A path
- * outside `root` is not ignored, and a file below an ignored directory stays ignored
- * whatever a later pattern says, as git cannot re-include it.
+ * Whether git ignores one absolute path below `root`: by the repository's `info/exclude`, then
+ * the `.gitignore` files from its root down to the path's directory, a later pattern overriding
+ * an earlier one, though a file below an ignored directory stays ignored, as git cannot re-include
+ * it. A path outside `root` is not ignored. With no repository, the files at and below `root` are
+ * read; with one, the directories above `root` give patterns but are not tested. An unreadable
+ * ignore file ignores nothing, and `unread` is told it.
  */
-export function gitIgnored(host: Host, root: string): (path: string) => boolean {
+export function gitIgnored(
+  host: Host,
+  root: string,
+  unread: UnreadIgnoreFile = () => undefined,
+): (path: string) => boolean {
+  const found = repositoryOf(host, root);
+  const repository = found?.root;
+  const above =
+    repository === undefined ? [] : [...ancestors(dirnamePath(root), repository)].reverse();
+  const excluded = found?.exclude === undefined ? [] : rulesIn(host, found.exclude, unread);
   const read = new Map<string, readonly Rule[]>();
   const rulesAt = (dir: string): readonly Rule[] => {
     let rules = read.get(dir);
     if (rules === undefined) {
-      try {
-        rules = rulesOf(host.readFile(joinPath(dir, ".gitignore")));
-      } catch {
-        rules = [];
-      }
+      rules = rulesIn(host, joinPath(dir, ".gitignore"), unread);
       read.set(dir, rules);
     }
     return rules;
   };
-  /** Whether the rules of `root` and of each directory down to one path's own decide it ignored. */
   const decided = (path: string, directory: boolean): boolean => {
-    const dirs: string[] = [];
-    for (let at = dirnamePath(path); relativePath(root, at) !== undefined; at = dirnamePath(at)) {
-      dirs.unshift(at);
-    }
-    dirs.unshift(root);
+    const sources: [string, readonly Rule[]][] = [
+      ...(repository === undefined ? [] : [[repository, excluded] as [string, readonly Rule[]]]),
+      ...[...above, ...[...ancestors(dirnamePath(path), root)].reverse()].map(
+        (dir): [string, readonly Rule[]] => [dir, rulesAt(dir)],
+      ),
+    ];
     let ignored = false;
-    for (const dir of dirs) {
-      const below = relativePath(dir, path);
-      for (const rule of below === undefined ? [] : rulesAt(dir)) {
-        if ((directory || !rule.directoryOnly) && rule.expression.test(below ?? "")) {
+    for (const [dir, rules] of sources) {
+      const below = relativePath(dir, path) ?? "";
+      for (const rule of rules) {
+        if ((directory || !rule.directoryOnly) && rule.expression.test(below)) {
           ignored = !rule.negated;
         }
       }

package/src/host.ts

@@ -1,5 +1,5 @@
-/** What one path names. */
-export type PathKind = "file" | "directory" | "absent";
+/** What one path names: `"other"` is anything else there, a named pipe, a device or a socket. */
+export type PathKind = "file" | "directory" | "other" | "absent";
 
 /** One entry of a directory. */
 export interface DirectoryEntry {
@@ -17,11 +17,18 @@ export interface DirectoryEntry {
 export interface Host {
   /** The directory a relative path resolves against. */
   workingDirectory(): string;
-  /** The text of one file, or a throw naming why it cannot be read. */
-  readFile(path: string): string;
+  /**
+   * The text of one file, or a throw naming why it cannot be read. Given `limit`, the
+   * text of no more than the file's first `limit` bytes, so a caller bounding a document
+   * asks for one byte past its bound and never holds a larger file whole.
+   */
+  readFile(path: string, limit?: number): string;
   /** The entries of one directory, or a throw naming why it cannot be read. */
   readDirectory(path: string): readonly DirectoryEntry[];
-  /** What one path names, `"absent"` where nothing is there. */
+  /**
+   * What one path names once every symbolic link along it is followed, `"absent"` where
+   * nothing is there, or a throw naming why it cannot be known, as for a link loop.
+   */
   kindOf(path: string): PathKind;
   /**
    * The path one path names once every symbolic link along it is followed, or a throw

package/src/import-bindings.ts

@@ -4,17 +4,20 @@
  */
 
 import {
+  isExportDeclaration,
   isExportSpecifier,
   isExternalModuleReference,
-  isIdentifier,
   isImportDeclaration,
   isImportEqualsDeclaration,
   isJsxElement,
   isJsxFragment,
   isJsxSelfClosingElement,
+  isNamedExports,
   isNamespaceImport,
   SyntaxKind,
   type Identifier,
+  type ImportDeclaration,
+  type ImportEqualsDeclaration,
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
@@ -41,42 +44,108 @@ export interface JsxOptions {
   readonly jsxFragmentFactory?: unknown;
 }
 
+/** One name a file's top-level import declaration binds. */
+interface ImportBinding {
+  readonly name: Identifier;
+  /** The export name it binds, `default` for a default import; absent where it binds a whole module. */
+  readonly imported?: string;
+  /** An `import x = …` declaration: whether it is exported, and whether it names an external module. */
+  readonly equals?: { readonly exported: boolean; readonly external: boolean };
+}
+
+const bindingsCache = new WeakMap<SourceFile, readonly ImportBinding[]>();
+
 /**
- * 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: SourceFile): readonly Identifier[] {
-  if (file.isDeclarationFile || !JUDGED.test(file.fileName)) {
-    return [];
+export function declarationBindings(
+  declaration: ImportDeclaration | ImportEqualsDeclaration,
+): readonly ImportBinding[] {
+  if (isImportEqualsDeclaration(declaration)) {
+    return [
+      {
+        name: declaration.name,
+        equals: {
+          exported: (declaration.modifiers ?? []).some(
+            (modifier) => modifier.kind === SyntaxKind.ExportKeyword,
+          ),
+          external: isExternalModuleReference(declaration.moduleReference),
+        },
+      },
+    ];
   }
-  const found: Identifier[] = [];
-  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);
+  const clause = declaration.importClause;
+  const found: ImportBinding[] = [];
+  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: SourceFile): readonly ImportBinding[] {
+  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: Node): readonly (string | undefined)[] {
+  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: Node): readonly string[] {
+  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: SourceFile): readonly Identifier[] {
+  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: Identifier): boolean {
   return isExportSpecifier(use.parent);