knip 5.70.2 → 5.72.0

package/dist/ConfigurationChief.d.ts

@@ -527,6 +527,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        svgr?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         syncpack?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -761,6 +766,7 @@ export declare class ConfigurationChief {
         stylelint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         svelte?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         svgo?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        svgr?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         syncpack?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         tailwind?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         taskfile?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/ConsoleStreamer.js

@@ -3,7 +3,7 @@ export class ConsoleStreamer {
     isWatch = false;
     lines = 0;
     constructor(options) {
-        this.isEnabled = options.isShowProgress && !options.isDebug;
+        this.isEnabled = options.isShowProgress;
         this.isWatch = options.isWatch;
     }
     clearLines(count) {

package/dist/DependencyDeputy.js

@@ -174,7 +174,7 @@ export class DependencyDeputy {
         const dependencyIssues = [];
         const devDependencyIssues = [];
         const optionalPeerDependencyIssues = [];
-        for (const [workspace, { manifestPath: filePath, manifestStr }] of this._manifests.entries()) {
+        for (const [workspace, { manifestPath: filePath, manifestStr }] of this._manifests) {
             const referencedDependencies = this.referencedDependencies.get(workspace);
             const hasTypesIncluded = this.getHasTypesIncluded(workspace);
             const peeker = new PackagePeeker(manifestStr);
@@ -342,7 +342,7 @@ export class DependencyDeputy {
     }
     getConfigurationHints() {
         const configurationHints = new Set();
-        for (const [workspaceName, manifest] of this._manifests.entries()) {
+        for (const [workspaceName, manifest] of this._manifests) {
             for (const identifier of manifest.unusedIgnoreDependencies) {
                 configurationHints.add({ workspaceName, identifier, type: 'ignoreDependencies' });
             }

package/dist/ProjectPrincipal.js

@@ -217,7 +217,7 @@ export class ProjectPrincipal {
         return externalRefs.length > 0;
     }
     reconcileCache(graph) {
-        for (const [filePath, file] of graph.entries()) {
+        for (const [filePath, file] of graph) {
             const fd = this.cache.getFileDescriptor(filePath);
             if (!fd?.meta)
                 continue;

package/dist/WorkspaceWorker.js

@@ -319,7 +319,7 @@ export class WorkspaceWorker {
             const configFiles = this.configFilesMap.get(wsName);
             if (configFiles) {
                 do {
-                    for (const [pluginName, dependencies] of configFiles.entries()) {
+                    for (const [pluginName, dependencies] of configFiles) {
                         configFiles.delete(pluginName);
                         if (this.enabledPlugins.includes(pluginName)) {
                             for (const input of await runPlugin(pluginName, Array.from(dependencies)))

package/dist/binaries/bash-parser.js

@@ -25,6 +25,12 @@ export const getDependenciesFromScript = (script, options) => {
             knownBinsOnly: false,
         });
     };
+    const definedFunctions = new Set();
+    const collectFunctionNames = (nodes) => {
+        for (const node of nodes)
+            if (node.type === 'Function')
+                definedFunctions.add(node.name.text);
+    };
     const getDependenciesFromNodes = (nodes) => nodes.flatMap(node => {
         switch (node.type) {
             case 'Command': {
@@ -41,6 +47,8 @@ export const getDependenciesFromScript = (script, options) => {
                     return [];
                 if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
                     return [];
+                if (definedFunctions.has(binary))
+                    return [];
                 const args = node.suffix?.map(arg => arg.text) ?? [];
                 if (['!', 'test'].includes(binary))
                     return fromArgs(args);
@@ -82,13 +90,18 @@ export const getDependenciesFromScript = (script, options) => {
                 return getDependenciesFromNodes(node.commands);
             case 'Function':
                 return getDependenciesFromNodes(node.body.commands);
+            case 'Subshell':
+                return getDependenciesFromNodes(node.list.commands);
             default:
                 return [];
         }
     });
     try {
         const parsed = parse(script);
-        return parsed?.commands ? getDependenciesFromNodes(parsed.commands) : [];
+        if (!parsed?.commands)
+            return [];
+        collectFunctionNames(parsed.commands);
+        return getDependenciesFromNodes(parsed.commands);
     }
     catch (error) {
         const msg = `Warning: failed to parse and ignoring script in ${relative(options.cwd, options.containingFilePath)} (${truncate(script, 30)})`;

package/dist/compilers/index.d.ts

@@ -479,6 +479,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    svgr?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     syncpack?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1075,6 +1080,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        svgr?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         syncpack?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/compilers/index.js

@@ -2,6 +2,7 @@ import Astro from './astro.js';
 import AstroMDX from './astro-mdx.js';
 import MDX from './mdx.js';
 import Prisma from './prisma.js';
+import SCSS from './scss.js';
 import Svelte from './svelte.js';
 import CSS from './tailwind.js';
 import Vue from './vue.js';
@@ -33,12 +34,14 @@ const compilers = new Map([
     ['.css', CSS],
     ['.mdx', MDX],
     ['.prisma', Prisma],
+    ['.sass', SCSS],
+    ['.scss', SCSS],
     ['.svelte', Svelte],
     ['.vue', Vue],
 ]);
 export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies) => {
     const hasDependency = (packageName) => dependencies.has(packageName);
-    for (const [extension, { condition, compiler }] of compilers.entries()) {
+    for (const [extension, { condition, compiler }] of compilers) {
         if (extension === '.mdx' && AstroMDX.condition(hasDependency)) {
             syncCompilers.set(extension, AstroMDX.compiler);
         }

package/dist/compilers/scss.d.ts

@@ -0,0 +1,6 @@
+import type { HasDependency } from './types.js';
+declare const _default: {
+    condition: (hasDependency: HasDependency) => boolean;
+    compiler: (text: string) => string;
+};
+export default _default;

package/dist/compilers/scss.js

@@ -0,0 +1,14 @@
+const condition = (hasDependency) => hasDependency('sass') || hasDependency('sass-embedded') || hasDependency('node-sass');
+const importMatcher = /@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
+const toRelative = (specifier) => (specifier.startsWith('.') ? specifier : `./${specifier}`);
+const compiler = (text) => {
+    const imports = [];
+    let match;
+    let index = 0;
+    while ((match = importMatcher.exec(text))) {
+        if (match[2])
+            imports.push(`import _$${index++} from '${match[1] ? match[2] : toRelative(match[2])}';`);
+    }
+    return imports.join('\n');
+};
+export default { condition, compiler };

package/dist/constants.js

@@ -89,6 +89,7 @@ export const IGNORED_GLOBAL_BINARIES = new Set([
     'rmdir',
     'rsync',
     'scp',
+    'sed',
     'seq',
     'set',
     'sh',

package/dist/graph/analyze.js

@@ -1,23 +1,24 @@
-import { getType, hasStrictlyEnumReferences, hasStrictlyNsReferences } from '../util/has-strictly-ns-references.js';
-import { getIsIdentifierReferencedHandler } from '../util/is-identifier-referenced.js';
+import { createGraphExplorer } from '../graph-explorer/explorer.js';
+import { getIssueType, hasStrictlyEnumReferences } from '../graph-explorer/utils.js';
 import { getPackageNameFromModuleSpecifier } from '../util/modules.js';
+import { toRelative } from '../util/path.js';
 import { findMatch } from '../util/regex.js';
 import { getShouldIgnoreHandler, getShouldIgnoreTagHandler } from '../util/tag.js';
-import { createAndPrintTrace, printTrace } from '../util/trace.js';
+import { formatTrace } from '../util/trace.js';
 export const analyze = async ({ analyzedFiles, counselor, chief, collector, deputy, entryPaths, factory, graph, streamer, unreferencedFiles, options, }) => {
     const shouldIgnore = getShouldIgnoreHandler(options.isProduction);
     const shouldIgnoreTags = getShouldIgnoreTagHandler(options.tags);
-    const isIdentifierReferenced = getIsIdentifierReferencedHandler(graph, entryPaths, options.isTrace);
+    const explorer = createGraphExplorer(graph, entryPaths);
     const ignoreExportsUsedInFile = chief.config.ignoreExportsUsedInFile;
-    const isExportedItemReferenced = (exportedItem) => exportedItem.refs[1] ||
-        (exportedItem.refs[0] > 0 &&
+    const isExportReferencedInFile = (exportedItem) => exportedItem.self[1] ||
+        (exportedItem.self[0] > 0 &&
             (typeof ignoreExportsUsedInFile === 'object'
                 ? exportedItem.type !== 'unknown' && !!ignoreExportsUsedInFile[exportedItem.type]
                 : ignoreExportsUsedInFile));
     const analyzeGraph = async () => {
         if (options.isReportValues || options.isReportTypes) {
             streamer.cast('Connecting the dots');
-            for (const [filePath, file] of graph.entries()) {
+            for (const [filePath, file] of graph) {
                 const exportItems = file.exports;
                 if (!exportItems || exportItems.size === 0)
                     continue;
@@ -27,17 +28,18 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     const principal = factory.getPrincipalByPackageName(workspace.pkgName);
                     const isEntry = entryPaths.has(filePath);
                     if (!isIncludeEntryExports && isEntry) {
-                        createAndPrintTrace(filePath, options, { isEntry });
                         continue;
                     }
                     const importsForExport = file.imported;
-                    for (const [identifier, exportedItem] of exportItems.entries()) {
+                    for (const [identifier, exportedItem] of exportItems) {
                         if (shouldIgnore(exportedItem.jsDocTags))
                             continue;
                         const isIgnored = shouldIgnoreTags(exportedItem.jsDocTags);
                         if (importsForExport) {
-                            const { isReferenced, reExportingEntryFile, traceNode } = isIdentifierReferenced(filePath, identifier, isIncludeEntryExports);
-                            if ((isReferenced || exportedItem.refs[1]) && isIgnored) {
+                            const [isReferenced, reExportingEntryFile] = explorer.isReferenced(filePath, identifier, {
+                                includeEntryExports: isIncludeEntryExports,
+                            });
+                            if ((isReferenced || exportedItem.self[1]) && isIgnored) {
                                 for (const tagName of exportedItem.jsDocTags) {
                                     if (options.tags[1].includes(tagName.replace(/^@/, ''))) {
                                         collector.addTagHint({ type: 'tag', filePath, identifier, tagName });
@@ -46,17 +48,14 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                             }
                             if (isIgnored)
                                 continue;
-                            if (reExportingEntryFile) {
+                            if (reExportingEntryFile && !isReferenced) {
                                 if (!isIncludeEntryExports) {
-                                    createAndPrintTrace(filePath, options, { identifier, isEntry, hasRef: isReferenced });
                                     continue;
                                 }
                                 const reExportedItem = graph.get(reExportingEntryFile)?.exports.get(identifier);
                                 if (reExportedItem && shouldIgnore(reExportedItem.jsDocTags))
                                     continue;
                             }
-                            if (traceNode)
-                                printTrace(traceNode, filePath, options, identifier);
                             if (isReferenced) {
                                 if (options.includedIssueTypes.enumMembers && exportedItem.type === 'enum') {
                                     if (!options.includedIssueTypes.nsTypes && importsForExport.refs.has(identifier))
@@ -68,11 +67,13 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                             continue;
                                         if (shouldIgnore(member.jsDocTags))
                                             continue;
-                                        if (member.refs[0] === 0) {
+                                        if (member.self[0] === 0) {
                                             const id = `${identifier}.${member.identifier}`;
-                                            const { isReferenced } = isIdentifierReferenced(filePath, id, true);
+                                            const [isMemberReferenced] = explorer.isReferenced(filePath, id, {
+                                                includeEntryExports: true,
+                                            });
                                             const isIgnored = shouldIgnoreTags(member.jsDocTags);
-                                            if (!isReferenced) {
+                                            if (!isMemberReferenced) {
                                                 if (isIgnored)
                                                     continue;
                                                 collector.addIssue({
@@ -125,17 +126,17 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                                 continue;
                             }
                         }
-                        const [hasStrictlyNsRefs, namespace] = hasStrictlyNsReferences(graph, importsForExport, identifier);
+                        const [hasStrictlyNsRefs, namespace] = explorer.hasStrictlyNsReferences(filePath, identifier);
                         const isType = ['enum', 'type', 'interface'].includes(exportedItem.type);
                         if (hasStrictlyNsRefs &&
                             ((!options.includedIssueTypes.nsTypes && isType) || !(options.includedIssueTypes.nsExports || isType)))
                             continue;
-                        if (!isExportedItemReferenced(exportedItem)) {
+                        if (!isExportReferencedInFile(exportedItem)) {
                             if (isIgnored)
                                 continue;
                             if (!options.isSkipLibs && principal?.hasExternalReferences(filePath, exportedItem))
                                 continue;
-                            const type = getType(hasStrictlyNsRefs, isType);
+                            const type = getIssueType(hasStrictlyNsRefs, isType);
                             collector.addIssue({
                                 type,
                                 filePath,
@@ -153,7 +154,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                 }
             }
         }
-        for (const [filePath, file] of graph.entries()) {
+        for (const [filePath, file] of graph) {
             const ws = chief.findWorkspaceByFilePath(filePath);
             if (ws) {
                 if (file.duplicates && options.includedIssueTypes.duplicates) {
@@ -227,5 +228,20 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
             collector.addConfigurationHint(hint);
     };
     await analyzeGraph();
+    if (options.isTrace) {
+        const nodes = explorer.buildExportsTree({ filePath: options.traceFile, identifier: options.traceExport });
+        nodes.sort((a, b) => a.filePath.localeCompare(b.filePath) || a.identifier.localeCompare(b.identifier));
+        const toRel = (path) => toRelative(path, options.cwd);
+        const isReferenced = (node) => {
+            if (explorer.isReferenced(node.filePath, node.identifier, { includeEntryExports: false })[0])
+                return true;
+            if (explorer.hasStrictlyNsReferences(node.filePath, node.identifier)[0])
+                return true;
+            const exportItem = graph.get(node.filePath)?.exports.get(node.identifier);
+            return exportItem ? isExportReferencedInFile(exportItem) : false;
+        };
+        for (const node of nodes)
+            console.log(formatTrace(node, toRel, isReferenced(node)));
+    }
     return analyzeGraph;
 };

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

@@ -0,0 +1,2 @@
+export declare const CONTINUE = "continue";
+export declare const STOP = "stop";

package/dist/graph-explorer/constants.js

@@ -0,0 +1,2 @@
+export const CONTINUE = 'continue';
+export const STOP = 'stop';

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

@@ -0,0 +1,11 @@
+import type { ModuleGraph } from '../types/module-graph.js';
+export declare const createGraphExplorer: (graph: ModuleGraph, entryPaths: Set<string>) => {
+    isReferenced: (filePath: string, identifier: string, options: {
+        includeEntryExports: boolean;
+    }) => [boolean, string | undefined];
+    hasStrictlyNsReferences: (filePath: string, identifier: string) => [boolean, (string | undefined)?];
+    buildExportsTree: (options: {
+        filePath?: string;
+        identifier?: string;
+    }) => import("./operations/build-exports-tree.js").TreeNode[];
+};

package/dist/graph-explorer/explorer.js

@@ -0,0 +1,10 @@
+import { buildExportsTree } from './operations/build-exports-tree.js';
+import { hasStrictlyNsReferences } from './operations/has-strictly-ns-references.js';
+import { isReferenced } from './operations/is-referenced.js';
+export const createGraphExplorer = (graph, entryPaths) => {
+    return {
+        isReferenced: (filePath, identifier, options) => isReferenced(graph, entryPaths, filePath, identifier, options),
+        hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, graph.get(filePath)?.imported, identifier),
+        buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
+    };
+};

package/dist/graph-explorer/operations/build-exports-tree.d.ts

@@ -0,0 +1,15 @@
+import type { Identifier, ModuleGraph } from '../../types/module-graph.js';
+import type { Via } from '../walk-down.js';
+export interface TreeNode {
+    filePath: string;
+    identifier: string;
+    originalId: string | undefined;
+    via: Via | undefined;
+    refs: string[];
+    isEntry: boolean;
+    children: TreeNode[];
+}
+export declare const buildExportsTree: (graph: ModuleGraph, entryPaths: Set<string>, options: {
+    filePath?: string;
+    identifier?: Identifier;
+}) => TreeNode[];

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

@@ -0,0 +1,96 @@
+import { CONTINUE } from '../constants.js';
+import { walkDown } from '../walk-down.js';
+export const buildExportsTree = (graph, entryPaths, options) => {
+    const traces = [];
+    const processFile = (filePath, file) => {
+        for (const exportId of options.identifier ? [options.identifier] : file.exports.keys()) {
+            if (!options.identifier || file.exports.has(exportId)) {
+                const trace = buildExportTree(graph, entryPaths, filePath, exportId);
+                if (trace)
+                    traces.push(trace);
+            }
+        }
+    };
+    if (options.filePath) {
+        const file = graph.get(options.filePath);
+        if (file)
+            processFile(options.filePath, file);
+    }
+    else {
+        for (const [filePath, file] of graph)
+            processFile(filePath, file);
+    }
+    return traces;
+};
+const buildExportTree = (graph, entryPaths, filePath, identifier) => {
+    const file = graph.get(filePath);
+    const rootNode = {
+        filePath,
+        identifier,
+        refs: filterRefs(file?.imported?.refs, identifier),
+        isEntry: entryPaths.has(filePath),
+        children: [],
+        originalId: undefined,
+        via: undefined,
+    };
+    const nodeMap = new Map();
+    nodeMap.set(`${filePath}:${identifier}`, rootNode);
+    walkDown(graph, filePath, identifier, (sourceFile, sourceId, importingFile, id, isEntry, via) => {
+        const importMaps = graph.get(importingFile)?.imports.internal.get(sourceFile);
+        const importRefs = importMaps?.refs;
+        const ns = id.split('.')[0];
+        if (via === 'importNS' && !hasRelevantRef(importRefs, id) && !isNsReExported(importMaps, ns))
+            return CONTINUE;
+        const key = `${importingFile}:${id}`;
+        const isRenamed = via.endsWith('As') && sourceId !== ns;
+        const refs = filterRefs(importRefs, id);
+        const childNode = nodeMap.get(key) ?? {
+            filePath: importingFile,
+            identifier: id,
+            originalId: isRenamed ? sourceId : undefined,
+            via,
+            refs,
+            isEntry,
+            children: [],
+        };
+        nodeMap.set(key, childNode);
+        let parentNode = nodeMap.get(`${sourceFile}:${sourceId}`);
+        if (!parentNode) {
+            for (const [k, v] of nodeMap) {
+                if (k.startsWith(`${sourceFile}:${sourceId}.`) || k === `${sourceFile}:${sourceId}`) {
+                    parentNode = v;
+                    break;
+                }
+            }
+        }
+        (parentNode ?? rootNode).children.push(childNode);
+        return CONTINUE;
+    }, entryPaths);
+    pruneReExportStarOnlyBranches(rootNode);
+    return rootNode;
+};
+const filterRefs = (refs, id) => {
+    if (!refs)
+        return [];
+    return Array.from(refs).filter(ref => id === ref || id.startsWith(`${ref}.`) || ref.startsWith(`${id}.`));
+};
+const hasRelevantRef = (refs, id) => {
+    if (!refs || refs.size === 0)
+        return false;
+    return Array.from(refs).some(ref => ref === id || ref.startsWith(`${id}.`));
+};
+const isNsReExported = (importMaps, ns) => {
+    if (!importMaps)
+        return false;
+    return importMaps.reExportedAs.has(ns) || importMaps.reExportedNs.has(ns);
+};
+const hasNonReExportStar = (node) => {
+    if (node.via && node.via !== 'reExportStar')
+        return true;
+    return node.children.some(child => hasNonReExportStar(child));
+};
+const pruneReExportStarOnlyBranches = (node) => {
+    node.children = node.children.filter(child => hasNonReExportStar(child));
+    for (const child of node.children)
+        pruneReExportStarOnlyBranches(child);
+};

package/dist/graph-explorer/operations/has-strictly-ns-references.d.ts

@@ -0,0 +1,2 @@
+import type { ImportMaps, ModuleGraph } from '../../types/module-graph.js';
+export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportMaps | undefined, identifier: string) => [boolean, string?];

package/dist/graph-explorer/operations/has-strictly-ns-references.js

@@ -0,0 +1,98 @@
+import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from '../visitors.js';
+export const hasStrictlyNsReferences = (graph, importsForExport, identifier) => {
+    if (!importsForExport)
+        return [false];
+    let foundNamespace;
+    const aliasByIdentifier = new Map();
+    const namespaceReExports = new Map();
+    const namespaceEdges = [];
+    const directById = new Map();
+    forEachPassThroughReExport(importsForExport, (id, sources) => {
+        directById.set(id, sources);
+    });
+    forEachAliasReExport(importsForExport, (id, alias, sources) => {
+        let arr = aliasByIdentifier.get(id);
+        if (!arr) {
+            arr = [];
+            aliasByIdentifier.set(id, arr);
+        }
+        arr.push({ alias, sources });
+    });
+    forEachNamespaceReExport(importsForExport, (namespace, sources) => {
+        namespaceEdges.push({ namespace, sources });
+        let arr = namespaceReExports.get(namespace);
+        if (!arr) {
+            arr = [];
+            namespaceReExports.set(namespace, arr);
+        }
+        arr.push(sources);
+    });
+    const starSources = getStarReExportSources(importsForExport);
+    const followReExports = (sources, nextId, propagateNamespace = true) => {
+        for (const filePath of sources) {
+            const file = graph.get(filePath);
+            if (!file?.imported)
+                continue;
+            const result = hasStrictlyNsReferences(graph, file.imported, nextId);
+            if (result[0] === false)
+                return result;
+            if (propagateNamespace && result[1])
+                foundNamespace = result[1];
+        }
+        return undefined;
+    };
+    for (const ns of importsForExport.importedNs.keys()) {
+        const hasNsRef = importsForExport.refs.has(ns);
+        if (!hasNsRef)
+            return [false, ns];
+        for (const ref of importsForExport.refs) {
+            if (ref.startsWith(`${ns}.`))
+                return [false, ns];
+        }
+        const nsReExports = namespaceReExports.get(ns);
+        if (nsReExports) {
+            for (const sources of nsReExports) {
+                const result = followReExports(sources, identifier, false);
+                if (result)
+                    return result;
+            }
+        }
+        const nsAliases = aliasByIdentifier.get(ns);
+        if (nsAliases) {
+            for (const { sources } of nsAliases) {
+                const result = followReExports(sources, identifier, false);
+                if (result)
+                    return result;
+            }
+        }
+        foundNamespace = ns;
+    }
+    const directSources = directById.get(identifier);
+    if (directSources) {
+        const result = followReExports(directSources, identifier, true);
+        if (result)
+            return result;
+    }
+    if (starSources) {
+        const result = followReExports(starSources, identifier, true);
+        if (result)
+            return result;
+    }
+    const [id, ...rest] = identifier.split('.');
+    const aliasEntries = aliasByIdentifier.get(id);
+    if (aliasEntries) {
+        for (const { alias, sources } of aliasEntries) {
+            const result = followReExports(sources, [alias, ...rest].join('.'), true);
+            if (result)
+                return result;
+        }
+    }
+    for (const { namespace: ns, sources } of namespaceEdges) {
+        const result = followReExports(sources, `${ns}.${identifier}`, true);
+        if (result)
+            return result;
+    }
+    if (foundNamespace)
+        return [true, foundNamespace];
+    return [false];
+};

package/dist/graph-explorer/operations/is-referenced.d.ts

@@ -0,0 +1,4 @@
+import type { Identifier, ModuleGraph } from '../../types/module-graph.js';
+export declare const isReferenced: (graph: ModuleGraph, entryPaths: Set<string>, filePath: string, id: Identifier, options: {
+    includeEntryExports: boolean;
+}) => [boolean, string | undefined];