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

package/dist/src/roots/root-set.js

@@ -0,0 +1,489 @@
+/**
+ * The root set of one project: every declaration kept live without a reference, and why.
+ * Every root seeds reachability and none counts as a reference; a root of a kind that
+ * names a caller is live under reference counting too, which the sweep decides, so a
+ * published export, which only supposes a consumer, stays a reference-counting candidate.
+ */
+import { aliasChains } from "../alias-chain.js";
+import { filesNamedBy, outsideChain } from "../entries/configuration-files.js";
+import { relativeSpecifiers } from "../entries/static-module.js";
+import { nodeKey } from "../inventory.js";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "../paths.js";
+import { byPosition } from "../position.js";
+import { UNANSWERED } from "../query.js";
+import { sourceFilesOf } from "../source-files.js";
+import { typeQueryAliases } from "../type-query-alias.js";
+import { bytewise } from "../text/compare.js";
+import { holdsManifest } from "../fs/manifest.js";
+import { globExpression } from "../text/glob.js";
+import { spelledFiles } from "../text/named-files.js";
+import { extensionOf, OUTPUT_EXTENSIONS } from "../extensions.js";
+import { publishedAPI, releaseTagged } from "./published-reach.js";
+import { skippedRoots } from "../type-errors.js";
+import { mergedGlobalInterfaces } from "../augmentations.js";
+/** Whether one declaration is written below the directory of a published workspace member. */
+function inPublishedMember(held, id, root, members) {
+    const path = held.symbols.find((symbol) => symbol.id === id)?.position.path;
+    if (path === undefined || members === undefined) {
+        return false;
+    }
+    const file = resolvePath(root, path);
+    return [...members].some((dir) => file.startsWith(`${dir}/`));
+}
+/** The kind of root each role of a manifest entry makes. */
+const ENTRY_KINDS = {
+    import: "manifest-entry",
+    run: "manifest-binary",
+    script: "script",
+};
+/** The rules whose rooted files a manifest target is read back to by name. */
+const READ_BACK_RULES = new Set([
+    "configuration-file",
+    "configuration-string",
+    "html-entry",
+]);
+/** The extension a source file's name drops. */
+const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
+/** Whether no `package.json` sits between one file and the manifest's directory, which holds it. */
+function ofPackage(host, dir, file) {
+    const between = ancestors(dirnamePath(file), dir);
+    return between.length > 0 && !between.slice(0, -1).some((at) => holdsManifest(host, at));
+}
+/**
+ * The rooted files one manifest target reads back to by name: its path below the
+ * manifest's directory, past its first directory where it names one, without its output
+ * extension, is the name, and a rooted file of the manifest's own package is one whose
+ * path below the same directory, without its source extension, ends with that name at a
+ * directory boundary.
+ */
+function readBackByName(host, entry, rooted) {
+    const dir = resolvePath(host.workingDirectory(), entry.dir);
+    const below = relativePath(dir, resolvePath(host.workingDirectory(), entry.path));
+    if (below === undefined || below === "") {
+        return [];
+    }
+    const cut = below.indexOf("/");
+    const written = cut === -1 ? below : below.slice(cut + 1);
+    const name = written.slice(0, written.length - (extensionOf(written, OUTPUT_EXTENSIONS)?.length ?? 0));
+    if (name === "") {
+        return [];
+    }
+    const found = new Map();
+    for (const file of rooted) {
+        const path = relativePath(dir, file.fileName)?.replace(SOURCE_EXTENSION, "");
+        if (path !== undefined &&
+            (path === name || path.endsWith(`/${name}`)) &&
+            ofPackage(host, dir, file.fileName)) {
+            found.set(file.fileName, file);
+        }
+    }
+    return [...found.values()];
+}
+/**
+ * The program files a manifest target no program holds reaches: the target is a file
+ * read as a configuration file outside the program is, and each file of the chain it
+ * starts loads the program files its relative specifiers name, read through the emit
+ * mapping, as a command's shim loads the compiled entry it runs.
+ */
+function throughOutside(options, targetRoot, files, entry) {
+    const cwd = options.host.workingDirectory();
+    const path = resolvePath(cwd, entry.path);
+    if (options.parse === undefined ||
+        options.runFiles?.has(path) === true ||
+        options.host.kindOf(path) !== "file") {
+        return [];
+    }
+    const chain = outsideChain(options.host, targetRoot, files, options.parse, [
+        { path, manifestDir: resolvePath(cwd, entry.dir) },
+    ]);
+    const found = new Map();
+    for (const { file } of chain) {
+        for (const specifier of relativeSpecifiers(file)) {
+            for (const named of filesNamedBy(files, dirnamePath(file.fileName), specifier)) {
+                found.set(named.fileName, named);
+            }
+        }
+    }
+    return [...found.values()];
+}
+/** Whether a configured string carries either special character. */
+function isPattern(text) {
+    return text.includes("*") || text.includes("?");
+}
+/**
+ * Whether ref matches a pattern whose only special characters are `*`, which stands
+ * for any run of characters including the solidus, and `?`, which stands for exactly
+ * one character counted as a code point. A star keeps the position it last stood at,
+ * so the shortest run it can stand for is tried first.
+ */
+function matchGlob(pattern, ref) {
+    let next = 0;
+    let star = -1;
+    let resume = 0;
+    let at = 0;
+    while (at < ref.length) {
+        if (next < pattern.length && (pattern[next] === "?" || pattern[next] === ref[at])) {
+            next += 1;
+            at += 1;
+        }
+        else if (next < pattern.length && pattern[next] === "*") {
+            star = next;
+            resume = at;
+            next += 1;
+        }
+        else if (star >= 0) {
+            resume += 1;
+            next = star + 1;
+            at = resume;
+        }
+        else {
+            return false;
+        }
+    }
+    while (next < pattern.length && pattern[next] === "*") {
+        next += 1;
+    }
+    return next === pattern.length;
+}
+/**
+ * Whether one configured string names the symbol reference ref. A string carrying
+ * neither special character names only the reference it spells.
+ *
+ * Both sides are read as code points: a character outside the basic plane is two
+ * string units, and `?` stands for one character.
+ */
+export function matchRef(pattern, ref) {
+    if (!isPattern(pattern)) {
+        return pattern === ref;
+    }
+    return matchGlob(Array.from(pattern), Array.from(ref));
+}
+/**
+ * Per package, the own files its held texts name, as `spelledFiles` reads them, but those a
+ * root enters with all they export: a command can use no more of such a file than the root
+ * keeps live. A manifest's are its entries' held texts, and the target root's package has the
+ * workflow steps, git hooks and makefile recipes beside its own, with the whole text of each
+ * file they are read from.
+ */
+function scriptHolds(entries, files, entered, host, targetRoot, workflows) {
+    const rooted = new Set(entered.filter((one) => one.exports && one.names === undefined).map((one) => one.file.fileName));
+    const spelled = [...files.byName.values()]
+        .filter((file) => !rooted.has(file.fileName))
+        .map((file) => ({ file, paths: [file.fileName, ...files.writtenAs(file)] }));
+    const cwd = host.workingDirectory();
+    const commands = new Map([
+        [
+            resolvePath(cwd, targetRoot),
+            [...workflows.readings.map((reading) => reading.held), ...workflows.texts],
+        ],
+    ]);
+    for (const entry of entries) {
+        if (entry.held !== undefined) {
+            const dir = resolvePath(cwd, entry.dir);
+            commands.set(dir, [...(commands.get(dir) ?? []), entry.held]);
+        }
+    }
+    const held = [];
+    for (const [dir, texts] of commands) {
+        const named = spelledFiles(texts.join("\n"), dir, spelled);
+        if (named.length > 0) {
+            const paths = named.map((file) => relativePath(targetRoot, file.fileName) ?? file.fileName);
+            held.push({ dir, files: paths });
+        }
+    }
+    return held;
+}
+/** The target's manifest entries, then those of its other packages. */
+function packageEntries(options) {
+    return [
+        ...options.manifest.entries.map((entry) => ({
+            entry,
+            publishes: options.publishedAPI &&
+                entry.published &&
+                (options.manifest.declaresExports ? entry.member.startsWith("exports") : true),
+        })),
+        ...(options.otherPackages ?? []).map((entry) => ({
+            entry,
+            publishes: entry.published &&
+                (options.publishedAPI || options.publishedMembers?.has(entry.dir) === true),
+        })),
+    ];
+}
+/**
+ * The program files one manifest entry names, read once per entry: its path, else its
+ * output's source, else a rooted file of `readBackTo` by name, else the chain it starts
+ * outside every program.
+ */
+function entryFileReader(options, targetRoot, files, readBackTo) {
+    const read = new Map();
+    const readEntry = (entry) => {
+        const named = files.named(entry.path);
+        if (named.length > 0 || entry.role === "script") {
+            return named;
+        }
+        const cwd = options.host.workingDirectory();
+        const shipped = files.namedAsOutput(resolvePath(cwd, entry.dir), resolvePath(cwd, entry.path));
+        if (shipped.length > 0) {
+            return shipped;
+        }
+        const byName = readBackByName(options.host, entry, readBackTo);
+        return byName.length > 0 ? byName : throughOutside(options, targetRoot, files, entry);
+    };
+    return (entry) => {
+        const known = read.get(entry) ?? readEntry(entry);
+        read.set(entry, known);
+        return known;
+    };
+}
+/** The files `ts.entry_files` names, each with the pattern that names it. */
+function patternedFiles(files, patterns) {
+    const patterned = [];
+    for (const pattern of patterns) {
+        const expression = globExpression(pattern);
+        for (const [path, file] of files.byPath) {
+            if (expression.test(path)) {
+                patterned.push({ file, pattern });
+            }
+        }
+    }
+    return patterned;
+}
+/**
+ * The files every root source enters, in the order manifest entries, entry-file patterns,
+ * entry sources; the files whose exports a consumer outside the target reaches; and the
+ * entries that name no file even read back by name to another entered file.
+ */
+function enteredFiles(options, targetRoot, files, entries) {
+    const points = options.sources.entered;
+    const scripted = entries.flatMap(({ entry }) => entry.role === "script" && entry.held === undefined ? files.named(entry.path) : []);
+    const entryFiles = entryFileReader(options, targetRoot, files, [
+        ...scripted,
+        ...points.filter((point) => READ_BACK_RULES.has(point.rule)).map((point) => point.file),
+    ]);
+    const published = entries.flatMap(({ entry, publishes }) => (publishes ? entryFiles(entry) : []));
+    if (options.publishedAPI) {
+        // A library's bundle hands what its entry exports to every program that loads it.
+        published.push(...points.filter((point) => point.rule === "bundler-entry").map((point) => point.file));
+    }
+    const publishedNames = new Set(published.map((file) => file.fileName));
+    const patterned = patternedFiles(files, options.entryFiles);
+    const entered = [];
+    const unmapped = [];
+    const mapped = patterned.map(({ file }) => file);
+    for (const { entry } of entries) {
+        if (entry.held !== undefined) {
+            continue;
+        }
+        const named = entryFiles(entry);
+        if (named.length === 0 && entry.role !== "script") {
+            unmapped.push(entry);
+        }
+        mapped.push(...named);
+        for (const file of named) {
+            const kind = ENTRY_KINDS[entry.role];
+            entered.push({
+                file,
+                kind,
+                source: entry.member,
+                exports: !publishedNames.has(file.fileName),
+            });
+        }
+    }
+    for (const { file, pattern } of patterned) {
+        entered.push({ file, kind: "entry-file", source: pattern, exports: true });
+    }
+    for (const point of points) {
+        entered.push({
+            file: point.file,
+            kind: point.rule,
+            source: point.source,
+            exports: point.exports,
+            ...(point.names === undefined ? {} : { names: point.names }),
+        });
+    }
+    return {
+        entered,
+        published,
+        unmappedEntries: unmapped.filter((entry) => readBackByName(options.host, entry, mapped).length === 0),
+    };
+}
+/** Every declaration and container of a `typeof import(...)` global, with the type's text. */
+function typeQueryRoots(files, declared, add) {
+    for (const file of files.byPath.values()) {
+        for (const alias of typeQueryAliases(file)) {
+            const source = alias.type.getText().replace(/\s+/gu, " ");
+            for (const node of [alias.declaration, ...alias.containers]) {
+                const id = declared.get(nodeKey(file, node));
+                if (id !== undefined) {
+                    add(id, "type-query-alias", source);
+                }
+            }
+        }
+    }
+}
+/** The roots in the order {@link Roots.liveUnderReachability} states. */
+function orderedRoots(found, held) {
+    const sites = new Map(held.symbols.map((symbol) => [symbol.id, symbol.position]));
+    return [...found].sort((a, b) => {
+        const left = sites.get(a.id);
+        const right = sites.get(b.id);
+        const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
+        return site || bytewise(a.kind, b.kind) || bytewise(a.source, b.source);
+    });
+}
+/**
+ * The roots one project holds, and every configured string that named nothing in it. A
+ * file a manifest member, an entry-file pattern or a tool's configuration names is a root
+ * with each name of its export table and every re-export link to what it carries; in a
+ * library, the published API alone roots what a published file exports. A test file is a
+ * root by itself, and so is each declaration a type error's skip keeps and each global
+ * interface merging into one declared outside the project.
+ */
+export function rootSet(project, held, targetRoot, options) {
+    const files = sourceFilesOf(project, targetRoot);
+    const fileIds = new Map();
+    for (const file of files.byName.values()) {
+        const id = held.declarations.get(nodeKey(file, file));
+        if (id !== undefined) {
+            fileIds.set(file.fileName, id);
+        }
+    }
+    const found = new Map();
+    const add = (id, kind, source) => {
+        found.set([id, kind, source].join("\u0000"), { id, kind, source });
+    };
+    const entries = packageEntries(options);
+    const { entered, published, unmappedEntries } = enteredFiles(options, targetRoot, files, entries);
+    const heldScripts = scriptHolds(entries.map(({ entry }) => entry), files, entered, options.host, targetRoot, options.sources.workflows);
+    const heldFiles = [...new Set(heldScripts.flatMap((one) => one.files))].flatMap((path) => files.byPath.get(path) ?? []);
+    typeQueryRoots(files, held.declarations, add);
+    const { tables: exportsOf, named, answered, } = exportTables(project, held, [
+        ...entered.filter((entry) => entry.exports).map((entry) => entry.file),
+        ...published,
+        ...heldFiles,
+    ]);
+    for (const entry of entered) {
+        const id = fileIds.get(entry.file.fileName);
+        if (id === undefined) {
+            continue;
+        }
+        add(id, entry.kind, entry.source);
+        if (entry.exports) {
+            const byName = named.get(entry.file.fileName);
+            const exported = entry.names === undefined || byName === undefined
+                ? (exportsOf.get(entry.file.fileName) ?? [])
+                : entry.names.flatMap((name) => byName.get(name) ?? []);
+            for (const one of exported) {
+                add(one, entry.kind, entry.source);
+            }
+        }
+    }
+    const tagged = releaseTagged(held, files).filter((id) => options.publishedAPI || inPublishedMember(held, id, targetRoot, options.publishedMembers));
+    const api = published.length > 0 || tagged.length > 0
+        ? publishedAPI(project, published, exportsOf, held, files.byPath, tagged)
+        : { ids: [], guessed: [] };
+    for (const id of api.ids) {
+        add(id, "published-api", "");
+    }
+    const unmatched = configured(held, options.patterns, add);
+    for (const id of skippedRoots(project, held, options.skips)) {
+        add(id, "type-error", "");
+    }
+    for (const id of mergedGlobalInterfaces(project, held, files)) {
+        add(id, "global-augmentation", "");
+    }
+    return {
+        liveUnderReachability: orderedRoots(found.values(), held),
+        unmatched,
+        unanswered: [
+            ...(answered ? api.guessed : held.symbols.map((symbol) => symbol.id)),
+            // A command runs a held file and may read any export of it, so the file, which reaches its
+            // top level, and its exports are held; a declaration neither reaches is still dead.
+            ...heldFiles.flatMap((file) => {
+                const id = fileIds.get(file.fileName);
+                return [...(id === undefined ? [] : [id]), ...(exportsOf.get(file.fileName) ?? [])];
+            }),
+        ],
+        unmappedEntries,
+        heldScripts,
+    };
+}
+/**
+ * Every declaration each file's module exports, by the file's name: the declaration
+ * each name of the export table is, and every link of a re-export's chain. A name
+ * whose declaration is outside the project's own files names nothing here. One batch
+ * resolves every file to its module and one request per module reads its export
+ * table, star re-exports resolved into it. A file that is no module exports nothing.
+ * `answered` is false where the checker left a table or a link of a chain unanswered.
+ */
+function exportTables(project, held, wanted) {
+    const unique = [...new Map(wanted.map((file) => [file.fileName, file])).values()];
+    const tables = new Map();
+    const named = new Map();
+    let answered = true;
+    if (unique.length === 0) {
+        return { tables, named, answered };
+    }
+    const modules = project.symbolsAt(unique.map((file) => project.handle(file)));
+    const chains = aliasChains(project, held);
+    const topLevel = (file) => {
+        const fileId = held.declarations.get(nodeKey(file, file));
+        return held.symbols.filter((symbol) => symbol.parent === fileId).map((symbol) => symbol.id);
+    };
+    unique.forEach((file, index) => {
+        const module = modules[index];
+        if (module === undefined) {
+            tables.set(file.fileName, []);
+            return;
+        }
+        const table = module === UNANSWERED ? UNANSWERED : project.queries.exportsOfModule(module);
+        if (table === UNANSWERED) {
+            answered = false;
+            tables.set(file.fileName, topLevel(file));
+            return;
+        }
+        const ids = new Set();
+        const byName = new Map();
+        for (const exported of table) {
+            for (const target of chains.chainOf(exported)) {
+                answered &&= !target.guessed;
+                ids.add(target.id);
+                byName.set(exported.name, [...(byName.get(exported.name) ?? []), target.id]);
+            }
+        }
+        tables.set(file.fileName, [...ids]);
+        named.set(file.fileName, byName);
+    });
+    return { tables, named, answered };
+}
+/**
+ * Keeps every declaration the configuration names and returns every string that
+ * named none, in configuration order. A string the configuration lists twice is one
+ * configured root.
+ */
+function configured(held, patterns, add) {
+    const unmatched = [];
+    for (const pattern of new Set(patterns)) {
+        const kind = isPattern(pattern) ? "pattern" : "configured";
+        let matched = false;
+        for (const symbol of held.symbols) {
+            if (matchRef(pattern, symbol.ref)) {
+                add(symbol.id, kind, pattern);
+                matched = true;
+            }
+        }
+        if (!matched) {
+            unmatched.push(pattern);
+        }
+    }
+    return unmatched;
+}
+/**
+ * Every configured string that named no declaration in any project of the run, in
+ * configuration order and each once. The finding is about the configuration, so a string
+ * naming a declaration of one project has named something, and a run with no project
+ * names nothing with any of them.
+ */
+export function unmatchedEverywhere(patterns, perProject) {
+    return [...new Set(patterns)].filter((pattern) => perProject.every((project) => project.unmatched.includes(pattern)));
+}

package/dist/src/roots/unseen-loads.js

@@ -0,0 +1,208 @@
+/**
+ * The loads by a computed path: those whose files the analysis resolves, and those it
+ * cannot, whose files are roots the analysis does not see, so the configuration's roots
+ * are never complete.
+ */
+import { isBinaryExpression, isCallExpression, isIdentifier, isMetaProperty, isNoSubstitutionTemplateLiteral, isPropertyAccessExpression, isStringLiteral, isTemplateExpression, SyntaxKind, } from "@typescript/native/ast";
+import { membersNamed, textsOf, writtenValue } from "../entries/static-module.js";
+import { writtenName } from "../platform-calls.js";
+import { dirnamePath, relativePath, resolvePath } from "../paths.js";
+import { unwrapped } from "../unwrap.js";
+import { globExpression } from "../text/glob.js";
+/** The literal text a computed path starts with: a template's head, or a concatenation's first literal. */
+function leadingLiteral(node) {
+    const at = unwrapped(node);
+    if (isTemplateExpression(at)) {
+        return at.head.text;
+    }
+    if (isBinaryExpression(at) && at.operatorToken.kind === SyntaxKind.PlusToken) {
+        const left = unwrapped(at.left);
+        return isStringLiteral(left) || isNoSubstitutionTemplateLiteral(left)
+            ? left.text
+            : leadingLiteral(at.left);
+    }
+    return undefined;
+}
+/**
+ * The directory below `dir` a computed load's leading literal names, every file of which
+ * the load reaches, or none where it names a package, `dir` itself or a directory holding
+ * it, each of which would name every sibling.
+ */
+function computedLoadDirectory(dir, prefix) {
+    if (!(prefix.startsWith("./") || prefix.startsWith("../")) || !prefix.endsWith("/")) {
+        return undefined;
+    }
+    const target = resolvePath(dir, prefix);
+    return target === dir || relativePath(target, dir) !== undefined ? undefined : target;
+}
+/** Whether one node is a call that may load a module by a computed path. */
+export function isLoadCall(node) {
+    if (!isCallExpression(node)) {
+        return false;
+    }
+    return (node.expression.kind === SyntaxKind.ImportKeyword ||
+        writtenName(node.expression) !== undefined ||
+        isMetaGlob(node));
+}
+/**
+ * The files one `import.meta.glob` call loads, as Vite's `toAbsoluteGlob` reads its globs
+ * (https://vite.dev/guide/features.html#glob-import): `/` against the project root, `./`
+ * and `../` against a literal `base` (read against the root where it starts with `/`) or the
+ * calling file's directory, `**` as written, and `!` removing what it matches. Undefined
+ * where Vite reads a glob through an alias, the root is unknown, or a glob or base is computed.
+ */
+function globbed(file, first, options, others, rootOf) {
+    const patterns = textsOf(writtenValue(first), true);
+    const bases = globOption(options, "base");
+    const [written, ...more] = bases ?? [];
+    const base = written === undefined ? undefined : textsOf(written, false);
+    if (patterns === undefined ||
+        bases === undefined ||
+        more.length > 0 ||
+        (written !== undefined && base === undefined)) {
+        return undefined;
+    }
+    const dir = dirnamePath(file.fileName);
+    const root = () => rootOf(file.fileName);
+    const against = (at) => {
+        if (!at.startsWith("/")) {
+            return resolvePath(dir, at);
+        }
+        const top = root();
+        return top === undefined ? undefined : resolvePath(top, `.${at}`);
+    };
+    const from = base?.[0] === undefined ? dir : against(base[0]);
+    const keep = [];
+    const drop = [];
+    for (const written of patterns) {
+        const negated = written.startsWith("!");
+        const pattern = negated ? written.slice(1) : written;
+        let path;
+        if (pattern.startsWith("/")) {
+            path = against(pattern);
+        }
+        else if (pattern.startsWith("./") || pattern.startsWith("../")) {
+            path = from === undefined ? undefined : resolvePath(from, pattern);
+        }
+        else if (pattern.startsWith("**")) {
+            path = pattern;
+        }
+        if (path === undefined) {
+            return undefined;
+        }
+        (negated ? drop : keep).push(globExpression(path));
+    }
+    return others.filter((candidate) => keep.some((glob) => glob.test(candidate.file.fileName)) &&
+        !drop.some((glob) => glob.test(candidate.file.fileName)));
+}
+/**
+ * The computed loads among one file's load calls, each loading the `candidates` but the
+ * file itself: an `import()` or `require()` whose path starts with a relative literal naming
+ * a directory below the file's loads every candidate below it, as a bundler's context module
+ * reads it, and an `import.meta.glob` every candidate its globs match ({@link globbed}). A
+ * call of a computed path that names no such directory and no package is an unresolved load.
+ */
+export function computedLoadsOf(file, calls, candidates, rootOf) {
+    const dir = dirnamePath(file.fileName);
+    const others = candidates.filter((candidate) => candidate.file !== file);
+    return calls.flatMap(({ call, from }) => {
+        const [first, options] = call.arguments;
+        if (first === undefined) {
+            return [];
+        }
+        if (isMetaGlob(call)) {
+            const files = globbed(file, first, options, others, rootOf);
+            const asset = readsAsAsset(options);
+            return [
+                {
+                    call,
+                    from,
+                    require: undefined,
+                    files: files ?? [],
+                    resolved: files !== undefined,
+                    asset,
+                    eager: isEager(options),
+                },
+            ];
+        }
+        const argument = unwrapped(first);
+        const require = call.expression.kind === SyntaxKind.ImportKeyword ? undefined : writtenName(call.expression);
+        if (!mayNamePath(argument)) {
+            return [];
+        }
+        const prefix = leadingLiteral(argument);
+        if (namesPackage(prefix)) {
+            return [];
+        }
+        const target = prefix === undefined ? undefined : computedLoadDirectory(dir, prefix);
+        const files = target === undefined
+            ? []
+            : others.filter((candidate) => relativePath(target, candidate.file.fileName) !== undefined);
+        return [
+            { call, from, require, files, resolved: target !== undefined, asset: false, eager: false },
+        ];
+    });
+}
+/**
+ * Whether a computed argument may be a module path: anything but a string, which names its
+ * module, and a value no path is, a number, a boolean, `null`, an object, an array, a
+ * function or a class.
+ */
+function mayNamePath(argument) {
+    return !NO_PATH.has(argument.kind);
+}
+const NO_PATH = new Set([
+    SyntaxKind.StringLiteral,
+    SyntaxKind.NoSubstitutionTemplateLiteral,
+    SyntaxKind.NumericLiteral,
+    SyntaxKind.BigIntLiteral,
+    SyntaxKind.TrueKeyword,
+    SyntaxKind.FalseKeyword,
+    SyntaxKind.NullKeyword,
+    SyntaxKind.ObjectLiteralExpression,
+    SyntaxKind.ArrayLiteralExpression,
+    SyntaxKind.ArrowFunction,
+    SyntaxKind.FunctionExpression,
+    SyntaxKind.ClassExpression,
+    SyntaxKind.RegularExpressionLiteral,
+]);
+/** Whether one call is `import.meta.glob(...)`. */
+function isMetaGlob(node) {
+    if (!isPropertyAccessExpression(node.expression)) {
+        return false;
+    }
+    const { expression, name } = node.expression;
+    return (isIdentifier(name) &&
+        name.text === "glob" &&
+        isMetaProperty(expression) &&
+        expression.keywordToken === SyntaxKind.ImportKeyword);
+}
+/** The values the options of an `import.meta.glob` write for one key, undefined where a spread may hide one. */
+function globOption(options, key) {
+    return options === undefined ? [] : membersNamed(writtenValue(options), key);
+}
+/** Whether the options of an `import.meta.glob` set `eager` to `true`. */
+function isEager(options) {
+    return (globOption(options, "eager")?.some((value) => value.kind === "boolean" && value.value) === true);
+}
+/** The query parameters that make Vite load a file as its text or its URL, each written bare. */
+const ASSET_QUERY = /(?:^\?|&)(?:raw|url|inline)(?:&|$)/u;
+/**
+ * Whether the options of an `import.meta.glob` read each file as text or as a URL: a
+ * `query` string holding a bare `raw`, `url` or `inline`, or an `as` of `raw` or `url`,
+ * which Vite reads as that query (https://vite.dev/guide/features.html#glob-import). Any
+ * other query is read as loading the module, which keeps more than it may.
+ */
+function readsAsAsset(options) {
+    const texts = (key) => (globOption(options, key) ?? []).flatMap((value) => value.kind === "text" ? [value.text] : []);
+    return (texts("as").some((text) => text === "raw" || text === "url") ||
+        texts("query").some((text) => ASSET_QUERY.test(text.startsWith("?") ? text : `?${text}`)));
+}
+/** Whether a computed path's leading literal names a package, whose files are none of the target's. */
+function namesPackage(prefix) {
+    return (prefix !== undefined &&
+        prefix !== "" &&
+        !prefix.startsWith(".") &&
+        !prefix.startsWith("/") &&
+        !/^[A-Za-z][A-Za-z\d+.-]*:/u.test(prefix));
+}