knip 6.35.1 → 6.37.0

package/dist/binaries/util.d.ts

@@ -1,6 +1,9 @@
 import type { Word } from 'unbash';
 import type { BinaryResolverOptions, GetInputsFromScriptsOptions, ScriptArg } from '../types/config.ts';
-import type { Input } from '../util/input.ts';
+import { type Input } from '../util/input.ts';
+export declare const toCommandBinary: (binary: string, { optionalBinaries }: GetInputsFromScriptsOptions, inputOptions?: {
+    dir?: string;
+}) => Input;
 export declare const toScript: (args: ScriptArg[]) => string;
 export declare const argsFrom: <T extends string | Word>(args: readonly T[], from: string) => T[];
 export declare const argsAfter: <T extends string | Word>(args: readonly T[], token: string) => T[];

package/dist/binaries/util.js

@@ -1,4 +1,6 @@
 import parseArgs from '../util/parse-args.js';
+import { toBinary } from '../util/input.js';
+export const toCommandBinary = (binary, { optionalBinaries }, inputOptions = {}) => toBinary(binary, optionalBinaries ? { ...inputOptions, optional: true } : inputOptions);
 const valueOf = (arg) => (typeof arg === 'string' ? arg : arg.value);
 export const toScript = (args) => {
     const parts = [];

package/dist/compilers/compilers.js

@@ -5,7 +5,7 @@ export const styleExtractor = /<style\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<
 const langAttrMatcher = /\blang\s*=\s*["']([^"']+)["']/i;
 export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
 export const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;
-export const importMatcher = /import(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
+export const importMatcher = /(?<![.\w$#])import\b(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
 export const collectImports = text => {
     if (!text.includes('import'))
         return '';

package/dist/compilers/scss.js

@@ -1,13 +1,13 @@
 import { ensureRelative, isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+import { hasUrlScheme } from '../util/url.js';
 const dependencies = ['sass', 'sass-embedded', 'node-sass'];
 const dependencyMatcher = /"(?:\\(?:\r\n|[\s\S]|$)|[^"\\\r\n\f])*(?:"|[\r\n\f]|$)|'(?:\\(?:\r\n|[\s\S]|$)|[^'\\\r\n\f])*(?:'|[\r\n\f]|$)|\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\r\n]*(?:[\r\n]|$)|@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]|url\(\s*(?:["']([^"']*)["']|([^'")\s]+))\s*\)/g;
-const urlSchemeMatcher = /^[a-z][a-z\d+.-]*:/i;
 const getUrlSpecifier = (url) => {
     if (!url ||
         url.startsWith('//') ||
         url.startsWith('/') ||
         url.startsWith('#') ||
-        urlSchemeMatcher.test(url) ||
+        hasUrlScheme(url) ||
         url.includes('$') ||
         url.includes('#{'))
         return;

package/dist/graph-explorer/cache.d.ts

@@ -1,6 +1,7 @@
 import type { ModuleGraph } from '../types/module-graph.ts';
 import type { UsageResult } from './operations/get-usage.ts';
 import type { DefinitionResult } from './operations/resolve-definition.ts';
+import type { ExportTableCache } from './operations/resolve-export-origins.ts';
 export declare const invalidateCache: (graph: ModuleGraph) => void;
 export declare const getCachedDefinition: (graph: ModuleGraph, filePath: string, identifier: string) => DefinitionResult | null | undefined;
 export declare const setCachedDefinition: (graph: ModuleGraph, filePath: string, identifier: string, result: DefinitionResult | null) => void;
@@ -8,3 +9,5 @@ export declare const getCachedUsage: (graph: ModuleGraph, filePath: string, iden
 export declare const setCachedUsage: (graph: ModuleGraph, filePath: string, identifier: string, result: UsageResult) => void;
 export declare const getCachedExportedIdentifiers: (graph: ModuleGraph, filePath: string) => Map<string, boolean> | undefined;
 export declare const setCachedExportedIdentifiers: (graph: ModuleGraph, filePath: string, result: Map<string, boolean>) => void;
+export declare const getCachedExportTable: (graph: ModuleGraph, filePath: string) => ExportTableCache | undefined;
+export declare const setCachedExportTable: (graph: ModuleGraph, filePath: string, table: ExportTableCache) => void;

package/dist/graph-explorer/cache.js

@@ -4,6 +4,7 @@ const createEmptyCache = () => ({
     usage: new Map(),
     importLookup: new Map(),
     exportedIdentifiers: new Map(),
+    exportTables: new Map(),
     generation: 0,
 });
 const getCache = (graph) => {
@@ -21,6 +22,7 @@ export const invalidateCache = (graph) => {
         cache.usage.clear();
         cache.importLookup.clear();
         cache.exportedIdentifiers.clear();
+        cache.exportTables.clear();
         cache.generation++;
     }
 };
@@ -70,3 +72,7 @@ export const setCachedExportedIdentifiers = (graph, filePath, result) => {
     const cache = getCache(graph);
     cache.exportedIdentifiers.set(filePath, result);
 };
+export const getCachedExportTable = (graph, filePath) => caches.get(graph)?.exportTables.get(filePath);
+export const setCachedExportTable = (graph, filePath, table) => {
+    getCache(graph).exportTables.set(filePath, table);
+};

package/dist/graph-explorer/explorer.d.ts

@@ -10,6 +10,7 @@ export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<s
         filePath?: string;
         identifier?: string;
     }) => import("./operations/build-exports-tree.ts").ExportsTreeNode[];
+    resolveExportOrigins: (filePath: string, identifier: string) => import("./operations/resolve-export-origins.ts").ExportOriginResolution;
     getDependencyUsage: (pattern?: string | RegExp) => Map<string, import("./operations/get-dependency-usage.ts").DependencyNodes>;
     resolveDefinition: (filePath: string, identifier: string) => import("./operations/resolve-definition.ts").DefinitionResult | null;
     getUsage: (filePath: string, identifier: string) => import("./operations/get-usage.ts").UsageResult;

package/dist/graph-explorer/explorer.js

@@ -9,12 +9,14 @@ import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references
 import { isEnumerated } from './operations/is-enumerated.js';
 import { isReferenced } from './operations/is-referenced.js';
 import { resolveDefinition } from './operations/resolve-definition.js';
+import { resolveExportOrigins } from './operations/resolve-export-origins.js';
 export const createGraphExplorer = (graph, entryPaths) => {
     return {
         isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
         hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         isEnumerated: (filePath, identifier) => isEnumerated(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
+        resolveExportOrigins: (filePath, identifier) => resolveExportOrigins(graph, filePath, identifier),
         getDependencyUsage: (pattern) => getDependencyUsage(graph, pattern),
         resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),
         getUsage: (filePath, identifier) => getUsage(graph, entryPaths, filePath, identifier),

package/dist/graph-explorer/operations/build-exports-tree.js

@@ -45,7 +45,8 @@ const buildExportTree = (graph, entryPaths, filePath, identifier) => {
         const key = `${importingFile}:${id}`;
         const isRenamed = via.endsWith('As') && sourceId !== ns;
         const refs = filterRefs(importRefs, id);
-        const childNode = nodeMap.get(key) ?? {
+        const existingNode = nodeMap.get(key);
+        const childNode = existingNode ?? {
             filePath: importingFile,
             identifier: id,
             originalId: isRenamed ? sourceId : undefined,
@@ -64,12 +65,23 @@ const buildExportTree = (graph, entryPaths, filePath, identifier) => {
                 }
             }
         }
-        (parentNode ?? rootNode).children.push(childNode);
+        const parent = parentNode ?? rootNode;
+        if (existingNode && reaches(existingNode, parent))
+            return CONTINUE;
+        parent.children.push(childNode);
         return CONTINUE;
     }, entryPaths);
     pruneReExportStarOnlyBranches(rootNode);
     return rootNode;
 };
+const reaches = (node, target) => {
+    if (node === target)
+        return true;
+    for (const child of node.children)
+        if (reaches(child, target))
+            return true;
+    return false;
+};
 const filterRefs = (refs, id) => {
     if (!refs)
         return [];

package/dist/graph-explorer/operations/get-ambiguous-star-export.d.ts

@@ -0,0 +1,8 @@
+import type { ExportOriginResolution } from './resolve-export-origins.ts';
+export interface AmbiguousStarExport {
+    origins: {
+        filePath: string;
+        identifier: string;
+    }[];
+}
+export declare const getAmbiguousStarExport: (resolution: ExportOriginResolution, identifier: string) => AmbiguousStarExport | undefined;

package/dist/graph-explorer/operations/get-ambiguous-star-export.js

@@ -0,0 +1,11 @@
+export const getAmbiguousStarExport = (resolution, identifier) => {
+    if (identifier === 'default')
+        return;
+    if (resolution.hasExplicitExport || resolution.origins.length < 2)
+        return;
+    const origins = [];
+    for (const origin of resolution.origins) {
+        origins.push({ filePath: origin.filePath, identifier: origin.identifier });
+    }
+    return { origins };
+};

package/dist/graph-explorer/operations/get-contention.js

@@ -1,142 +1,285 @@
 import { IMPORT_STAR } from '../../constants.js';
-import { getExportedIdentifiers } from '../utils.js';
-import { forEachAliasReExport, forEachPassThroughReExport, getStarReExportSources } from '../visitors.js';
+import { compareStrings } from '../../util/string.js';
+import { createExportResolver } from './resolve-export-origins.js';
+const SEVERITY = { ambiguous: 3, shadowed: 2, converged: 1 };
 export const getContention = (graph, filePath) => {
+    const result = new Map();
     const node = graph.get(filePath);
     if (!node)
-        return new Map();
-    const exportedIdentifiers = getExportedIdentifiers(graph, filePath);
-    const result = new Map();
-    for (const identifier of exportedIdentifiers.keys()) {
-        if (identifier === 'default')
-            continue;
-        const details = getContentionForIdentifier(graph, filePath, identifier);
-        if (details && (details.branching.length > 0 || details.conflict.length > 0)) {
-            result.set(identifier, details);
+        return result;
+    const nodes = new Map([[filePath, node]]);
+    const getNode = (path) => {
+        if (nodes.has(path))
+            return nodes.get(path);
+        const found = graph.get(path);
+        nodes.set(path, found);
+        return found;
+    };
+    const positions = new Map();
+    const resolver = createExportResolver(graph);
+    const findOriginExport = (origin) => {
+        if (origin.identifier === IMPORT_STAR)
+            return;
+        const originNode = getNode(origin.filePath);
+        if (!originNode)
+            return;
+        const exact = originNode.exports.get(origin.identifier);
+        if (exact?.binding === origin.identifier)
+            return exact;
+        let nearest;
+        for (const _export of originNode.exports.values()) {
+            if (_export.binding !== origin.identifier)
+                continue;
+            if (!nearest || _export.pos < nearest.pos)
+                nearest = _export;
         }
-    }
-    return result;
-};
-const getContentionForIdentifier = (graph, startFilePath, identifier) => {
-    const network = buildReExportNetwork(graph, startFilePath, identifier);
-    if (network.files.size <= 1)
-        return null;
-    const branchingFiles = [];
-    for (const file of network.files) {
-        const sourceCount = network.reExportsFrom.get(file)?.size ?? 0;
-        if (sourceCount > 1) {
-            branchingFiles.push(file);
+        return nearest;
+    };
+    const locateOrigin = (origin) => {
+        const key = `${origin.filePath}:${origin.identifier}`;
+        const cached = positions.get(key);
+        if (cached)
+            return cached;
+        const _export = findOriginExport(origin);
+        const located = _export ? { ...origin, line: _export.line, col: _export.col } : { ...origin };
+        positions.set(key, located);
+        return located;
+    };
+    const materialize = (sitePath, identifier, entry, kind) => {
+        const isShadowed = kind === 'shadowed';
+        const origins = [];
+        for (const origin of (isShadowed && entry.shadowed ? entry.shadowed : entry.origins).values())
+            origins.push(locateOrigin(origin));
+        origins.sort((a, b) => compareStrings(a.filePath, b.filePath) || compareStrings(a.identifier, b.identifier));
+        const site = {
+            kind,
+            filePath: sitePath,
+            identifier,
+            origins,
+            sources: [...(isShadowed ? (entry.shadowedSources ?? []) : entry.sources.keys())],
+        };
+        const _export = getNode(sitePath)?.exports.get(identifier);
+        if (_export) {
+            site.line = _export.line;
+            site.col = _export.col;
         }
-    }
-    const hasConflict = network.definitions.size > 1;
-    if (branchingFiles.length === 0 && !hasConflict)
-        return null;
-    return {
-        branching: branchingFiles.sort(),
-        conflict: hasConflict ? Array.from(network.definitions).sort() : [],
+        if (isShadowed) {
+            const [winner] = entry.origins.values();
+            if (winner)
+                site.winner = locateOrigin(winner);
+        }
+        return site;
     };
-};
-const buildReExportNetwork = (graph, startFilePath, identifier) => {
-    const network = {
-        files: new Set(),
-        definitions: new Set(),
-        reExportsFrom: new Map(),
+    const compareSites = (describedIdentifier) => (a, b) => {
+        const isOwnA = a.filePath === filePath && a.identifier === describedIdentifier;
+        const isOwnB = b.filePath === filePath && b.identifier === describedIdentifier;
+        if (isOwnA !== isOwnB)
+            return isOwnA ? -1 : 1;
+        return (SEVERITY[b.kind] - SEVERITY[a.kind] ||
+            compareStrings(a.filePath, b.filePath) ||
+            compareStrings(a.identifier, b.identifier));
     };
-    const upVisited = new Set();
-    const downVisited = new Set();
-    walkUp(graph, network, startFilePath, identifier, upVisited);
-    walkDown(graph, network, startFilePath, identifier, downVisited);
-    for (const file of network.files) {
-        if (!upVisited.has(file)) {
-            walkUp(graph, network, file, identifier, upVisited);
+    const sitesByFile = new Map();
+    const inspect = (sitePath, identifier) => {
+        let sites = sitesByFile.get(sitePath);
+        if (!sites)
+            sitesByFile.set(sitePath, (sites = new Map()));
+        if (identifier !== undefined && (sitePath === filePath || sites.has(identifier)))
+            return sites.get(identifier);
+        const info = resolver.getInfo(sitePath);
+        const table = identifier === undefined ? resolver.getTable(sitePath) : new Map();
+        if (identifier !== undefined) {
+            const entry = resolver.resolve(sitePath, identifier);
+            if (entry)
+                table.set(identifier, entry);
         }
-    }
-    for (const definitionFile of network.definitions) {
-        if (!downVisited.has(definitionFile))
-            walkDown(graph, network, definitionFile, identifier, downVisited);
-    }
-    return network;
-};
-const walkUp = (graph, network, filePath, identifier, visited) => {
-    if (visited.has(filePath))
-        return;
-    visited.add(filePath);
-    const node = graph.get(filePath);
-    if (!node)
-        return;
-    const exportedIds = getExportedIdentifiers(graph, filePath);
-    if (!exportedIds.has(identifier))
-        return;
-    network.files.add(filePath);
-    const exp = node.exports.get(identifier);
-    if (exp && !exp.isReExport) {
-        network.definitions.add(filePath);
-    }
-    for (const [sourcePath, importMaps] of node.imports.internal) {
-        forEachPassThroughReExport(importMaps, (id, _sources) => {
-            if (id !== identifier)
+        const entries = new Map();
+        const firstSources = new Map();
+        const addEntry = (name, resolution) => {
+            const entry = {
+                ...resolution,
+                sources: new Map(),
+                shadowed: undefined,
+                shadowedSources: undefined,
+            };
+            const first = firstSources.get(name);
+            if (first)
+                entry.sources.set(first.filePath, first);
+            entries.set(name, entry);
+            return entry;
+        };
+        for (const [name, entry] of table) {
+            if (entry.origins.size >= 2)
+                addEntry(name, entry);
+        }
+        const contribute = (name, source, origins, isStar) => {
+            const resolution = table.get(name);
+            if (!resolution || origins.size === 0)
                 return;
-            addEdge(network, sourcePath, filePath);
-            walkUp(graph, network, sourcePath, identifier, visited);
-        });
-        forEachAliasReExport(importMaps, (sourceId, alias, _sources) => {
-            if (alias !== identifier)
+            let entry = entries.get(name);
+            let contributes = false;
+            if (isStar && resolution.hasExplicitExport) {
+                for (const [key, origin] of origins) {
+                    if (resolution.origins.has(key))
+                        contributes = true;
+                    else {
+                        entry ??= addEntry(name, resolution);
+                        (entry.shadowed ??= new Map()).set(key, origin);
+                        (entry.shadowedSources ??= new Set()).add(source.filePath);
+                    }
+                }
+            }
+            else
+                contributes = true;
+            if (!contributes)
                 return;
-            addEdge(network, sourcePath, filePath);
-            walkUp(graph, network, sourcePath, sourceId, visited);
-        });
-        const starSources = getStarReExportSources(importMaps);
-        if (starSources) {
-            const sourceExports = getExportedIdentifiers(graph, sourcePath);
-            if (sourceExports.has(identifier)) {
-                addEdge(network, sourcePath, filePath);
-                walkUp(graph, network, sourcePath, identifier, visited);
+            const first = firstSources.get(name);
+            if (!entry && first && first.filePath !== source.filePath)
+                entry = addEntry(name, resolution);
+            if (entry)
+                entry.sources.set(source.filePath, source);
+            else
+                firstSources.set(name, source);
+        };
+        for (const [name, sources] of info.references) {
+            if (!table.has(name))
+                continue;
+            for (const source of sources) {
+                const entry = resolver.resolve(source.filePath, source.identifier);
+                if (entry)
+                    contribute(name, source, entry.origins, false);
             }
         }
-    }
-};
-const walkDown = (graph, network, filePath, identifier, visited) => {
-    if (visited.has(filePath))
-        return;
-    visited.add(filePath);
-    const node = graph.get(filePath);
-    if (!node?.importedBy)
-        return;
-    const processConsumer = (consumerPath) => {
-        network.files.add(consumerPath);
-        addEdge(network, filePath, consumerPath);
-        const consumerExport = graph.get(consumerPath)?.exports.get(identifier);
-        if (consumerExport && !consumerExport.isReExport)
-            network.definitions.add(consumerPath);
-        walkDown(graph, network, consumerPath, identifier, visited);
+        for (const [name, origins] of info.terminals) {
+            const entry = table.get(name);
+            if (!entry)
+                continue;
+            for (const origin of origins) {
+                if (origin.identifier === IMPORT_STAR && graph.has(origin.filePath))
+                    contribute(name, origin, entry.origins, false);
+            }
+        }
+        for (const sourcePath of info.stars) {
+            if (identifier === undefined) {
+                for (const [name, entry] of resolver.getTable(sourcePath)) {
+                    if (name !== 'default')
+                        contribute(name, { filePath: sourcePath, identifier: name }, entry.origins, true);
+                }
+            }
+            else if (identifier !== 'default') {
+                const entry = resolver.resolve(sourcePath, identifier);
+                if (entry)
+                    contribute(identifier, { filePath: sourcePath, identifier }, entry.origins, true);
+            }
+        }
+        for (const [name, entry] of entries) {
+            let kind;
+            if (entry.origins.size >= 2)
+                kind = 'ambiguous';
+            else if (entry.shadowed?.size)
+                kind = 'shadowed';
+            else if (entry.sources.size >= 2) {
+                const [origin] = entry.origins.values();
+                if (origin) {
+                    for (const [path, source] of entry.sources) {
+                        if (!resolver.reachesOrigin(source, origin, { filePath: sitePath, identifier: name }))
+                            entry.sources.delete(path);
+                    }
+                    if (entry.sources.size >= 2)
+                        kind = 'converged';
+                }
+            }
+            sites.set(name, kind ? materialize(sitePath, name, entry, kind) : undefined);
+        }
+        if (identifier !== undefined) {
+            if (!sites.has(identifier))
+                sites.set(identifier, undefined);
+            return sites.get(identifier);
+        }
     };
-    const directConsumers = node.importedBy.reExport.get(identifier);
-    if (directConsumers) {
-        for (const consumerPath of directConsumers)
-            processConsumer(consumerPath);
-    }
-    for (const [sourceId, aliasMap] of node.importedBy.reExportAs) {
-        if (sourceId === identifier) {
-            for (const [_alias, consumers] of aliasMap) {
+    inspect(filePath);
+    for (const [identifier, entry] of resolver.getTable(filePath)) {
+        if (identifier === 'default')
+            continue;
+        const sites = [];
+        const ownSite = inspect(filePath, identifier);
+        if (ownSite)
+            sites.push(ownSite);
+        else if (!node.importedBy?.reExport.size && !node.importedBy?.reExportAs.size)
+            continue;
+        const origins = entry.origins;
+        const visited = new Set([`${filePath}\0${identifier}`]);
+        const queue = [[filePath, identifier]];
+        const visitConsumer = (consumerPath, consumerId) => {
+            const key = `${consumerPath}\0${consumerId}`;
+            if (visited.has(key))
+                return;
+            visited.add(key);
+            const consumerEntry = resolver.resolve(consumerPath, consumerId);
+            if (!consumerEntry)
+                return;
+            const site = inspect(consumerPath, consumerId);
+            if (site)
+                sites.push(site);
+            if (site?.kind === 'ambiguous')
+                return;
+            for (const origin of consumerEntry.origins.keys()) {
+                if (origins.has(origin)) {
+                    queue.push([consumerPath, consumerId]);
+                    return;
+                }
+            }
+        };
+        for (let index = 0; index < queue.length; index++) {
+            const [currentPath, currentId] = queue[index];
+            const importedBy = getNode(currentPath)?.importedBy;
+            if (!importedBy)
+                continue;
+            const consumers = importedBy.reExport.get(currentId);
+            if (consumers)
                 for (const consumerPath of consumers)
-                    processConsumer(consumerPath);
+                    visitConsumer(consumerPath, currentId);
+            const aliases = importedBy.reExportAs.get(currentId);
+            if (aliases) {
+                for (const [alias, consumerPaths] of aliases) {
+                    for (const consumerPath of consumerPaths)
+                        visitConsumer(consumerPath, alias);
+                }
             }
+            const starConsumers = importedBy.reExport.get(IMPORT_STAR);
+            if (starConsumers)
+                for (const consumerPath of starConsumers)
+                    visitConsumer(consumerPath, currentId);
         }
-    }
-    const starConsumers = node.importedBy.reExport.get(IMPORT_STAR);
-    if (starConsumers) {
-        for (const consumerPath of starConsumers) {
-            const consumerExports = getExportedIdentifiers(graph, consumerPath);
-            if (consumerExports.has(identifier))
-                processConsumer(consumerPath);
+        if (sites.length === 0)
+            continue;
+        sites.sort(compareSites(identifier));
+        const branching = new Set();
+        const conflict = new Set();
+        for (const site of sites) {
+            if (site.kind === 'converged')
+                branching.add(site.filePath);
+            else {
+                let hasGraphOrigin = false;
+                for (const origin of site.origins) {
+                    if (!graph.has(origin.filePath))
+                        continue;
+                    conflict.add(origin.filePath);
+                    hasGraphOrigin = true;
+                }
+                if (site.winner && graph.has(site.winner.filePath)) {
+                    conflict.add(site.winner.filePath);
+                    hasGraphOrigin = true;
+                }
+                if (!hasGraphOrigin)
+                    conflict.add(site.filePath);
+            }
         }
+        result.set(identifier, {
+            branching: [...branching].sort(),
+            conflict: [...conflict].sort(),
+            sites,
+        });
     }
-};
-const addEdge = (network, source, consumer) => {
-    let sources = network.reExportsFrom.get(consumer);
-    if (!sources) {
-        sources = new Set();
-        network.reExportsFrom.set(consumer, sources);
-    }
-    sources.add(source);
+    return new Map([...result].sort(([a], [b]) => compareStrings(a, b)));
 };

package/dist/graph-explorer/operations/resolve-export-origins.d.ts

@@ -0,0 +1,32 @@
+import type { FileNode, ModuleGraph } from '../../types/module-graph.ts';
+export interface ExportOrigin {
+    filePath: string;
+    identifier: string;
+}
+export interface ExportOriginResolution {
+    origins: ExportOrigin[];
+    hasExplicitExport: boolean;
+}
+export interface ExportTableEntry {
+    origins: ReadonlyMap<string, ExportOrigin>;
+    hasExplicitExport: boolean;
+}
+export type ExportTable = Map<string, ExportTableEntry>;
+export interface ExportTableCache {
+    entries: ExportTable;
+    complete: boolean;
+}
+interface ExportInfo {
+    node: FileNode | undefined;
+    references: Map<string, ExportOrigin[]>;
+    terminals: Map<string, ExportOrigin[]>;
+    stars: string[];
+}
+export declare const createExportResolver: (graph: ModuleGraph) => {
+    getTable: (filePath: string) => ExportTable;
+    resolve: (filePath: string, identifier: string) => ExportTableEntry | undefined;
+    getInfo: (filePath: string) => ExportInfo;
+    reachesOrigin: (source: ExportOrigin, origin: ExportOrigin, site: ExportOrigin) => boolean;
+};
+export declare const resolveExportOrigins: (graph: ModuleGraph, filePath: string, identifier: string) => ExportOriginResolution;
+export {};