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

package/src/javascript-file.ts

@@ -1,29 +1,46 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.ts";
+import { globExpression } from "./text/glob.ts";
+
 export const JAVASCRIPT_FILE = /\.(?:js|jsx|mjs|cjs)$/u;
 
-/** A minified file by its name; any other is one by its size and its mean line length. */
-const MINIFIED_NAME = /\.min\.(?:js|mjs|cjs)$/u;
+/** The patterns the TypeScript row of `languages.json` skips files by, each matched against a name alone. */
+const MINIFIED_NAMES = LANGUAGE_ROWS.ts.skippedFiles.map((pattern) => ({
+  pattern,
+  expression: globExpression(pattern),
+}));
 const MINIFIED_BYTES = 10_240;
 const MINIFIED_LINE = 500;
 
-/** Whether one name is a minified file's, which decides it without its text. */
-export function minifiedByName(fileName: string): boolean {
-  return MINIFIED_NAME.test(fileName);
+/** What a minified file is decided by where its text is not read. */
+const LONG_LINES = "long lines";
+
+/** The skipped-file pattern one file's name matches, which decides it minified without its text. */
+export function minifiedByName(fileName: string): string | undefined {
+  const name = fileName.slice(fileName.lastIndexOf("/") + 1);
+  return MINIFIED_NAMES.find((one) => one.expression.test(name))?.pattern;
 }
 
-/** Whether one JavaScript file is minified: by its name, or by its text's size and mean line length. */
-export function minified(fileName: string, text: string): boolean {
+/**
+ * What decides one JavaScript file minified: the skipped-file pattern its name matches, or
+ * {@link LONG_LINES} for a text of the size whose mean line is longer than the limit;
+ * undefined for a file that is not minified.
+ */
+export function minifiedBy(fileName: string, text: string): string | undefined {
   if (!JAVASCRIPT_FILE.test(fileName)) {
-    return false;
+    return undefined;
   }
-  if (minifiedByName(fileName)) {
-    return true;
+  const named = minifiedByName(fileName);
+  if (named !== undefined) {
+    return named;
   }
   // A UTF-16 unit encodes to at most three UTF-8 bytes, so a shorter text is below the size.
   if (text.length * 3 < MINIFIED_BYTES) {
-    return false;
+    return undefined;
   }
   const lines = text.split(/\r?\n/u).length;
-  return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE;
+  return utf8Bytes(text) >= MINIFIED_BYTES && text.length / lines > MINIFIED_LINE
+    ? LONG_LINES
+    : undefined;
 }
 
 /** The length of a text in UTF-8, a lone surrogate counting as the three bytes of U+FFFD. */

package/src/load/classify.ts

@@ -1,5 +1,5 @@
 import type { SourceFile } from "@typescript/native/ast";
-import { conventionFailuresFor } from "../conventions.ts";
+import { conventionFailuresFor } from "../entries/conventions.ts";
 import type { Host } from "../host.ts";
 import { relativePath, resolvePath } from "../paths.ts";
 import { diagnosticsOf, ownedAs, type Engine, type ProjectView } from "../session.ts";
@@ -11,7 +11,13 @@ import {
   renderDiagnostic,
   type LocatedDiagnostic,
 } from "./diagnostics.ts";
-import { targetRelative, type LoadedConsumer, type NotBuilt, type Origin } from "./discover.ts";
+import {
+  targetRelative,
+  unreadableDetail,
+  type LoadedConsumer,
+  type NotBuilt,
+  type Origin,
+} from "./discover.ts";
 import { missingModule, pathsOf, type ModuleContext } from "./expected-module.ts";
 import { FailureExit, failureLine, type Failure } from "../failure.ts";
 import type { ProgramPlan, RunPlan } from "./plan.ts";
@@ -21,8 +27,12 @@ import { ownErrors } from "./workspace-run.ts";
 
 /** What keeps one configuration from being analyzed. */
 type Failed =
-  /** Its project carries an error that leaves it unloaded. */
-  | { readonly kind: "load"; readonly errors: readonly [LocatedDiagnostic, ...LocatedDiagnostic[]] }
+  /** Its project carries an error that leaves it unloaded, its configuration unreadable or not. */
+  | {
+      readonly kind: "load";
+      readonly errors: readonly [LocatedDiagnostic, ...LocatedDiagnostic[]];
+      readonly unreadable: boolean;
+    }
   | { readonly kind: "setup"; readonly failures: readonly [Failure, ...Failure[]] }
   /** The snapshot opened no project for it. */
   | { readonly kind: "unopened" };
@@ -162,7 +172,7 @@ function classifyTarget<Brand>(
   const raw = projectErrors(diagnosticsOf(project));
   const load = nonEmpty(raw.load);
   if (load !== undefined) {
-    return { kind: "load", errors: load };
+    return { kind: "load", errors: load, unreadable: raw.unreadable };
   }
   const reading = readErrors(project, plan, ownErrors(raw.check, referenceOnly), {
     host,
@@ -236,7 +246,7 @@ function classifyConsumer<Brand>(
   const raw = projectErrors(diagnosticsOf(project));
   const load = nonEmpty(raw.load);
   if (load !== undefined) {
-    return { kind: "load", errors: load };
+    return { kind: "load", errors: load, unreadable: raw.unreadable };
   }
   let faulted: string | undefined;
   const reading = readErrors(project, plan, raw.check, {
@@ -283,7 +293,8 @@ function ending(plan: ProgramPlan, failed: Failed, root: string): readonly Failu
   return plan.consumer === undefined
     ? [
         {
-          failureClass: "no-program",
+          failureClass:
+            failed.kind === "load" && failed.unreadable ? "unreadable-configuration" : "no-program",
           detail: `${what}: correct the configuration, or name the configurations to analyze`,
         },
       ]
@@ -295,6 +306,30 @@ function ending(plan: ProgramPlan, failed: Failed, root: string): readonly Failu
       ];
 }
 
+/** The setup failures a dropped derived configuration counts as, where it counts as any. */
+function droppedFailures(
+  failed: Failed,
+  plan: ProgramPlan,
+  root: string,
+): { readonly failures?: readonly [Failure, ...Failure[]] } {
+  if (failed.kind === "setup") {
+    return { failures: failed.failures };
+  }
+  return failed.kind === "load" && failed.unreadable
+    ? {
+        failures: [
+          {
+            failureClass: "unreadable-configuration",
+            detail: unreadableDetail(
+              plan.id,
+              `cannot be read as a compiler configuration: ${droppedBy(failed, root)}`,
+            ),
+          },
+        ],
+      }
+    : {};
+}
+
 /** The first line of the error that drops one derived configuration. */
 function droppedBy(failed: Failed, root: string): string {
   return failed.kind === "load"
@@ -326,7 +361,6 @@ export function classify(
   const analyzed: Analyzed<unknown>[] = [];
   const consumed: Consumed<unknown>[] = [];
   const ended = new Map<Failed["kind"], { plan: ProgramPlan; failed: Failed }[]>();
-  const dropped: Failed[] = [];
   const unopened = run.plans.filter((plan) => !views.has(plan.configFile));
   const outcomes = [
     ...run.plans.flatMap((plan) => {
@@ -355,8 +389,12 @@ export function classify(
     } else if (POLICY[plan.origin][outcome.kind] === "end") {
       ended.set(outcome.kind, [...(ended.get(outcome.kind) ?? []), { plan, failed: outcome }]);
     } else {
-      dropped.push(outcome);
-      notBuilt.push({ id: plan.id, configFile: plan.configFile, error: droppedBy(outcome, root) });
+      notBuilt.push({
+        id: plan.id,
+        configFile: plan.configFile,
+        error: droppedBy(outcome, root),
+        ...droppedFailures(outcome, plan, root),
+      });
     }
   }
   for (const kind of ["unopened", "setup", "load"] as const) {
@@ -369,9 +407,7 @@ export function classify(
       );
     }
   }
-  const setupDropped = nonEmpty(
-    dropped.flatMap((one) => (one.kind === "setup" ? one.failures : [])),
-  );
+  const setupDropped = nonEmpty(notBuilt.flatMap((one) => one.failures ?? []));
   const [first] = notBuilt;
   if (analyzed.length === 0 && first !== undefined) {
     throw new FailureExit(

package/src/load/diagnostics.ts

@@ -121,10 +121,18 @@ export function diagnosticErrors(sets: {
   return [...sets.configParsing, ...sets.syntactic, ...sets.semantic].filter(isError);
 }
 
+/**
+ * The code of a configuration whose only parse error is that its inputs name no file: it reads
+ * as written and holds no program.
+ */
+const NO_INPUTS = 18003;
+
 /** Why one open project cannot be analyzed as it stands, split by whether it loaded at all. */
 interface ProjectErrors {
   /** The configuration's own errors and the errors in no file the table reads as a load failure. */
   readonly load: readonly LocatedDiagnostic[];
+  /** Whether the compiler cannot read the configuration: a parse error other than {@link NO_INPUTS}. */
+  readonly unreadable: boolean;
   /** The errors in the files of a project that loaded. */
   readonly check: readonly LocatedDiagnostic[];
   /** The libraries the configuration names that the compiler cannot find, of a project that loaded. */
@@ -135,9 +143,11 @@ interface ProjectErrors {
 export function projectErrors(sets: ProjectDiagnostics): ProjectErrors {
   const unplaced = (kind: DiagnosticClass): readonly Diagnostic[] =>
     sets.unplaced.filter((diagnostic) => classOf(diagnostic, false) === kind);
-  const load = [...sets.configParsing.filter(isError), ...unplaced("load")];
+  const parsing = sets.configParsing.filter(isError);
+  const load = [...parsing, ...unplaced("load")];
   return {
     load: locatedIn(load, sets.locate),
+    unreadable: parsing.some(({ code }) => code !== NO_INPUTS),
     check: load.length > 0 ? [] : locatedIn(diagnosticErrors(sets), sets.locate),
     unfound: load.length > 0 ? [] : locatedIn(unplaced("unfound-library"), sets.locate),
   };

package/src/load/discover.ts

@@ -2,13 +2,13 @@ import type { BuildConfiguration, ProjectConfiguration } from "../config.ts";
 import { LANGUAGE_ROWS } from "../contract/contract.generated.ts";
 import { filesBelow, filesIn } from "../fs/tree.ts";
 import type { Host } from "../host.ts";
-import { packageScope } from "../inventory.ts";
+import { packageScope } from "./package-scope.ts";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "../paths.ts";
 import { LANGUAGE, message } from "../product.ts";
 import type { Module, Scope } from "../scope.ts";
 import type { Engine } from "../session.ts";
 import { globExpression } from "../text/glob.ts";
-import { failureExit, type FailureExit } from "../failure.ts";
+import { failureExit, type Failure, type FailureExit } from "../failure.ts";
 import { MANIFEST } from "../fs/manifest.ts";
 
 /** The names of the files a program of the language is read from. */
@@ -72,6 +72,8 @@ export interface NotBuilt {
   readonly configFile: string;
   /** The error's first line, every path below the target root spelled relative to it. */
   readonly error: string;
+  /** The setup failures that dropped it, where one did. */
+  readonly failures?: readonly [Failure, ...Failure[]];
 }
 
 /**
@@ -165,11 +167,9 @@ function readConfiguration(
   try {
     const parsed = engine.parseConfigFile(configFile);
     const circular = parsed.errors.find(({ code }) => code === CIRCULAR_EXTENDS);
-    // The compiler leaves the message's `{0}` unfilled:
-    // https://github.com/microsoft/TypeScript/pull/64755
     return circular === undefined
       ? { parsed }
-      : { reason: `TS${String(circular.code)}: ${circular.text.replace("{0}", () => configFile)}` };
+      : { reason: `TS${String(circular.code)}: ${circular.text}` };
   } catch (error: unknown) {
     return { reason: message(error) };
   }
@@ -274,11 +274,17 @@ export function targetWithoutSources(target: string): FailureExit {
 }
 
 /** A target configuration a matrix or the invocation names that cannot be built, ending the run. */
-function unbuilt(named: string, reason: string): never {
-  throw failureExit(
-    "no-program",
-    `${named} ${reason}: correct the configuration, or name the configurations to analyze`,
-  );
+function unbuilt(
+  named: string,
+  reason: string,
+  failureClass: Failure["failureClass"] = "no-program",
+): never {
+  throw failureExit(failureClass, unreadableDetail(named, reason));
+}
+
+/** What fails and the fix, for a configuration `named` that `reason` keeps from being built. */
+export function unreadableDetail(named: string, reason: string): string {
+  return `${named} ${reason}: correct the configuration, or name the configurations to analyze`;
 }
 
 /**
@@ -321,7 +327,11 @@ function declaredProjects(
     }
     const read = readConfiguration(engine, configFile);
     if ("reason" in read) {
-      unbuilt(named, `cannot be read as a compiler configuration: ${read.reason}`);
+      unbuilt(
+        named,
+        `cannot be read as a compiler configuration: ${read.reason}`,
+        "unreadable-configuration",
+      );
     }
     references.set(configFile, referencesOf(read.parsed));
     const configuration: Configuration = {
@@ -377,13 +387,19 @@ function derivedProjects(
     [...fromScope, ...configFilesUnder(host, targetRoot)],
     (reference) => relativePath(rootDir, reference) !== undefined,
     (configFile, reason) => {
+      const why = `cannot be read as a compiler configuration: ${reason}`;
       if (fromScope.includes(configFile)) {
-        unbuilt(configFile, `cannot be read as a compiler configuration: ${reason}`);
+        unbuilt(configFile, why, "unreadable-configuration");
       }
+      const failure: Failure = {
+        failureClass: "unreadable-configuration",
+        detail: targetRelative(unreadableDetail(idOf(configFile), why), absoluteRoot),
+      };
       notBuilt.push({
         id: idOf(configFile),
         configFile,
         error: targetRelative(reason, absoluteRoot),
+        failures: [failure],
       });
     },
   );

package/src/load/package-scope.ts

@@ -0,0 +1,74 @@
+import { manifestAt } from "../fs/manifest.ts";
+import type { Host } from "../host.ts";
+import { dirnamePath, joinPath } from "../paths.ts";
+import type { Module } from "../ref.ts";
+
+/** One manifest that names a package, and the directory below the root that holds it. */
+interface Named {
+  readonly name: string;
+  readonly at: string;
+}
+
+/**
+ * Resolves each file's package scope: the name of the nearest manifest at or above its
+ * directory up to the target root, and the file's path below that manifest. Where no
+ * manifest up to the root carries a name, the package is a single dot and the path is read
+ * from the root, which cannot collide, because a package name never starts with a dot. One
+ * directory is read at most once.
+ */
+export function packageScope(host: Host, root: string): (path: string) => Module {
+  const named = new Map<string, Named | undefined>();
+
+  const manifestName = (dir: string): string | undefined => {
+    const name = manifestAt(host, joinPath(root, dir))?.["name"];
+    return typeof name === "string" && name !== "" ? name : undefined;
+  };
+
+  const nearest = (dir: string): Named | undefined => {
+    if (named.has(dir)) {
+      return named.get(dir);
+    }
+    const name = manifestName(dir);
+    const found =
+      name !== undefined ? { name, at: dir } : dir === "" ? undefined : nearest(parentOf(dir));
+    named.set(dir, found);
+    return found;
+  };
+
+  return (path) => {
+    const found = nearest(parentOf(path));
+    if (found === undefined) {
+      return { package: ".", path };
+    }
+    return { package: found.name, path: found.at === "" ? path : path.slice(found.at.length + 1) };
+  };
+}
+
+/**
+ * Whether Node reads each file's `.js` siblings as ECMAScript modules: the `type` of the
+ * nearest manifest at or above its directory up to the target root is `module`
+ * (https://nodejs.org/api/packages.html#type). One directory is read at most once.
+ */
+export function packageTypeIsModule(host: Host, root: string): (path: string) => boolean {
+  const typed = new Map<string, boolean>();
+
+  const nearest = (dir: string): boolean => {
+    const known = typed.get(dir);
+    if (known !== undefined) {
+      return known;
+    }
+    const manifest = manifestAt(host, joinPath(root, dir));
+    const found =
+      manifest !== undefined ? manifest["type"] === "module" : dir !== "" && nearest(parentOf(dir));
+    typed.set(dir, found);
+    return found;
+  };
+
+  return (path) => nearest(parentOf(path));
+}
+
+/** The directory one path below the root sits in, and the root itself as the empty path. */
+function parentOf(path: string): string {
+  const dir = dirnamePath(path);
+  return dir === "." ? "" : dir;
+}

package/src/load/plan.ts

@@ -1,10 +1,19 @@
 import type { CreateSnapshotProgramParams } from "@typescript/native/sync";
 import type { PartialConfig } from "../config.ts";
-import { readConventions, type ConventionManifest, type Conventions } from "../conventions.ts";
+import {
+  readConventions,
+  type ConventionManifest,
+  type Conventions,
+} from "../entries/conventions.ts";
 import { holdsManifest, inInstalledPackages, MANIFEST, readManifestAt } from "../fs/manifest.ts";
 import { gitIgnored } from "../git-ignore.ts";
 import type { Host } from "../host.ts";
-import { packageEntries, readManifest, type Manifest, type ManifestEntry } from "../manifest.ts";
+import {
+  packageEntries,
+  readManifest,
+  type Manifest,
+  type ManifestEntry,
+} from "../roots/manifest.ts";
 import {
   ancestors,
   dirnamePath,

package/src/load/synthesize.ts

@@ -6,14 +6,14 @@
  */
 
 import { readCommands } from "../commands/read.ts";
-import { CONVENTION_ROWS } from "../convention-rows.ts";
-import type { Conventions } from "../conventions.ts";
+import { CONVENTION_ROWS } from "../entries/convention-rows.ts";
+import type { Conventions } from "../entries/conventions.ts";
 import { holdsManifest, MANIFEST, readManifestAt, type ManifestRead } from "../fs/manifest.ts";
 import { filesBelow } from "../fs/tree.ts";
 import type { Host } from "../host.ts";
-import { JAVASCRIPT_FILE, minified, minifiedByName } from "../javascript-file.ts";
+import { JAVASCRIPT_FILE, minifiedBy, minifiedByName } from "../javascript-file.ts";
 import { isRecord } from "../json-document.ts";
-import { manifestCommands } from "../manifest.ts";
+import { manifestCommands } from "../roots/manifest.ts";
 import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.ts";
 import type { Engine } from "../session.ts";
 import { bytewise } from "../text/compare.ts";
@@ -50,11 +50,11 @@ interface CandidateContext {
 
 /** Whether one file is minified build output; one that cannot be read is left to the compiler. */
 function minifiedFile(host: Host, file: string): boolean {
-  if (minifiedByName(file)) {
+  if (minifiedByName(file) !== undefined) {
     return true;
   }
   try {
-    return minified(file, host.readFile(file));
+    return minifiedBy(file, host.readFile(file)) !== undefined;
   } catch {
     return false;
   }

package/src/load/test-globals.ts

@@ -23,7 +23,7 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
-import type { ParseFile } from "../configuration-files.ts";
+import type { ParseFile } from "../entries/configuration-files.ts";
 import type { Host } from "../host.ts";
 import { isRecord } from "../json-document.ts";
 import { ancestors, dirnamePath, joinPath } from "../paths.ts";

package/src/load/workspace-manifests.ts

@@ -8,7 +8,7 @@
 
 import { emittedFrom } from "./emit-map.ts";
 import type { Host } from "../host.ts";
-import { readManifest, type Manifest, type ManifestEntry } from "../manifest.ts";
+import { readManifest, type Manifest, type ManifestEntry } from "../roots/manifest.ts";
 import { joinPath, relativePath } from "../paths.ts";
 import type { WorkspaceMember } from "./workspace.ts";
 import type { WorkspaceResolver } from "./workspace-resolution.ts";

package/src/load/workspace-run.ts

@@ -6,7 +6,7 @@
  */
 
 import type { Host } from "../host.ts";
-import type { Manifest, ManifestEntry } from "../manifest.ts";
+import type { Manifest, ManifestEntry } from "../roots/manifest.ts";
 import { relativePath } from "../paths.ts";
 import type { Engine } from "../session.ts";
 import type { LocatedDiagnostic } from "./diagnostics.ts";

package/src/matrix.ts

@@ -9,7 +9,7 @@ import { graphOf, OUTSIDE, type Graph } from "./graph.ts";
 import type { InventorySymbol } from "./inventory.ts";
 import { byPosition } from "./position.ts";
 import type { Reference } from "./references.ts";
-import type { Root } from "./roots.ts";
+import type { Root } from "./roots/root-set.ts";
 import {
   reachedWithTheTests,
   sweep,
@@ -198,19 +198,12 @@ export function matrixOf(per: readonly Configured[]): Matrix {
 }
 
 /**
- * Answers which declarations of the run are dead in every configuration that holds them.
- *
- * Liveness is a question about one configuration, because a file another configuration
- * does not compile makes no reference there and a root it does not hold seeds nothing
- * there, so each configuration is swept on its own graph under the run's input. A
- * declaration is a candidate when every configuration holding it judged it one: a
- * reference under one configuration is a reference, so what one project uses is never
- * reported, and a configuration that does not hold a declaration says nothing about it.
- * The candidate's relation is reference counting where every configuration found it so,
- * and reachability otherwise; its counts are the union's, one per reference.
- *
- * The components are computed once, over the union and the intersected dead set, so one
- * dead component is one entry of the run with one identifier.
+ * Which declarations of the run are dead in every configuration that holds them. Each
+ * configuration is swept on its own graph, since a file it does not compile references nothing
+ * there and a root it does not hold seeds nothing. A declaration is a candidate when every
+ * configuration holding it judged it one; its relation is reference counting where every one
+ * found it so, else reachability, and its counts are the union's. Components are computed once,
+ * over the union and the intersected dead set, so one dead component has one identifier.
  */
 export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
   const per = matrix.graphs.map((graph) => sweep(graph, input));

package/src/outside-tests.ts

@@ -19,7 +19,7 @@ import {
   type Node,
   type SourceFile,
 } from "@typescript/native/ast";
-import { RESOLVED_EXTENSIONS, type ParseFile } from "./configuration-files.ts";
+import { RESOLVED_EXTENSIONS, type ParseFile } from "./entries/configuration-files.ts";
 import { emittedFrom } from "./load/emit-map.ts";
 import type { Host } from "./host.ts";
 import type { Inventory } from "./inventory.ts";

package/src/paths.ts

@@ -97,6 +97,24 @@ export function resolvePath(against: string, path: string): string {
   return isAbsolutePath(path) ? normalizePath(path) : joinPath(against, path);
 }
 
+/**
+ * A URL reference's scheme. A reference with none that does not start with a solidus is
+ * relative, the bare name included: https://url.spec.whatwg.org/#relative-url-string
+ */
+const URL_SCHEME = /^[a-z][a-z\d+.-]*:/iu;
+
+/**
+ * The path a relative URL reference names against `dir`, its query and its fragment
+ * removed, which name no part of the file; undefined where the reference is not relative.
+ */
+export function relativeURLPath(dir: string, reference: string): string | undefined {
+  if (reference === "" || reference.startsWith("/") || URL_SCHEME.test(reference)) {
+    return undefined;
+  }
+  const cut = reference.search(/[?#]/u);
+  return resolvePath(dir, cut < 0 ? reference : reference.slice(0, cut));
+}
+
 /**
  * The relative path before the query of a relative module specifier such as
  * `./worker.ts?worker`, the module a bundler loads; undefined for a specifier with no

package/src/platform-calls.ts

@@ -0,0 +1,119 @@
+/**
+ * Which calls are the platform's `require` and which constructions its `URL` (roots.23,
+ * references-ts.1), decided once over the bindings of the names a callee is written with: the
+ * checker's in a program, the file's own scopes in a module read outside every program.
+ */
+
+import {
+  isBindingElement,
+  isCallExpression,
+  isExportSpecifier,
+  isIdentifier,
+  isImportSpecifier,
+  isPropertyAccessExpression,
+  isStringLiteral,
+  isVariableDeclaration,
+  type Identifier,
+  type Node,
+} from "@typescript/native/ast";
+import { parenthesesRemoved, unwrapped } from "./unwrap.ts";
+
+/** A name of the platform the analysis reads calls of. */
+type PlatformName = "require" | "createRequire" | "URL";
+
+/** What one written name is bound to, as far as its reader can tell. */
+export interface Bound {
+  /** Its own name, and each one an import, a re-export or a destructuring carries it by. */
+  readonly names: ReadonlySet<string>;
+  /** The declarations of the target it resolves to, a variable's initializer read through. */
+  readonly own: readonly Node[];
+  /** Whether the type checker proves it the target's own, a function or a class it writes with a body. */
+  readonly provenOwn: boolean;
+}
+
+/** The binding of each written name, `undefined` where nothing answers which declaration it names. */
+export type BindingOf = (written: Identifier) => Bound | undefined;
+
+/** The name one declaration carries a binding by beside its own: the export an import or a re-export names, or the property a destructuring reads. */
+export function carriedNames(node: Node): readonly string[] {
+  if (isImportSpecifier(node) || isExportSpecifier(node)) {
+    return [(node.propertyName ?? node.name).text];
+  }
+  const property = isBindingElement(node) ? node.propertyName : undefined;
+  return property !== undefined && (isIdentifier(property) || isStringLiteral(property))
+    ? [property.text]
+    : [];
+}
+
+/**
+ * A written name's binding as a file states it, with no checker to ask, so nothing is
+ * proven the target's own (conventions.3): `declarationOf` names the declaration a name
+ * resolves to, and a property is read by how it is written alone.
+ */
+export function lexicalBinding(
+  declarationOf: (written: Identifier) => Node | undefined,
+): BindingOf {
+  return (written) => {
+    const parent = written.parent;
+    if (isPropertyAccessExpression(parent) && parent.name === written) {
+      return undefined;
+    }
+    const declaration = declarationOf(written);
+    return {
+      names: new Set([
+        written.text,
+        ...(declaration === undefined ? [] : carriedNames(declaration)),
+      ]),
+      own: declaration === undefined ? [] : [declaration],
+      provenOwn: false,
+    };
+  };
+}
+
+/** The name a callee or a constructor is written with, parentheses removed: an identifier or a property name. */
+export function writtenName(expression: Node): Identifier | undefined {
+  const at = parenthesesRemoved(expression);
+  if (isIdentifier(at)) {
+    return at;
+  }
+  return isPropertyAccessExpression(at) && isIdentifier(at.name) ? at.name : undefined;
+}
+
+/**
+ * Whether a call or construction through `callee` is one of the platform's `name`: never
+ * where its binding is proven the target's own; otherwise where it is written or carried
+ * by that name, or resolves to a variable of the target whose initializer is such a
+ * callee or, for `require`, a call of a `createRequire`. A callee nothing binds is read by
+ * how it is written.
+ */
+export function callsPlatformBy(
+  name: PlatformName,
+  callee: Identifier,
+  bindingOf: BindingOf,
+  seen = new Set<Node>(),
+): boolean {
+  const bound = bindingOf(callee);
+  if (bound?.provenOwn === true) {
+    return false;
+  }
+  if (callee.text === name || bound?.names.has(name) === true) {
+    return true;
+  }
+  return (bound?.own ?? []).some((node) => {
+    if (seen.has(node) || !isVariableDeclaration(node) || node.initializer === undefined) {
+      return false;
+    }
+    seen.add(node);
+    const value = unwrapped(node.initializer);
+    if (isCallExpression(value)) {
+      const called = writtenName(value.expression);
+      return (
+        name === "require" &&
+        called !== undefined &&
+        callsPlatformBy("createRequire", called, bindingOf, seen)
+      );
+    }
+    const written = writtenName(value);
+    return written !== undefined && callsPlatformBy(name, written, bindingOf, seen);
+  });
+}