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

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

@@ -1,6 +1,6 @@
 import { LANGUAGE_ROWS } from "../contract/contract.generated.js";
 import { filesBelow, filesIn } from "../fs/tree.js";
-import { packageScope } from "../inventory.js";
+import { packageScope } from "./package-scope.js";
 import { dirnamePath, joinPath, relativePath, resolvePath } from "../paths.js";
 import { LANGUAGE, message } from "../product.js";
 import { globExpression } from "../text/glob.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/package-scope.js

@@ -0,0 +1,56 @@
+import { manifestAt } from "../fs/manifest.js";
+import { dirnamePath, joinPath } from "../paths.js";
+/**
+ * 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, root) {
+    const named = new Map();
+    const manifestName = (dir) => {
+        const name = manifestAt(host, joinPath(root, dir))?.["name"];
+        return typeof name === "string" && name !== "" ? name : undefined;
+    };
+    const nearest = (dir) => {
+        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, root) {
+    const typed = new Map();
+    const nearest = (dir) => {
+        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) {
+    const dir = dirnamePath(path);
+    return dir === "." ? "" : dir;
+}

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);
+    });
+}

package/dist/src/platform-symbols.js

@@ -0,0 +1,140 @@
+/**
+ * The platform's names read through a program's checker: its `require` and `URL`, as
+ * `platform-calls.ts` decides them, its worker constructors and `navigator`, and Node's
+ * `Worker`.
+ */
+import { isArrowFunction, isClassDeclaration, isClassExpression, isFunctionDeclaration, isFunctionExpression, isMethodDeclaration, isModuleDeclaration, isPropertyAssignment, isPropertyDeclaration, isSourceFile, isStringLiteralLikeNode, isVariableDeclaration, } from "@typescript/native/ast";
+import { SymbolFlags } from "@typescript/native/sync";
+import { UNANSWERED } from "./query.js";
+import { boundExports, NAMESPACE } from "./entries/static-module.js";
+import { isAmbient } from "./inventory.js";
+import { callsPlatformBy, carriedNames } from "./platform-calls.js";
+import { unwrapped } from "./unwrap.js";
+/** The symbol one symbol names through its aliases, or the symbol itself where it is none. */
+function dealiased(project, symbol, asked) {
+    if ((symbol.flags & SymbolFlags.Alias) === 0) {
+        return symbol;
+    }
+    asked();
+    return project.queries.aliased(symbol);
+}
+/** Each declaration of `symbol` in a file of the target, read in this project's program. */
+function ownDeclarations(project, symbol) {
+    const own = project.ownPaths();
+    return symbol.declarations.flatMap((handle) => {
+        const node = own.has(handle.path) ? project.declarationAt(handle)?.node : undefined;
+        return node === undefined ? [] : [node];
+    });
+}
+/**
+ * Whether one declaration writes a function or a class with a body (roots.23): a function
+ * or method declaration with a body, a class declaration, or a variable, a property or a
+ * class field whose initializer is a function, an arrow function or a class expression,
+ * under no `declare` modifier and in no declaration file.
+ */
+function writesBody(node) {
+    const value = (isVariableDeclaration(node) || isPropertyAssignment(node) || isPropertyDeclaration(node)) &&
+        node.initializer !== undefined
+        ? unwrapped(node.initializer)
+        : node;
+    return ((isFunctionDeclaration(value) || isMethodDeclaration(value)
+        ? value.body !== undefined
+        : isFunctionExpression(value) ||
+            isArrowFunction(value) ||
+            isClassDeclaration(value) ||
+            isClassExpression(value)) && !isAmbient(value.getSourceFile(), value));
+}
+/**
+ * What the checker binds `symbol` to, one alias step at a time: every name a step of the
+ * chain carries it by, and the declarations of the target its last step reaches, which
+ * prove it the target's own where one {@link writesBody}. A chain that ends at no
+ * declaration, or that the checker leaves unanswered, reaches none.
+ */
+function boundBy(project, symbol, asked) {
+    if (typeof symbol !== "object") {
+        return undefined;
+    }
+    const names = new Set();
+    const stepped = new Set();
+    for (let at = symbol; at !== undefined && !stepped.has(at.id);) {
+        stepped.add(at.id);
+        names.add(at.name);
+        const own = ownDeclarations(project, at);
+        for (const node of own) {
+            carriedNames(node).forEach((one) => names.add(one));
+        }
+        if ((at.flags & SymbolFlags.Alias) === 0) {
+            return { names, own, provenOwn: own.some(writesBody) };
+        }
+        asked();
+        const next = project.aliasStepOf(at);
+        at = typeof next === "object" ? next : undefined;
+    }
+    return { names, own: [], provenOwn: false };
+}
+/** Each written name's binding, as this project's checker answers it. */
+function checkerBinding(project, asked) {
+    return (written) => {
+        asked();
+        return boundBy(project, project.symbolsAt([project.handle(written)])[0], asked);
+    };
+}
+/**
+ * Whether a call or construction through `callee`, the batch's answer for which is `symbol`,
+ * is one of the platform's `require` or `URL` (roots.23, references-ts.1), as
+ * {@link callsPlatformBy} decides it over this project's checker, each request it puts
+ * counted by `asked`.
+ */
+export function callsPlatform(project, name, callee, symbol, asked) {
+    const others = checkerBinding(project, asked);
+    return callsPlatformBy(name, callee, (written) => written === callee ? boundBy(project, symbol, asked) : others(written));
+}
+/**
+ * Whether a worker's constructor or `navigator`, the batch's answer for which is `symbol`, is
+ * the platform's (references-ts.2): a name the checker leaves unanswered, or one whose symbol
+ * is no alias and has a declaration outside the target's files.
+ */
+export function isPlatformGlobal(project, symbol) {
+    if (symbol === UNANSWERED) {
+        return true;
+    }
+    const own = project.ownPaths();
+    return (symbol !== undefined &&
+        (symbol.flags & SymbolFlags.Alias) === 0 &&
+        symbol.declarations.some((handle) => !own.has(handle.path)));
+}
+/** The module names Node's worker threads are imported by. */
+const THREADS = new Set(["worker_threads", "node:worker_threads"]);
+function namesThreads(node) {
+    return node !== undefined && isStringLiteralLikeNode(node) && THREADS.has(node.text);
+}
+/** Whether one declaration is written in the body of `declare module "worker_threads"`. */
+function inThreadsModule(node) {
+    for (let at = node; !isSourceFile(at); at = at.parent) {
+        if (isModuleDeclaration(at) && namesThreads(at.name)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether a `Worker` constructor, the batch's answer for which is `symbol`, is Node's
+ * (references-ts.2): its symbol resolves to a declaration of `worker_threads`, or one of its
+ * own declarations binds the module's `Worker`, or `holder`, the namespace it is read
+ * through, binds the module, each binding read as {@link boundExports} reads one, which
+ * decides where the module has no declaration. Each request it puts is counted by `asked`.
+ */
+export function startsThread(project, symbol, holder, asked) {
+    const bindingOf = checkerBinding(project, asked);
+    const declared = (one, member) => typeof one === "object" &&
+        ownDeclarations(project, one).some((node) => boundExports(node, (specifier) => THREADS.has(specifier), bindingOf).includes(member));
+    if (declared(symbol, "Worker") || declared(holder, NAMESPACE)) {
+        return true;
+    }
+    const named = typeof symbol === "object" ? dealiased(project, symbol, asked) : undefined;
+    return (typeof named === "object" &&
+        named.declarations.some((handle) => {
+            const node = project.declarationAt(handle)?.node;
+            return node !== undefined && inThreadsModule(node);
+        }));
+}