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

package/dist/src/dependencies.js

@@ -7,11 +7,13 @@
  * itself is that dependency's need, not the target's.
  */
 import { isArrayLiteralExpression, isCallExpression, isExportDeclaration, isExpressionStatement, isExternalModuleReference, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isMetaProperty, isNamespaceExport, isObjectLiteralExpression, isPropertyAccessExpression, isPropertyAssignment, isShorthandPropertyAssignment, isStringLiteral, isNoSubstitutionTemplateLiteral, SyntaxKind, } from "@typescript/native/ast";
+import { amdLoadOf, amdPlatform } from "./amd.js";
 import { automaticTypes } from "./automatic-types.js";
 import { declaredIn as declaredBeside, dependenciesNamed, moduleStrings, outsideChain, } from "./entries/configuration-files.js";
+import { declarationBindings } from "./import-bindings.js";
 import { nodeKey } from "./inventory.js";
 import { packageScope } from "./load/package-scope.js";
-import { ancestors, dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath, } from "./paths.js";
+import { ancestors, cannotStartPackageName, dirnamePath, joinPath, relativePath, resolvePath, } from "./paths.js";
 import { UNANSWERED } from "./query.js";
 import { sourceFilesOf } from "./source-files.js";
 import { manifestCommands, nodemonTexts } from "./roots/manifest.js";
@@ -153,7 +155,7 @@ function configurationPackages(host, configFile, options, programPackages, parse
         }
         seen.add(file);
         for (const entry of extendsOf(host, file, parse)) {
-            if (entry.startsWith(".") || isAbsolutePath(entry)) {
+            if (cannotStartPackageName(entry)) {
                 const local = resolvePath(dirnamePath(file), entry);
                 pending.push(local.endsWith(".json") ? local : `${local}.json`);
             }
@@ -178,27 +180,9 @@ function importOf(specifier) {
 }
 /** The local names one import declaration binds. */
 function bindingsOf(node) {
-    if (node === undefined) {
-        return [];
-    }
-    if (isImportEqualsDeclaration(node)) {
-        return [node.name];
-    }
-    if (!isImportDeclaration(node) || node.importClause === undefined) {
-        return [];
-    }
-    const clause = node.importClause;
-    const names = clause.name === undefined ? [] : [clause.name];
-    const bindings = clause.namedBindings;
-    if (bindings !== undefined) {
-        if (bindings.kind === SyntaxKind.NamespaceImport) {
-            names.push(bindings.name);
-        }
-        else {
-            names.push(...bindings.elements.map((element) => element.name));
-        }
-    }
-    return names;
+    return node !== undefined && (isImportDeclaration(node) || isImportEqualsDeclaration(node))
+        ? declarationBindings(node).map((binding) => binding.name)
+        : [];
 }
 /**
  * Every package one project needs, and which declaration each use is written in.
@@ -428,6 +412,7 @@ function fileNeeds(project, held, file, { programPackages, automatic }, use) {
     }
     const loads = runtimeLoads(file);
     const callees = loads.flatMap((load) => load.callees);
+    const amdCallees = new Set(loads.flatMap((load) => (load.amd ? load.callees : [])));
     const asked = [
         ...specifiers,
         ...bindings.map(({ node }) => node),
@@ -517,10 +502,11 @@ function fileNeeds(project, held, file, { programPackages, automatic }, use) {
             unansweredCallees.add(callee);
             return;
         }
-        // The decision reads the callee's symbol and its written name, and nothing else of it.
-        const key = symbol === undefined ? undefined : `${symbol.id}\u0000${callee.text}`;
+        // The decision reads the callee's symbol, its written name and its platform name, and nothing else.
+        const platform = amdCallees.has(callee) ? amdPlatform(callee) : "require";
+        const key = symbol === undefined ? undefined : `${symbol.id}\u0000${platform}\u0000${callee.text}`;
         const answer = (key === undefined ? undefined : decided.get(key)) ??
-            callsPlatform(project, "require", callee, symbol, () => undefined);
+            callsPlatform(project, platform, callee, symbol);
         if (key !== undefined) {
             decided.set(key, answer);
         }
@@ -543,12 +529,22 @@ function fileNeeds(project, held, file, { programPackages, automatic }, use) {
  * argument is literal text naming a package: a `require()` call, which the compiler lists among
  * a file's imports only in a JavaScript file and only through the bare name; a `.resolve` of
  * another name, which needs it where that name is a `require`; and `import.meta.resolve` or
- * a `.resolve` of the name `require`, whatever it names, a use where it stands.
+ * a `.resolve` of the name `require`, whatever it names, a use where it stands; and each id of
+ * an AMD dependency list (references-ts.37), which needs it where the call is AMD's.
  */
 function runtimeLoads(file) {
     const found = [];
     const visit = (node) => {
-        if (isCallExpression(node)) {
+        const amd = amdLoadOf(node);
+        if (amd !== undefined) {
+            for (const { id } of amd.ids) {
+                const named = packageOfSpecifier(id.text);
+                if (named !== undefined) {
+                    found.push({ specifier: id, named, callees: [amd.callee], amd: true });
+                }
+            }
+        }
+        else if (isCallExpression(node)) {
             const [argument] = node.arguments;
             if (argument !== undefined && isLiteralText(argument)) {
                 const named = packageOfSpecifier(argument.text);
@@ -566,7 +562,7 @@ function runtimeLoads(file) {
                         receiver === undefined ? undefined : writtenName(receiver),
                     ].filter((one) => one !== undefined);
                 if (named !== undefined && (stands || callees.length > 0)) {
-                    found.push({ specifier: argument, named, callees });
+                    found.push({ specifier: argument, named, callees, amd: false });
                 }
             }
         }

package/dist/src/destructuring.js

@@ -156,8 +156,6 @@ function sourceOf(target) {
 export function destructuring(project, cap, properties = propertyTables(project.queries)) {
     const queries = project.queries;
     const tables = new Map();
-    let patternBatches = 0;
-    let patternLookups = 0;
     const tableOf = (type) => {
         const known = tables.get(type.id);
         if (known !== undefined) {
@@ -166,7 +164,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         let table = new Map();
         if ((type.flags & TypeFlags.AnyOrUnknown) === 0) {
             const read = properties.of(type);
-            patternLookups += read.asked ? 1 : 0;
             table = isAnswered(read.properties)
                 ? new Map(read.properties.map((property) => [property.name, property]))
                 : UNANSWERED;
@@ -178,7 +175,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if ((type.flags & TypeFlags.Union) === 0) {
             return type;
         }
-        patternLookups += 1;
         return queries.nonNullable(type);
     };
     /**
@@ -193,11 +189,9 @@ export function destructuring(project, cap, properties = propertyTables(project.
             if (index === undefined) {
                 return undefined;
             }
-            patternLookups += 1;
             const elements = queries.typeArguments(type);
             return isAnswered(elements) ? elements[index] : UNANSWERED;
         }
-        patternLookups += 1;
         const array = queries.isArray(type);
         if (!isAnswered(array)) {
             return UNANSWERED;
@@ -205,7 +199,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if (!array) {
             return undefined;
         }
-        patternLookups += 1;
         const elements = queries.typeArguments(type);
         return isAnswered(elements) ? elements[0] : UNANSWERED;
     };
@@ -222,14 +215,12 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if (more.length > 0) {
             return UNANSWERED;
         }
-        patternLookups += 1;
         return queries.typeOfSymbol(property);
     };
     const resultOf = (callee) => {
         if (callee === undefined || callee === UNANSWERED) {
             return callee;
         }
-        patternLookups += 1;
         const signatures = queries.signaturesOf(callee, SignatureKind.Call);
         if (!isAnswered(signatures)) {
             return UNANSWERED;
@@ -238,7 +229,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if (signature === undefined) {
             return undefined;
         }
-        patternLookups += 1;
         return queries.returnTypeOf(signature);
     };
     const iterations = new Map();
@@ -266,7 +256,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
         if (result !== undefined && result !== UNANSWERED) {
             let parts = [result];
             if (result.isUnionType()) {
-                patternLookups += 1;
                 parts = queries.constituents(result);
             }
             const values = isAnswered(parts)
@@ -296,7 +285,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
             if (property === undefined) {
                 return undefined;
             }
-            patternLookups += 1;
             return queries.typeOfSymbol(property);
         }
         return elementOf(defined, next.index);
@@ -317,7 +305,6 @@ export function destructuring(project, cap, properties = propertyTables(project.
             }
         }
         const asked = [...asking];
-        patternBatches += Math.ceil(asked.length / cap);
         const answered = new Map();
         queries.typesAt(asked, cap).forEach((type, index) => {
             const node = asked[index];
@@ -347,10 +334,5 @@ export function destructuring(project, cap, properties = propertyTables(project.
             return isAnswered(table) ? table.get(read.name) : UNANSWERED;
         });
     };
-    return {
-        resolve,
-        get cost() {
-            return { patternBatches, patternLookups };
-        },
-    };
+    return { resolve };
 }

package/dist/src/element-access.js

@@ -5,8 +5,6 @@
  * target holds, the members are read at each call, by the type of the argument it passes.
  */
 import { isArrayLiteralExpression, isArrowFunction, isBinaryExpression, isCallExpression, isElementAccessExpression, isForInStatement, isForOfStatement, isFunctionDeclaration, isFunctionExpression, isIdentifier, isNoSubstitutionTemplateLiteral, isNumericLiteral, isObjectLiteralExpression, isParenthesizedExpression, isPostfixUnaryExpression, isPrefixUnaryExpression, isPropertyAssignment, isShorthandPropertyAssignment, isSpreadAssignment, isSpreadElement, isStringLiteral, isVariableDeclaration, isVariableDeclarationList, isVariableStatement, NodeFlags, SyntaxKind, } from "@typescript/native/ast";
-import { nodeKey } from "./inventory.js";
-import { renderPosition } from "./position.js";
 import { UNANSWERED } from "./query.js";
 import { parenthesesRemoved } from "./unwrap.js";
 /** The assignment operators that read their target before they write it. */
@@ -153,174 +151,191 @@ function assigns(body, name) {
     return found;
 }
 /**
- * The references the element accesses of one project's own files make to the members their
- * index's literal type names, each made by the declaration holding the access or the call.
+ * The reads the element accesses of a side's files make of the members their index's literal
+ * type names, each made by the declaration holding the access or the call. A type the checker
+ * leaves unanswered holds what its answer could have read.
  */
-export function elementAccessReferences(project, held, chains, root, testFiles) {
-    const queries = project.queries;
-    const candidates = [];
-    const calls = new Map();
-    const names = [];
-    for (const file of project.ownSourceFiles()) {
-        const fileId = held.declarations.get(nodeKey(file, file));
-        if (fileId === undefined) {
-            continue;
-        }
-        const visit = (node, from) => {
-            const holder = held.declarations.get(nodeKey(file, node)) ?? from;
-            if (isElementAccessExpression(node) && !isLiteralIndex(node.argumentExpression)) {
-                candidates.push({ file, from: holder, access: node, use: useOf(node) });
-            }
-            if (isCallExpression(node)) {
-                calls.set(node, { file, from: holder });
-            }
-            if (isIdentifier(node)) {
-                names.push(node);
-            }
-            node.forEachChild((child) => {
-                visit(child, holder);
-            });
-        };
-        file.forEachChild((child) => {
-            visit(child, fileId);
-        });
-    }
-    if (candidates.length === 0) {
-        return [];
-    }
-    // A parameter index is decided at the calls only where the function is a callable every
-    // use of which is a call, so the symbols of the parameters and of every name are read.
-    const parameterOf = new Map();
-    const byCallable = new Map();
-    for (const candidate of candidates) {
-        const index = parenthesesRemoved(candidate.access.argumentExpression);
-        const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
-        const callable = fn === undefined ? undefined : callableOf(fn);
-        if (callable === undefined || !isIdentifier(index)) {
-            continue;
-        }
-        const at = callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === index.text);
-        if (at < 0 || assigns(callable.body, index.text)) {
-            continue;
-        }
-        parameterOf.set(candidate, { callable, at });
-        byCallable.set(callable.name, [...(byCallable.get(callable.name) ?? []), candidate]);
-    }
-    const callableNames = [...byCallable.keys()];
-    const spelled = new Set(callableNames.map((name) => name.text));
-    const sameName = names.filter((name) => spelled.has(name.text));
-    const symbols = queries.symbolsAt([...callableNames, ...sameName]);
-    const symbolOf = new Map();
-    [...callableNames, ...sameName].forEach((node, at) => {
-        const symbol = symbols[at];
-        if (symbol !== UNANSWERED && symbol !== undefined) {
-            symbolOf.set(node, symbol);
-        }
-    });
-    const callsOf = new Map();
-    for (const name of callableNames) {
-        const symbol = symbolOf.get(name);
-        let found = symbol === undefined ? undefined : [];
-        for (const use of sameName) {
-            if (found === undefined) {
-                break;
-            }
-            if (use === name || symbolOf.get(use) !== symbol) {
-                continue;
-            }
-            const parent = use.parent;
-            found =
-                isCallExpression(parent) && parent.expression === use ? [...found, parent] : undefined;
-        }
-        callsOf.set(name, found);
-    }
-    const lookups = [];
-    for (const candidate of candidates) {
-        const deferred = parameterOf.get(candidate);
-        const sites = deferred === undefined ? undefined : callsOf.get(deferred.callable.name);
-        if (deferred === undefined || sites === undefined) {
-            lookups.push({
-                file: candidate.file,
-                from: candidate.from,
-                at: candidate.access.argumentExpression,
-                object: candidate.access.expression,
-                index: candidate.access.argumentExpression,
-                use: candidate.use,
-            });
-            continue;
-        }
-        // An object that is a parameter too is read as the argument each call passes there.
-        const object = parenthesesRemoved(candidate.access.expression);
-        const objectAt = isIdentifier(object)
-            ? deferred.callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text)
-            : -1;
-        for (const call of sites) {
-            const parameter = deferred.callable.parameters[deferred.at];
-            const index = call.arguments[deferred.at] ?? parameter?.initializer;
-            const site = calls.get(call);
-            if (index === undefined || site === undefined) {
-                continue;
-            }
-            lookups.push({
-                file: site.file,
-                from: site.from,
-                at: call,
-                object: (objectAt < 0 ? undefined : call.arguments[objectAt]) ?? candidate.access.expression,
-                index,
-                use: candidate.use,
-            });
-        }
-    }
-    const nodes = lookups.flatMap((one) => [one.index, one.object]);
-    const types = queries.typesAt(nodes);
-    const typeOf = (node, at) => {
-        const type = types[at];
-        return nodes[at] === node && type !== UNANSWERED ? type : undefined;
-    };
-    // A type parameter's body serves every instantiation, so it reads what its constraint admits.
-    const keysOf = (type) => {
-        if (!type.isTypeParameter()) {
-            return type;
-        }
-        const constraint = queries.constraintOf(type);
-        return constraint === UNANSWERED || constraint === undefined ? type : constraint;
-    };
-    const partsOf = (type) => {
-        const parts = queries.constituents(type);
-        return parts === UNANSWERED ? [type] : parts;
-    };
-    const found = [];
-    lookups.forEach((lookup, at) => {
-        const indexType = typeOf(lookup.index, 2 * at);
-        const objectType = typeOf(lookup.object, 2 * at + 1);
-        const literals = indexType === undefined ? undefined : literalNames(partsOf(keysOf(indexType)));
-        if (objectType === undefined || literals === undefined) {
-            return;
-        }
-        const position = renderPosition(lookup.file, root, lookup.at.getStart());
-        for (const part of partsOf(objectType)) {
-            const properties = queries.propertiesOf(part);
-            for (const property of properties === UNANSWERED ? [] : properties) {
-                if (!literals.has(property.escapedName)) {
-                    continue;
+export const elementAccess = {
+    start() {
+        const candidates = [];
+        const calls = new Map();
+        const names = [];
+        return {
+            visit(node, { file, from }) {
+                if (isElementAccessExpression(node) && !isLiteralIndex(node.argumentExpression)) {
+                    candidates.push({ file, from, access: node, use: useOf(node) });
+                }
+                if (isCallExpression(node)) {
+                    calls.set(node, { file, from });
+                }
+                if (isIdentifier(node)) {
+                    names.push(node);
                 }
-                for (const to of chains.declarationsOf(property)) {
-                    for (const use of lookup.use === "both" ? ["read", "write"] : [lookup.use]) {
+            },
+            reads({ project, chains }) {
+                const found = [];
+                if (candidates.length === 0) {
+                    return found;
+                }
+                const queries = project.queries;
+                // A parameter index is decided at the calls only where the function is a callable every
+                // use of which is a call, so the symbols of the parameters and of every name are read.
+                const parameterOf = new Map();
+                const byCallable = new Map();
+                for (const candidate of candidates) {
+                    const index = parenthesesRemoved(candidate.access.argumentExpression);
+                    const fn = isIdentifier(index) ? enclosingFunction(candidate.access) : undefined;
+                    const callable = fn === undefined ? undefined : callableOf(fn);
+                    if (callable === undefined || !isIdentifier(index)) {
+                        continue;
+                    }
+                    const at = callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === index.text);
+                    if (at < 0 || assigns(callable.body, index.text)) {
+                        continue;
+                    }
+                    parameterOf.set(candidate, { callable, at });
+                    byCallable.set(callable.name, [...(byCallable.get(callable.name) ?? []), candidate]);
+                }
+                const callableNames = [...byCallable.keys()];
+                const spelled = new Set(callableNames.map((name) => name.text));
+                const sameName = names.filter((name) => spelled.has(name.text));
+                const asked = [...callableNames, ...sameName];
+                const symbols = queries.symbolsAt(asked);
+                const symbolOf = new Map();
+                asked.forEach((node, at) => {
+                    const symbol = symbols[at];
+                    if (symbol !== undefined) {
+                        symbolOf.set(node, symbol);
+                    }
+                });
+                const callsOf = new Map();
+                for (const name of callableNames) {
+                    const symbol = symbolOf.get(name);
+                    let sites = symbol === undefined || symbol === UNANSWERED ? undefined : [];
+                    for (const use of sameName) {
+                        if (sites === undefined) {
+                            break;
+                        }
+                        const other = symbolOf.get(use);
+                        if (use === name || (other !== symbol && other !== UNANSWERED)) {
+                            continue;
+                        }
+                        // A use the checker could not resolve may be the function's, read where it is not called.
+                        const parent = use.parent;
+                        sites =
+                            other !== UNANSWERED && isCallExpression(parent) && parent.expression === use
+                                ? [...sites, parent]
+                                : undefined;
+                    }
+                    callsOf.set(name, sites);
+                }
+                const lookups = [];
+                for (const candidate of candidates) {
+                    const deferred = parameterOf.get(candidate);
+                    const sites = deferred === undefined ? undefined : callsOf.get(deferred.callable.name);
+                    if (deferred === undefined || sites === undefined) {
+                        lookups.push({
+                            file: candidate.file,
+                            from: candidate.from,
+                            at: candidate.access.argumentExpression,
+                            object: candidate.access.expression,
+                            index: candidate.access.argumentExpression,
+                            use: candidate.use,
+                        });
+                        continue;
+                    }
+                    // An object that is a parameter too is read as the argument each call passes there.
+                    const object = parenthesesRemoved(candidate.access.expression);
+                    const objectAt = isIdentifier(object)
+                        ? deferred.callable.parameters.findIndex((parameter) => isIdentifier(parameter.name) && parameter.name.text === object.text)
+                        : -1;
+                    for (const call of sites) {
+                        const parameter = deferred.callable.parameters[deferred.at];
+                        const index = call.arguments[deferred.at] ?? parameter?.initializer;
+                        const site = calls.get(call);
+                        if (index === undefined || site === undefined) {
+                            continue;
+                        }
+                        lookups.push({
+                            file: site.file,
+                            from: site.from,
+                            at: call,
+                            object: (objectAt < 0 ? undefined : call.arguments[objectAt]) ??
+                                candidate.access.expression,
+                            index,
+                            use: candidate.use,
+                        });
+                    }
+                }
+                const nodes = lookups.flatMap((one) => [one.index, one.object]);
+                const types = queries.typesAt(nodes);
+                // A type parameter's body serves every instantiation, so it reads what its constraint admits.
+                const keysOf = (type) => {
+                    if (!type.isTypeParameter()) {
+                        return type;
+                    }
+                    const constraint = queries.constraintOf(type);
+                    return constraint === UNANSWERED || constraint === undefined ? type : constraint;
+                };
+                const partsOf = (type) => {
+                    const parts = queries.constituents(type);
+                    return parts === UNANSWERED ? [type] : parts;
+                };
+                lookups.forEach((lookup, at) => {
+                    const indexType = types[2 * at];
+                    const objectType = types[2 * at + 1];
+                    const literals = indexType === undefined || indexType === UNANSWERED
+                        ? undefined
+                        : literalNames(partsOf(keysOf(indexType)));
+                    if (indexType === UNANSWERED || objectType === UNANSWERED) {
                         found.push({
+                            kind: "held",
                             from: lookup.from,
-                            to,
-                            position,
-                            use,
-                            resolution: "keyed",
-                            test: testFiles.has(position.path),
+                            ...(literals === undefined ? {} : { names: [...literals] }),
+                            ...(objectType === UNANSWERED || objectType === undefined
+                                ? literals === undefined
+                                    ? { members: true }
+                                    : {}
+                                : { types: partsOf(objectType) }),
                         });
+                        return;
                     }
-                }
-            }
-        }
-    });
-    return found;
-}
+                    if (objectType === undefined || literals === undefined) {
+                        return;
+                    }
+                    for (const part of partsOf(objectType)) {
+                        const properties = queries.propertiesOf(part);
+                        if (properties === UNANSWERED) {
+                            found.push({ kind: "held", from: lookup.from, names: [...literals] });
+                            continue;
+                        }
+                        for (const property of properties) {
+                            if (!literals.has(property.escapedName)) {
+                                continue;
+                            }
+                            for (const to of chains.declarationsOf(property)) {
+                                for (const use of lookup.use === "both"
+                                    ? ["read", "write"]
+                                    : [lookup.use]) {
+                                    found.push({
+                                        kind: "named",
+                                        from: lookup.from,
+                                        to,
+                                        file: lookup.file,
+                                        at: lookup.at,
+                                        use,
+                                        via: "keyed",
+                                    });
+                                }
+                            }
+                        }
+                    }
+                });
+                return found;
+            },
+        };
+    },
+};
 /** The names a union of literal types spells, or none where a constituent is no string or number literal. */
 function literalNames(parts) {
     const names = new Set();

package/dist/src/entries/build-scripts.js

@@ -7,7 +7,7 @@
 import { isArrowFunction, isCallExpression, isConstructorDeclaration, isFunctionDeclaration, isFunctionExpression, isGetAccessorDeclaration, isIdentifier, isMethodDeclaration, isNewExpression, isSetAccessorDeclaration, isVariableDeclaration, } from "@typescript/native/ast";
 import { declarationOf, membersNamed, staticModule } from "./static-module.js";
 import { filesNamedBy } from "./configuration-files.js";
-import { ancestors, dirnamePath, relativePath, resolvePath } from "../paths.js";
+import { ancestors, dirnamePath, isExplicitPath, relativePath, resolvePath } from "../paths.js";
 import { bytewise } from "../text/compare.js";
 import { unwrapped } from "../unwrap.js";
 import { holdsManifest, inInstalledPackages, manifestAt } from "../fs/manifest.js";
@@ -43,7 +43,7 @@ function lastMember(object, key) {
 function pathOf(value, dir, scriptDir) {
     if (value.kind === "text") {
         const { text } = value;
-        const request = !text.startsWith("./") && !text.startsWith("../") && !text.startsWith("/");
+        const request = !isExplicitPath(text);
         return { path: resolvePath(dir, text), text, request };
     }
     if (value.kind === "directory") {

package/dist/src/entries/configuration-files.js

@@ -8,7 +8,7 @@
  */
 import { isNoSubstitutionTemplateLiteral, isStringLiteral, } from "@typescript/native/ast";
 import { relativeSpecifiers } from "./static-module.js";
-import { ancestors, dirnamePath, joinPath, relativePath, resolvePath } from "../paths.js";
+import { ancestors, dirnamePath, isAbsolutePath, joinPath, relativePath, resolvePath, startsRelativePath, } from "../paths.js";
 import { bytewise } from "../text/compare.js";
 import { isRecord } from "../json-document.js";
 import { filesIn } from "../fs/tree.js";
@@ -32,8 +32,6 @@ const MODULE_FORMS = [
 ];
 /** A JSON configuration file's name. */
 const DOCUMENT_NAME = /^(?:[\w-]+(?:\.[\w-]+)?\.config\.json|\.[\w-]+rc(?:\.json)?)$/u;
-/** The prefixes a string names a file with, relative to the file that writes it. */
-const RELATIVE_PREFIXES = ["./", "../"];
 /** The JavaScript extensions a relative specifier from a configuration file stands for TypeScript under. */
 const COUNTERPARTS = [
     [".js", [".ts", ".tsx"]],
@@ -185,9 +183,7 @@ export function configurationFiles(host, targetRoot, files, parse) {
         }
         document.manifestDirs.push(next.manifestDir);
         for (const text of document.strings) {
-            const path = RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix))
-                ? resolvePath(dirnamePath(next.path), text)
-                : undefined;
+            const path = startsRelativePath(text) ? resolvePath(dirnamePath(next.path), text) : undefined;
             if (path?.endsWith(".json") === true &&
                 isProjectPath(root, path) &&
                 host.kindOf(path) === "file") {
@@ -311,7 +307,7 @@ export function dependenciesNamed(text, declared) {
  * none.
  */
 export function filesNamedBy(files, dir, text) {
-    if (text === "" || text.startsWith("/") || /[*?[{]/u.test(text)) {
+    if (text === "" || isAbsolutePath(text) || /[*?[{]/u.test(text)) {
         return [];
     }
     const path = resolvePath(dir, text);

package/dist/src/entries/conventions.js

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