@cplieger/deadset-ts 7.2.0-dev.3 → 8.0.0-dev.1

package/dist/bin/mapper-connection.js

@@ -6,6 +6,7 @@
  * https://github.com/microsoft/TypeScript/blob/f9f8d01292562242b6e7c7142e46ed7e470926f9/tsc/internal/contentmapper/hostimpl.go
  */
 import { componentModule } from "../src/component-files.js";
+import { extensionOf } from "../src/paths.js";
 /** The JSON-RPC code of a method this mapper does not serve. */
 const METHOD_NOT_FOUND = -32601;
 /** The JSON-RPC code of a request whose parameters are not the protocol's. */
@@ -42,13 +43,15 @@ function answer(message) {
         case "closeProject":
             return reply(null);
         case "transform": {
-            const content = typeof message.params === "object" && message.params !== null
-                ? message.params.content
-                : undefined;
+            const params = typeof message.params === "object" && message.params !== null ? message.params : {};
+            const { content, fileName } = params;
             if (typeof content !== "string") {
                 return fail(INVALID_PARAMS, "transform: params.content is not a string");
             }
-            const module = componentModule(content);
+            if (typeof fileName !== "string") {
+                return fail(INVALID_PARAMS, "transform: params.fileName is not a string");
+            }
+            const module = componentModule(content, extensionOf(fileName));
             return reply({ text: module.text, extension: module.extension, mappings: module.mappings });
         }
         default:

package/dist/src/analysis.js

@@ -5,6 +5,7 @@
  * makes: a view carries a project's identity in its type so a handle cannot cross to
  * another project's checker, which holds only for views the session hands out.
  */
+import { isStringLiteralLikeNode } from "@typescript/native/ast";
 import { lineOf, readComponent } from "./component-files.js";
 import { kindOf } from "./config.js";
 import { consumerLoads, consumerReferences, moduleIdentity, } from "./consumers.js";
@@ -12,7 +13,7 @@ import { configuredDeclarations, configuredRef, declarationsNamed, } from "./con
 import { decorator } from "./decorator.js";
 import { configurationNeeds, dependenciesOf, projectNeeds } from "./dependencies.js";
 import { deprecatedDeclarations } from "./deprecation.js";
-import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "./discover.js";
+import { discoverProjects, DiscoveryError, isGuess, MISSING_GLOBAL_TYPE, projectErrors, renderDiagnostic, targetRelative, withBaseUrlPaths, } from "./discover.js";
 import { conventionFailuresFor, generatedFiles, readConventions, } from "./conventions.js";
 import { readEdgeSides } from "./edges.js";
 import { enumGroup } from "./enum-group.js";
@@ -32,7 +33,7 @@ import { intraFunctionFacts, projectParts } from "./intra-function-parts.js";
 import { inventory } from "./inventory.js";
 import { packageEntries, readManifest } from "./manifest.js";
 import { liveFilesAt, matrixOf, referenceKey, sweepMatrix, } from "./matrix.js";
-import { dirnamePath, joinPath, normalizePath, relativePath, resolvePath } from "./paths.js";
+import { dirnamePath, extensionOf, joinPath, normalizePath, relativePath, resolvePath, } from "./paths.js";
 import { byPosition, isComponentFile } from "./position.js";
 import { LANGUAGE } from "./report.js";
 import { SetupError, setupLine } from "./setup-failure.js";
@@ -162,6 +163,7 @@ function readProjects(engine, host, scope, config, stage) {
             parse,
             publishedAPI: config.targetKind !== "" && kindOf(config.targetKind, LANGUAGE) === "library",
             publishedMembers: new Set((workspace?.entries ?? []).filter((entry) => entry.published).map((entry) => entry.dir)),
+            runFiles: new Set(opened.flatMap((one) => one.fileNames().map((name) => resolvePath(host.workingDirectory(), name)))),
         };
     };
     const notBuilt = [...discovered.notBuilt];
@@ -175,6 +177,7 @@ function readProjects(engine, host, scope, config, stage) {
     const failures = [];
     const unbuildable = [];
     const setupDropped = [];
+    const librariesUnfound = [];
     const consumed = new Map();
     const heldFiles = new Set();
     let outsideTests = [];
@@ -192,6 +195,7 @@ function readProjects(engine, host, scope, config, stage) {
     const joins = discovered.derived
         ? joinedTestFiles(engine, host, absoluteRoot, discovered.configFiles, testPatterns)
         : new Map();
+    const programs = withBaseUrlPaths(engine, host, [...discovered.configFiles, ...consumerOf.keys()], workspace?.programs ?? new Map());
     const session = runSession(engine, [...discovered.configFiles, ...consumerOf.keys()], (opened) => {
         const consumer = consumerOf.get(opened.configFile);
         const setup = consumer === undefined ? workspace?.unbuildable(opened.configFile) : undefined;
@@ -227,10 +231,6 @@ function readProjects(engine, host, scope, config, stage) {
                 : resolvePath(host.workingDirectory(), consumer.path),
             paths: pathsOf(engine, project.configFile),
         });
-        if (reading.failing.length > 0) {
-            failures.push(...reading.failing);
-            return undefined;
-        }
         if (consumer !== undefined && reading.missing.length > 0) {
             unbuildable.push(...reading.missing.map((one) => ({
                 setupClass: "missing-consumer",
@@ -258,11 +258,30 @@ function readProjects(engine, host, scope, config, stage) {
             }
             return undefined;
         }
+        librariesUnfound.push(...raw.unfound.map((one) => ({
+            configFile: project.configFile,
+            error: renderDiagnostic(one, (path) => relativePath(absoluteRoot, path) ?? path),
+        })));
+        const missingGlobal = raw.unfound.find(({ diagnostic }) => diagnostic.code === MISSING_GLOBAL_TYPE);
+        const skips = missingGlobal === undefined
+            ? reading.skips
+            : [
+                ...reading.skips,
+                ...project.ownSourceFiles().map((file) => ({
+                    record: {
+                        path: relativePath(absoluteRoot, file.fileName) ?? file.fileName,
+                        line: 1,
+                        message: missingGlobal.diagnostic.text,
+                    },
+                    file,
+                    unit: file,
+                })),
+            ];
         const configuration = ids.get(project.configFile) ?? project.configFile;
         const read = () => {
             const held = inventory(project, host, targetRoot);
             const found = roots(project, held, targetRoot, options);
-            const kept = skippedRoots(project, held, reading.skips);
+            const kept = skippedRoots(project, held, skips);
             const rooted = kept.length === 0
                 ? found
                 : {
@@ -278,8 +297,8 @@ function readProjects(engine, host, scope, config, stage) {
                 configFile: project.configFile,
                 held,
                 rooted,
-                typeErrorSkips: reading.skips.map((one) => one.record),
-                skipped: skippedUnits(reading.skips, absoluteRoot),
+                typeErrorSkips: skips.map((one) => one.record),
+                skipped: skippedUnits(skips, absoluteRoot),
                 referenceOnly: project
                     .ownSourceFiles()
                     .filter((file) => referenceOnly(file.fileName))
@@ -292,9 +311,7 @@ function readProjects(engine, host, scope, config, stage) {
             heldFiles.add(relativePath(absoluteRoot, file.fileName) ?? file.fileName);
         }
         return stage(project, { configuration, read });
-    }, discovered.derived ? "record" : "refuse", joins.size === 0
-        ? workspace?.programs
-        : withJoinedTests(engine, host, workspace?.programs ?? new Map(), joins), () => {
+    }, discovered.derived ? "record" : "refuse", joins.size === 0 ? programs : withJoinedTests(engine, host, programs, joins), () => {
         outsideTests = testFilesAt(host, targetRoot, sourcePaths(host, targetRoot).filter((path) => !heldFiles.has(path) && testPatterns.some((pattern) => pattern.test(path))), parse);
     }, readManifests);
     for (const configFile of session.unopened) {
@@ -326,6 +343,7 @@ function readProjects(engine, host, scope, config, stage) {
         notBuilt,
         unanswered: session.unanswered,
         componentsUnread: workspace?.componentsUnread ?? [],
+        librariesUnfound,
         conventionsApplied: conventions.applied,
         conventionUses: conventions.uses,
         memberDirs,
@@ -401,6 +419,55 @@ export const DETECTORS = new Map([
     ["framework-lifecycle", frameworkLifecycle],
     ["serialization-contract", serializationContract],
 ]);
+/** The manifest section of a package test evidence counts, and the sections that keep one out of it. */
+const DEV_SECTION = "devDependencies";
+const OTHER_SECTIONS = ["dependencies", "peerDependencies", "optionalDependencies"];
+/**
+ * The imports of a run's own files and the manifests below the target root that test
+ * evidence reads: a package is a devDependency of a file where the nearest manifest at or
+ * above it that declares the package declares it under `devDependencies` alone.
+ */
+function testEvidence(host, targetRoot, projects) {
+    const imports = new Map();
+    for (const one of projects) {
+        for (const [path, specifiers] of one.imports) {
+            imports.set(path, specifiers);
+        }
+    }
+    const manifests = new Map();
+    const manifestAt = (dir) => {
+        if (!manifests.has(dir)) {
+            let value;
+            try {
+                value = JSON.parse(host.readFile(joinPath(dir, "package.json")));
+            }
+            catch {
+                value = undefined;
+            }
+            manifests.set(dir, typeof value === "object" && value !== null && !Array.isArray(value)
+                ? value
+                : undefined);
+        }
+        return manifests.get(dir);
+    };
+    const declares = (section, name) => typeof section === "object" && section !== null && Object.hasOwn(section, name);
+    const root = resolvePath(host.workingDirectory(), targetRoot);
+    return {
+        imports,
+        devDependency: (path, name) => {
+            for (let dir = dirnamePath(joinPath(root, path));; dir = dirnamePath(dir)) {
+                const manifest = manifestAt(dir);
+                const other = OTHER_SECTIONS.some((one) => declares(manifest?.[one], name));
+                if (declares(manifest?.[DEV_SECTION], name) || other) {
+                    return !other;
+                }
+                if (normalizePath(dir) === normalizePath(root) || dirnamePath(dir) === dir) {
+                    return false;
+                }
+            }
+        },
+    };
+}
 /**
  * Reads every project of the run, its references and exemptions, and `extra`'s answer,
  * while the project's view is open, and merges the projects into one matrix in the run's
@@ -439,7 +506,13 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             testFiles: resolved.testFilePaths,
             evidence,
             componentFiles: components.map(pathOf),
-            componentWarnings: components.flatMap((file) => readComponent(file.originalText).warnings.map((warning) => ({
+            imports: new Map(project.ownSourceFiles().flatMap((file) => {
+                const path = relativePath(targetRoot, file.fileName);
+                return path === undefined
+                    ? []
+                    : [[path, file.imports.filter(isStringLiteralLikeNode).map((one) => one.text)]];
+            })),
+            componentWarnings: components.flatMap((file) => readComponent(file.originalText, extensionOf(file.fileName)).warnings.map((warning) => ({
                 path: pathOf(file),
                 line: lineOf(file.originalText, warning.offset),
                 reason: warning.reason,
@@ -458,7 +531,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
     }));
     // Test-support code is code only test code imports in any configuration of the run: a
     // configuration that holds no test file says nothing about what the tests import.
-    const support = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles));
+    const support = testSupportFiles(withOutside.flatMap((one) => one.projectRead.held.symbols), withOutside.flatMap((one) => one.references), withOutside.flatMap((one) => one.projectRead.rooted.liveUnderReachability), withOutside.flatMap((one) => one.testFiles), testEvidence(host, targetRoot, withOutside));
     const settled = settledSatisfaction(withOutside.map((one) => ({ evidence: one.evidence, held: one.projectRead.held })), [...withOutside.flatMap((one) => one.references), ...read.consumers.references]);
     const answers = withOutside.map((one, index) => {
         const { projectRead } = one;
@@ -476,8 +549,9 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
             symbols: projectRead.held.symbols,
             references: [...made, ...evidenceReferences(projectRead.held.symbols, detected.inTestFiles)],
             roots: projectRead.rooted.liveUnderReachability,
-            testFiles: one.testFiles,
+            testFiles: [...one.testFiles, ...supportFiles],
             ...(supportFiles.length === 0 ? {} : { supportFiles }),
+            ...(projectRead.held.ambient.size === 0 ? {} : { ambient: projectRead.held.ambient }),
             ...(projectRead.referenceOnly.length === 0
                 ? {}
                 : { referenceOnly: projectRead.referenceOnly }),
@@ -498,6 +572,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
                 ...exempt.filter(isUnansweredRecord).map((record) => record.id),
             ],
             typeErrorSkips: projectRead.typeErrorSkips,
+            unmappedEntries: projectRead.rooted.unmappedEntries,
             skipped: projectRead.skipped,
             componentFiles: one.componentFiles,
             componentWarnings: one.componentWarnings,
@@ -528,6 +603,7 @@ function readRun(engine, host, scope, config, mode, detectors, extra) {
         notBuilt: read.notBuilt,
         unanswered: read.unanswered,
         componentsUnread: read.componentsUnread,
+        librariesUnfound: read.librariesUnfound,
         conventionsApplied: read.conventionsApplied,
         conventionUses: read.conventionUses,
         memberDirs: read.memberDirs,
@@ -695,7 +771,8 @@ export function readEmitterRun(engine, host, scope, config, mode, detectors) {
  * The workspace members whose dependencies the run judges: `read` holds those a built
  * project holds a file below, `unbuilt` the others whose own directory, the nearest
  * manifest's above the configuration, holds a configuration the run could not build. A
- * member no configuration holds a file of is in neither.
+ * member no configuration holds a file of is in neither. A nested package no built project
+ * holds a file below joins `unbuilt` the same way.
  */
 function judgedMembers(host, targetRoot, read) {
     const root = resolvePath(host.workingDirectory(), targetRoot);
@@ -714,6 +791,14 @@ function judgedMembers(host, targetRoot, read) {
             judged.unbuilt.push(dir);
         }
     }
+    for (const dir of read.nestedDirs) {
+        const below = relativePath(root, dir);
+        if (below !== undefined &&
+            owners.has(dir) &&
+            ![...held].some((path) => path.startsWith(`${below}/`))) {
+            judged.unbuilt.push(dir);
+        }
+    }
     return judged;
 }
 /** The directory of the nearest `package.json` at or above a file, inside `root`, else `root`. */
@@ -796,7 +881,9 @@ function readAnalysis(engine, host, scope, config, provenance, mode, detectors)
             notBuilt: read.notBuilt,
             unanswered: read.unanswered,
             componentsUnread: read.componentsUnread,
+            librariesUnfound: read.librariesUnfound,
             conventionsApplied: read.conventionsApplied,
+            unmappedEntries: unmappedEverywhere(read.projects),
         },
         configured: read.projects.map((one) => one.configured),
         symbols,
@@ -833,6 +920,19 @@ function inputsOver(host, scope, config, provenance, mode, read, documents) {
         suppressions,
     };
 }
+/** The manifest entries every project of the run reads back to no file, in the first project's order. */
+function unmappedEverywhere(projects) {
+    const key = (entry) => `${entry.dir}\u0000${entry.member}`;
+    const [first, ...rest] = projects;
+    const others = rest.map((one) => new Set(one.unmappedEntries.map(key)));
+    const found = new Map();
+    for (const entry of first?.unmappedEntries ?? []) {
+        if (others.every((one) => one.has(key(entry)))) {
+            found.set(key(entry), entry);
+        }
+    }
+    return [...found.values()];
+}
 /**
  * The analysis of the run the scope and the configuration describe: the run read with its
  * suppressions bound, every family's findings with the suppressions applied and the

package/dist/src/augmentations.js

@@ -6,6 +6,7 @@
  * name, which the language or a library types values by where the target never names it,
  * as `import.meta` or `process.env`, so a use of its member is a use of it.
  */
+import { referenceKey } from "./matrix.js";
 /** Whether one declaration is a `declare global` block: a module-level namespace named `global`. */
 function isGlobalBlock(symbol, held, files) {
     return (symbol.kind === "namespace" &&
@@ -41,12 +42,24 @@ export function augmentationReferences(held, found, scripts = new Set()) {
         }
         return [];
     };
-    return found.flatMap((reference) => holders(reference.to).map((to) => ({
-        from: reference.from,
-        to,
-        position: reference.position,
-        use: "read",
-        resolution: reference.resolution,
-        test: reference.test,
-    })));
+    // Two uses at one place of declarations one block holds read the block once there.
+    const made = new Set(found.map(referenceKey));
+    const reads = new Map();
+    for (const reference of found) {
+        for (const to of holders(reference.to)) {
+            const read = {
+                from: reference.from,
+                to,
+                position: reference.position,
+                use: "read",
+                resolution: reference.resolution,
+                test: reference.test,
+            };
+            const key = referenceKey(read);
+            if (!made.has(key) && !reads.has(key)) {
+                reads.set(key, read);
+            }
+        }
+    }
+    return [...reads.values()];
 }

package/dist/src/automatic-types.js

@@ -0,0 +1,189 @@
+/**
+ * The global names and ambient modules of the `@types` packages a compiler before version 6
+ * includes automatically: every package of each type root when the configuration lists no
+ * `types`. Version 6 and later include none, so the analysis program holds none of their
+ * declarations, and a use of one resolves to nothing; each such use is a use of the package.
+ */
+import { isClassDeclaration, isEnumDeclaration, isExportAssignment, isExportDeclaration, isFunctionDeclaration, isIdentifier, isImportDeclaration, isImportEqualsDeclaration, isInterfaceDeclaration, isModuleBlock, isModuleDeclaration, isStringLiteral, isTypeAliasDeclaration, isVariableStatement, SyntaxKind, } from "@typescript/native/ast";
+import { dirnamePath, joinPath, resolvePath } from "./paths.js";
+const TYPE_ROOT = "node_modules/@types";
+const NONE = { globals: new Map(), modules: new Map() };
+/**
+ * The packages each host has read, so a run's configurations share one reading of a type
+ * root; a host reads one unchanging tree for its whole life.
+ */
+const READ = new WeakMap();
+/** Whether one file is a module: it imports, exports or assigns an export at its top level. */
+function isModuleFile(file) {
+    return file.statements.some((statement) => isImportDeclaration(statement) ||
+        isImportEqualsDeclaration(statement) ||
+        isExportDeclaration(statement) ||
+        isExportAssignment(statement) ||
+        (statement.modifiers ?? []).some((modifier) => modifier.kind === SyntaxKind.ExportKeyword));
+}
+/** The names one statement of a global scope declares, and the ambient modules it declares. */
+function declared(statement, globals, modules) {
+    if (isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+            if (isIdentifier(declaration.name)) {
+                globals.push(declaration.name.text);
+            }
+        }
+    }
+    else if (isFunctionDeclaration(statement) ||
+        isClassDeclaration(statement) ||
+        isInterfaceDeclaration(statement) ||
+        isTypeAliasDeclaration(statement) ||
+        isEnumDeclaration(statement)) {
+        if (statement.name !== undefined) {
+            globals.push(statement.name.text);
+        }
+    }
+    else if (isModuleDeclaration(statement)) {
+        if (isStringLiteral(statement.name)) {
+            modules.push(statement.name.text);
+        }
+        else {
+            globals.push(statement.name.text);
+        }
+    }
+}
+/**
+ * What one declaration file declares in the global scope: its top level where it is no
+ * module, and the body of each `declare global` block where it is one.
+ */
+function fileDeclarations(file, globals, modules) {
+    if (!isModuleFile(file)) {
+        file.statements.forEach((statement) => {
+            declared(statement, globals, modules);
+        });
+        return;
+    }
+    for (const statement of file.statements) {
+        if (isModuleDeclaration(statement) &&
+            isIdentifier(statement.name) &&
+            statement.name.text === "global" &&
+            statement.body !== undefined &&
+            isModuleBlock(statement.body)) {
+            statement.body.statements.forEach((inner) => {
+                declared(inner, globals, modules);
+            });
+        }
+    }
+}
+/** The entry declaration file of one installed type package's directory. */
+function entryOf(host, dir) {
+    try {
+        const manifest = JSON.parse(host.readFile(joinPath(dir, "package.json")));
+        const named = typeof manifest === "object" && manifest !== null
+            ? (manifest["types"] ??
+                manifest["typings"])
+            : undefined;
+        if (typeof named === "string" && named !== "") {
+            const path = resolvePath(dir, named);
+            return path.endsWith(".ts") ? path : `${path}.d.ts`;
+        }
+    }
+    catch {
+        // A package with no readable manifest is read from its index, as the compiler reads it.
+    }
+    return joinPath(dir, "index.d.ts");
+}
+/**
+ * Every global name and ambient module one installed type package declares: in its entry
+ * file and each file a `/// <reference path>` of a file read reaches, inside the package.
+ */
+function packageDeclarations(host, dir, parse) {
+    const known = READ.get(host) ?? new Map();
+    READ.set(host, known);
+    const held = known.get(dir);
+    if (held !== undefined) {
+        return held;
+    }
+    const globals = [];
+    const modules = [];
+    const seen = new Set();
+    const pending = [entryOf(host, dir)];
+    for (let path = pending.pop(); path !== undefined; path = pending.pop()) {
+        if (seen.has(path) || !path.startsWith(`${dir}/`)) {
+            continue;
+        }
+        seen.add(path);
+        let text;
+        try {
+            text = host.readFile(path);
+        }
+        catch {
+            continue;
+        }
+        const file = parse(path, text);
+        fileDeclarations(file, globals, modules);
+        for (const reference of file.referencedFiles) {
+            pending.push(resolvePath(dirnamePath(path), reference.fileName));
+        }
+    }
+    const found = { globals, modules };
+    known.set(dir, found);
+    return found;
+}
+/**
+ * What the `@types` packages a compiler before version 6 would include for one
+ * configuration declare: none where its options list `types`, else every package of each
+ * `node_modules/@types` directory at or above the configuration's directory, the nearest
+ * holding a name winning.
+ */
+export function automaticTypes(host, configFile, options, parse) {
+    if (options["types"] !== undefined) {
+        return NONE;
+    }
+    const globals = new Map();
+    const modules = new Map();
+    const add = (into, name, named) => {
+        const held = into.get(name) ?? [];
+        if (!held.includes(named)) {
+            into.set(name, [...held, named]);
+        }
+    };
+    const read = new Set();
+    for (const root of typeRoots(configFile, options)) {
+        let entries;
+        try {
+            entries = host.readDirectory(root);
+        }
+        catch {
+            entries = [];
+        }
+        for (const entry of entries) {
+            if (read.has(entry.name) || host.kindOf(joinPath(root, entry.name)) !== "directory") {
+                continue;
+            }
+            read.add(entry.name);
+            const named = `@types/${entry.name}`;
+            const found = packageDeclarations(host, joinPath(root, entry.name), parse);
+            found.globals.forEach((name) => {
+                add(globals, name, named);
+            });
+            found.modules.forEach((name) => {
+                add(modules, name, named);
+            });
+        }
+    }
+    return { globals, modules };
+}
+/**
+ * The type roots of one configuration that a package manager installs into: those its
+ * `typeRoots` lists, else each `node_modules/@types` directory at or above its directory.
+ */
+function typeRoots(configFile, options) {
+    const listed = options["typeRoots"];
+    if (Array.isArray(listed)) {
+        return listed.filter((root) => typeof root === "string" && root.endsWith(`/${TYPE_ROOT}`));
+    }
+    const roots = [];
+    for (let dir = dirnamePath(configFile);; dir = dirnamePath(dir)) {
+        roots.push(joinPath(dir, TYPE_ROOT));
+        if (dirnamePath(dir) === dir) {
+            return roots;
+        }
+    }
+}

package/dist/src/base-url.js

@@ -0,0 +1,18 @@
+import { resolvePath } from "./paths.js";
+/**
+ * The `paths` one configuration's resolved options map under the compilers before version
+ * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
+ * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
+ * options' own `paths` stand. Version 7 reads no `baseUrl`:
+ * https://github.com/microsoft/TypeScript/issues/62207
+ */
+export function baseUrlPaths(options) {
+    const baseUrl = Reflect.get(options, "baseUrl");
+    if (typeof baseUrl !== "string") {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
+        key,
+        targets.map((target) => resolvePath(baseUrl, target)),
+    ]));
+}