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

package/dist/src/inventory/commonjs.js

@@ -1,16 +1,17 @@
 import { isArrayBindingPattern, isArrowFunction, isAssignmentOperator, isAwaitExpression, isBinaryExpression, isBindingElement, isCallExpression, isClassDeclaration, isClassExpression, isClassStaticBlockDeclaration, isComputedPropertyName, isDeleteExpression, isElementAccessExpression, isEqualityOperator, isExpressionStatement, isForOfStatement, isFunctionDeclaration, isFunctionExpression, isFunctionLikeDeclaration, isGetAccessorDeclaration, isIdentifier, isIfStatement, isMetaProperty, isMethodDeclaration, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectBindingPattern, isObjectLiteralExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAccessExpression, isPropertyAssignment, isSetAccessorDeclaration, isShorthandPropertyAssignment, isSourceFile, isSpreadAssignment, isStringLiteral, isTypeOfExpression, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, ModifierFlags, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
 import { componentOf, modifiersOf, } from "../inventory.js";
+import { callsPlatformBy, lexicalBinding, writtenName } from "../platform-calls.js";
 import { spellsNoBinding } from "../spelled-names.js";
 import { unwrapped } from "../unwrap.js";
 /**
  * The export table of a CommonJS file: the module value `module.exports` is assigned and
  * the properties written on it, read from the top-level unconditional statements in order,
  * as Node runs them (https://nodejs.org/api/modules.html#moduleexports). Each entry is
- * keyed by the node that writes it, which is the checker's declaration of the export where
- * it binds one, so the two name one subject. Any other write of the exports opens the
- * table: its entries are kept and the file is listed open.
+ * keyed by the node that writes it, the checker's declaration of the export where it binds
+ * one. Any other write of the exports opens the table: its entries are kept and the file is
+ * listed open. `declarationOf` reads a `require()` call through the file's own scopes.
  */
-export function commonJS(typeIsModule, resolved) {
+export function commonJS(typeIsModule, resolved, declarationOf) {
     return {
         declare(file, owner, into) {
             if (!isCommonJS(file, owner.position.path, typeIsModule)) {
@@ -18,7 +19,7 @@ export function commonJS(typeIsModule, resolved) {
             }
             const bound = boundOccurrences(file, resolved);
             const free = (node) => !bound.has(node);
-            const table = readTable(file, free, topLevelDeclarations(file));
+            const table = readTable(file, free, topLevelDeclarations(file), lexicalBinding(declarationOf));
             const open = table.open || opens(file, free, table.modelled);
             for (const entry of table.entries.values()) {
                 const record = into.declare(entry.node, owner, entry.kind, entry.name, {
@@ -176,24 +177,33 @@ function topLevelDeclarations(file) {
 }
 const DEFAULT = { text: "default", computed: false };
 /** The table one file's top-level unconditional statements write, in order. */
-function readTable(file, isFree, declarations) {
+function readTable(file, isFree, declarations, bindingOf) {
     const entries = new Map();
     const modelled = new Set();
+    // Written inside the closures below, which the compiler's narrowing does not follow.
     let open = false;
     let aliasing = true;
+    let whole;
+    let wholeOpen = false;
     const free = (node, name) => isIdentifier(node) && node.text === name && isFree(node);
     const isModuleExports = (node) => isPropertyAccessExpression(node) &&
         free(node.expression, "module") &&
         node.name.text === "exports";
-    const isRequire = (node) => isCallExpression(node) &&
-        free(node.expression, "require") &&
-        node.arguments.length === 1 &&
-        node.arguments[0] !== undefined &&
-        isLiteralText(node.arguments[0]);
+    const isRequire = (node) => {
+        if (!isCallExpression(node) || node.arguments.length !== 1) {
+            return false;
+        }
+        const [argument] = node.arguments;
+        const callee = writtenName(node.expression);
+        return (argument !== undefined &&
+            isLiteralText(argument) &&
+            callee !== undefined &&
+            callsPlatformBy("require", callee, bindingOf));
+    };
     /** What a value written under one key declares. */
     const entryOf = (component, node, name, value) => {
         const held = value === undefined ? undefined : unwrapped(value);
-        const base = { node, name, component, localName: undefined };
+        const base = { node, name, component, localName: undefined, value };
         if (held === undefined) {
             return { ...base, kind: "variable" };
         }
@@ -245,6 +255,7 @@ function readTable(file, isFree, declarations) {
     /** The module value one assignment writes, placed at the `exports` name it assigns. */
     const moduleValue = (node, name) => {
         entries.clear();
+        whole = node.right;
         const value = unwrapped(node.right);
         if (isRequire(value)) {
             return;
@@ -253,7 +264,7 @@ function readTable(file, isFree, declarations) {
             value.properties.forEach(literalProperty);
             return;
         }
-        const base = { node, name, component: DEFAULT };
+        const base = { node, name, component: DEFAULT, value: node.right };
         const target = isIdentifier(value) ? declarations.get(value.text) : undefined;
         if (target !== undefined) {
             entries.set("default", { ...base, localName: undefined, kind: "export-alias", target });
@@ -273,7 +284,7 @@ function readTable(file, isFree, declarations) {
             });
         }
         else {
-            open = true;
+            wholeOpen = true;
         }
     };
     /** Whether one expression is the exports object a top-level write may name here. */
@@ -300,8 +311,17 @@ function readTable(file, isFree, declarations) {
             }
             else if (isModuleExports(left)) {
                 modelled.add(expression);
-                moduleValue(expression, left.name);
-                aliasing = false;
+                const inner = unwrapped(expression.right);
+                const chained = isBinaryExpression(inner) &&
+                    inner.operatorToken.kind === SyntaxKind.EqualsToken &&
+                    free(inner.left, "exports")
+                    ? inner
+                    : undefined;
+                if (chained !== undefined) {
+                    modelled.add(chained);
+                }
+                moduleValue(chained ?? expression, left.name);
+                aliasing = chained !== undefined;
             }
             else if (isPropertyAccessExpression(left) || isElementAccessExpression(left)) {
                 const object = exportsObject(left.expression);
@@ -332,7 +352,32 @@ function readTable(file, isFree, declarations) {
             }
         }
     }
-    return { entries, open, modelled };
+    return { entries, open: open || wholeOpen, modelled, whole, membersOpen: open };
+}
+/**
+ * The module value one file leaves where Node runs it as CommonJS, read by the one table
+ * the inventory's export table reads, or undefined where the file writes module syntax.
+ * `declarationOf` names the declaration each name resolves to, undefined for none, as a
+ * lexical reading of a file outside every program answers it.
+ */
+export function commonJSModuleValue(file, declarationOf) {
+    if (writesModuleSyntax(file)) {
+        return undefined;
+    }
+    const free = (node) => {
+        const declaration = isIdentifier(node) ? declarationOf(node) : undefined;
+        return declaration === undefined || !bindsOwn(declaration, file);
+    };
+    const table = readTable(file, free, topLevelDeclarations(file), lexicalBinding(declarationOf));
+    const held = table.whole === undefined ? undefined : unwrapped(table.whole);
+    const members = [...table.entries.values()].flatMap((entry) => entry.component === DEFAULT && held !== undefined && !isObjectLiteralExpression(held)
+        ? []
+        : [{ key: entry.component.text, value: entry.value, node: entry.node }]);
+    return {
+        whole: held === undefined || isObjectLiteralExpression(held) ? undefined : table.whole,
+        members,
+        open: table.membersOpen || opens(file, free, table.modelled),
+    };
 }
 /** Whether one node is `Object.defineProperty`. */
 function isDefineProperty(node) {

package/dist/src/inventory/enumerate.js

@@ -4,6 +4,7 @@ import { packageScope, packageTypeIsModule } from "../load/package-scope.js";
 import { relativePath } from "../paths.js";
 import { renderPosition } from "../position.js";
 import { isAnswered, UNANSWERED } from "../query.js";
+import { declarationOf } from "../entries/static-module.js";
 import { commonJS } from "./commonjs.js";
 import { SYNTAX } from "./syntax.js";
 /**
@@ -18,7 +19,7 @@ export function inventory(project, host, targetRoot) {
     const moduleOf = packageScope(host, targetRoot);
     const sources = [
         SYNTAX,
-        commonJS(packageTypeIsModule(host, targetRoot), resolvedIn(project)),
+        commonJS(packageTypeIsModule(host, targetRoot), resolvedIn(project), declarationOf),
     ];
     const into = new Builder(targetRoot);
     for (const file of files) {

package/dist/src/javascript-file.js

@@ -1,26 +1,41 @@
+import { LANGUAGE_ROWS } from "./contract/contract.generated.js";
+import { globExpression } from "./text/glob.js";
 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. */
+/** 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) {
-    return MINIFIED_NAME.test(fileName);
+    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, text) {
+/**
+ * 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, text) {
     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. */
 function utf8Bytes(text) {

package/dist/src/load/classify.js

@@ -1,9 +1,9 @@
-import { conventionFailuresFor } from "../conventions.js";
+import { conventionFailuresFor } from "../entries/conventions.js";
 import { relativePath, resolvePath } from "../paths.js";
 import { diagnosticsOf, ownedAs } from "../session.js";
 import { skipAt } from "../type-errors.js";
 import { classOf, MISSING_GLOBAL_TYPE, projectErrors, renderDiagnostic, } from "./diagnostics.js";
-import { targetRelative } from "./discover.js";
+import { targetRelative, unreadableDetail, } from "./discover.js";
 import { missingModule, pathsOf } from "./expected-module.js";
 import { FailureExit, failureLine } from "../failure.js";
 import { JAVASCRIPT_FILE } from "../javascript-file.js";
@@ -80,7 +80,7 @@ function classifyTarget(engine, host, run, plan, view, unfound) {
     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,
@@ -134,7 +134,7 @@ function classifyConsumer(engine, host, run, plan, consumer, project) {
     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;
     const reading = readErrors(project, plan, raw.check, {
@@ -173,7 +173,7 @@ function ending(plan, failed, root) {
     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`,
             },
         ]
@@ -184,6 +184,22 @@ function ending(plan, failed, root) {
             },
         ];
 }
+/** The setup failures a dropped derived configuration counts as, where it counts as any. */
+function droppedFailures(failed, plan, root) {
+    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, root) {
     return failed.kind === "load"
@@ -206,7 +222,6 @@ export function classify(engine, host, run, views) {
     const analyzed = [];
     const consumed = [];
     const ended = new Map();
-    const dropped = [];
     const unopened = run.plans.filter((plan) => !views.has(plan.configFile));
     const outcomes = [
         ...run.plans.flatMap((plan) => {
@@ -237,8 +252,12 @@ export function classify(engine, host, run, views) {
             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"]) {
@@ -248,7 +267,7 @@ export function classify(engine, host, run, views) {
             throw new FailureExit(kind === "unopened" ? [failures[0]] : failures, all.flatMap(({ failed }) => (failed.kind === "load" ? failed.errors : [])));
         }
     }
-    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(setupDropped ?? [

package/dist/src/load/diagnostics.js

@@ -68,12 +68,19 @@ function locatedIn(diagnostics, locate) {
 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;
 /** The errors one open project carries, each located in the file it names. */
 export function projectErrors(sets) {
     const unplaced = (kind) => 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/dist/src/load/discover.js

@@ -66,11 +66,9 @@ function readConfiguration(engine, configFile) {
     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) {
         return { reason: message(error) };
@@ -137,8 +135,12 @@ export function targetWithoutSources(target) {
     return failureExit("no-program", `${target} holds no compiler configuration, no file named ${MARKERS.join(", ")}, and no JavaScript file: run from the directory that holds one, or name the languages to analyze`);
 }
 /** A target configuration a matrix or the invocation names that cannot be built, ending the run. */
-function unbuilt(named, reason) {
-    throw failureExit("no-program", `${named} ${reason}: correct the configuration, or name the configurations to analyze`);
+function unbuilt(named, reason, failureClass = "no-program") {
+    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, reason) {
+    return `${named} ${reason}: correct the configuration, or name the configurations to analyze`;
 }
 /**
  * The projects a build matrix declares, in its order, each a file below the target root, a
@@ -172,7 +174,7 @@ function declaredProjects(engine, host, targetRoot, entries) {
         }
         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 = {
@@ -212,13 +214,19 @@ function derivedProjects(engine, host, scope) {
     const idOf = (configFile) => relativePath(targetRoot, configFile) ?? configFile;
     const notBuilt = [];
     const found = derivedFrom(engine, host, [...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 = {
+            failureClass: "unreadable-configuration",
+            detail: targetRelative(unreadableDetail(idOf(configFile), why), absoluteRoot),
+        };
         notBuilt.push({
             id: idOf(configFile),
             configFile,
             error: targetRelative(reason, absoluteRoot),
+            failures: [failure],
         });
     });
     const configurations = found.map(({ configFile, parsed }) => ({

package/dist/src/load/plan.js

@@ -1,7 +1,7 @@
-import { readConventions } from "../conventions.js";
+import { readConventions, } from "../entries/conventions.js";
 import { holdsManifest, inInstalledPackages, MANIFEST, readManifestAt } from "../fs/manifest.js";
 import { gitIgnored } from "../git-ignore.js";
-import { packageEntries, readManifest } from "../manifest.js";
+import { packageEntries, readManifest, } from "../roots/manifest.js";
 import { ancestors, dirnamePath, joinPath, normalizePath, relativePath, resolvePath, } from "../paths.js";
 import { bytewise } from "../text/compare.js";
 import { globExpression } from "../text/glob.js";

package/dist/src/load/synthesize.js

@@ -5,12 +5,12 @@
  * is written for.
  */
 import { readCommands } from "../commands/read.js";
-import { CONVENTION_ROWS } from "../convention-rows.js";
+import { CONVENTION_ROWS } from "../entries/convention-rows.js";
 import { holdsManifest, MANIFEST, readManifestAt } from "../fs/manifest.js";
 import { filesBelow } from "../fs/tree.js";
-import { JAVASCRIPT_FILE, minified, minifiedByName } from "../javascript-file.js";
+import { JAVASCRIPT_FILE, minifiedBy, minifiedByName } from "../javascript-file.js";
 import { isRecord } from "../json-document.js";
-import { manifestCommands } from "../manifest.js";
+import { manifestCommands } from "../roots/manifest.js";
 import { ancestors, dirnamePath, joinPath, relativePath } from "../paths.js";
 import { bytewise } from "../text/compare.js";
 import { writtenPath } from "./workspace-programs.js";
@@ -33,11 +33,11 @@ const FORMED_OPTIONS = {
 };
 /** Whether one file is minified build output; one that cannot be read is left to the compiler. */
 function minifiedFile(host, file) {
-    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/dist/src/load/workspace-manifests.js

@@ -6,7 +6,7 @@
  * workspace imports, so only its commands are entry points.
  */
 import { emittedFrom } from "./emit-map.js";
-import { readManifest } from "../manifest.js";
+import { readManifest } from "../roots/manifest.js";
 import { joinPath, relativePath } from "../paths.js";
 import { MANIFEST } from "../fs/manifest.js";
 /** The one character a subpath pattern of a manifest's `exports` holds. */

package/dist/src/matrix.js

@@ -81,19 +81,12 @@ export function matrixOf(per) {
     };
 }
 /**
- * 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, input) {
     const per = matrix.graphs.map((graph) => sweep(graph, input));

package/dist/src/outside-tests.js

@@ -7,7 +7,7 @@
  * it names is not known.
  */
 import { isCallExpression, isExportDeclaration, isImportDeclaration, isNamespaceExport, isNamespaceImport, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { RESOLVED_EXTENSIONS } from "./configuration-files.js";
+import { RESOLVED_EXTENSIONS } from "./entries/configuration-files.js";
 import { emittedFrom } from "./load/emit-map.js";
 import { namesImported } from "./module-declarations.js";
 import { dirnamePath, joinPath, normalizePath, queriedModulePath } from "./paths.js";

package/dist/src/paths.js

@@ -88,6 +88,22 @@ export function extensionOf(path) {
 export function resolvePath(against, path) {
     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, reference) {
+    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/dist/src/platform-calls.js

@@ -0,0 +1,78 @@
+/**
+ * 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, } from "@typescript/native/ast";
+import { parenthesesRemoved, unwrapped } from "./unwrap.js";
+/** 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) {
+    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) {
+    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) {
+    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, callee, bindingOf, seen = new Set()) {
+    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);
+    });
+}