knip 5.79.0 → 5.80.1

package/dist/ConfigurationChief.d.ts

@@ -388,6 +388,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        parcel?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         playwright?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -770,6 +775,7 @@ export declare class ConfigurationChief {
         nyc?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         oclif?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         oxlint?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
+        parcel?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         playwright?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "playwright-ct"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;
         "playwright-test"?: (boolean | import("./types/config.js").EnsuredPluginConfiguration) | undefined;

package/dist/ProjectPrincipal.js

@@ -226,7 +226,7 @@ export class ProjectPrincipal {
             const fd = this.cache.getFileDescriptor(filePath);
             if (!fd?.meta)
                 continue;
-            fd.meta.data = { ...file, internalImportCache: undefined, imported: undefined };
+            fd.meta.data = { ...file, internalImportCache: undefined, importedBy: undefined };
         }
         this.cache.reconcile();
     }

package/dist/cli.js

@@ -2,7 +2,7 @@ import { fix } from './IssueFixer.js';
 import { run } from './run.js';
 import parseArgs, { helpText } from './util/cli-arguments.js';
 import { createOptions } from './util/create-options.js';
-import { getKnownErrors, hasErrorCause, isConfigurationError, isKnownError } from './util/errors.js';
+import { getKnownErrors, hasErrorCause, isConfigurationError, isKnownError, isModuleNotFoundError, } from './util/errors.js';
 import { logError, logWarning } from './util/log.js';
 import { perfObserver } from './util/Performance.js';
 import { runPreprocessors, runReporters } from './util/reporter.js';
@@ -88,8 +88,11 @@ const main = async () => {
             const knownErrors = getKnownErrors(error);
             for (const knownError of knownErrors)
                 logError('ERROR', knownError.message);
-            if (hasErrorCause(knownErrors[0]))
+            if (hasErrorCause(knownErrors[0])) {
                 console.error('Reason:', knownErrors[0].cause.message);
+                if (isModuleNotFoundError(knownErrors[0].cause))
+                    console.log('Module load error? Visit https://knip.dev/reference/known-issues');
+            }
             if (isConfigurationError(knownErrors[0]))
                 console.log('\nRun `knip --help` or visit https://knip.dev for help');
             process.exit(2);

package/dist/compilers/index.d.ts

@@ -339,6 +339,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    parcel?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     playwright?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -970,6 +975,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        parcel?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         playwright?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/compilers/scss.d.ts

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

package/dist/compilers/scss.js

@@ -1,14 +1,20 @@
+import { existsSync } from 'node:fs';
+import { basename, dirname, join } from '../util/path.js';
 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] && !match[2].startsWith('sass:'))
-            imports.push(`import _$${index++} from '${match[1] ? match[2] : toRelative(match[2])}';`);
-    }
-    return imports.join('\n');
+const resolvePartial = (specifier, containingFile) => {
+    const rel = specifier.startsWith('.') ? specifier : `./${specifier}`;
+    const name = basename(rel);
+    if (name.startsWith('_'))
+        return rel;
+    const dir = dirname(rel);
+    const partial = name.endsWith('.scss') ? `_${name}` : `_${name}.scss`;
+    if (existsSync(join(dirname(containingFile), dir, partial)))
+        return `${dir}/_${name}`;
+    return rel;
 };
+const compiler = (text, filePath) => [...text.matchAll(importMatcher)]
+    .filter(match => match[2] && !match[2].startsWith('sass:'))
+    .map((match, i) => `import _$${i} from '${match[1] ? match[2] : resolvePartial(match[2], filePath)}';`)
+    .join('\n');
 export default { condition, compiler };

package/dist/graph/analyze.js

@@ -32,7 +32,7 @@ export const analyze = async ({ analyzedFiles, counselor, chief, collector, depu
                     if (!isIncludeEntryExports && isEntry) {
                         continue;
                     }
-                    const importsForExport = file.imported;
+                    const importsForExport = file.importedBy;
                     for (const [identifier, exportedItem] of exportItems) {
                         if (shouldIgnore(exportedItem.jsDocTags))
                             continue;

package/dist/graph/build.js

@@ -212,7 +212,7 @@ export async function build({ chief, collector, counselor, deputy, factory, isGi
                 collector.addConfigurationHint(hint);
         }
         principal.addEntryPaths(userEntryPaths);
-        if (options.isUseTscFiles) {
+        if (options.isUseTscFiles && isFile) {
             const isIgnoredWorkspace = chief.createIgnoredWorkspaceMatcher(name, dir);
             debugLogArray(name, 'Using tsconfig files as project files', tscSourcePaths);
             for (const filePath of tscSourcePaths) {

package/dist/graph-explorer/explorer.js

@@ -10,7 +10,7 @@ import { resolveDefinition } from './operations/resolve-definition.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)?.imported, identifier),
+        hasStrictlyNsReferences: (filePath, identifier) => hasStrictlyNsReferences(graph, filePath, graph.get(filePath)?.importedBy, identifier),
         buildExportsTree: (options) => buildExportsTree(graph, entryPaths, options),
         getDependencyUsage: (pattern) => getDependencyUsage(graph, pattern),
         resolveDefinition: (filePath, identifier) => resolveDefinition(graph, filePath, identifier),

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

@@ -27,7 +27,7 @@ const buildExportTree = (graph, entryPaths, filePath, identifier) => {
     const rootNode = {
         filePath,
         identifier,
-        refs: filterRefs(file?.imported?.refs, identifier),
+        refs: filterRefs(file?.importedBy?.refs, identifier),
         isEntry: entryPaths.has(filePath),
         children: [],
         originalId: undefined,
@@ -82,7 +82,7 @@ const hasRelevantRef = (refs, id) => {
 const isNsReExported = (importMaps, ns) => {
     if (!importMaps)
         return false;
-    return importMaps.reExportedAs.has(ns) || importMaps.reExportedNs.has(ns);
+    return importMaps.reExportAs.has(ns) || importMaps.reExportNs.has(ns);
 };
 const hasNonReExportStar = (node) => {
     if (node.via && node.via !== 'reExportStar')

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

@@ -100,7 +100,7 @@ const walkDown = (graph, network, filePath, identifier, visited) => {
         return;
     visited.add(filePath);
     const node = graph.get(filePath);
-    if (!node?.imported)
+    if (!node?.importedBy)
         return;
     const processConsumer = (consumerPath) => {
         network.files.add(consumerPath);
@@ -110,12 +110,12 @@ const walkDown = (graph, network, filePath, identifier, visited) => {
             network.definitions.add(consumerPath);
         walkDown(graph, network, consumerPath, identifier, visited);
     };
-    const directConsumers = node.imported.reExported.get(identifier);
+    const directConsumers = node.importedBy.reExport.get(identifier);
     if (directConsumers) {
         for (const consumerPath of directConsumers)
             processConsumer(consumerPath);
     }
-    for (const [sourceId, aliasMap] of node.imported.reExportedAs) {
+    for (const [sourceId, aliasMap] of node.importedBy.reExportAs) {
         if (sourceId === identifier) {
             for (const [_alias, consumers] of aliasMap) {
                 for (const consumerPath of consumers)
@@ -123,7 +123,7 @@ const walkDown = (graph, network, filePath, identifier, visited) => {
             }
         }
     }
-    const starConsumers = node.imported.reExported.get(IMPORT_STAR);
+    const starConsumers = node.importedBy.reExport.get(IMPORT_STAR);
     if (starConsumers) {
         for (const consumerPath of starConsumers) {
             const consumerExports = getExportedIdentifiers(graph, consumerPath);

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

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

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

@@ -1,101 +1,86 @@
-import { forEachAliasReExport, forEachNamespaceReExport, forEachPassThroughReExport, getStarReExportSources, } from '../visitors.js';
-export const hasStrictlyNsReferences = (graph, filePath, importsForExport, identifier, seenFiles = new Set()) => {
-    if (!importsForExport)
-        return [false];
-    if (seenFiles.has(filePath))
-        return [false];
-    seenFiles.add(filePath);
-    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);
+import { getAliasReExportMap, getPassThroughReExportSources, getStarReExportSources } from '../visitors.js';
+export const hasStrictlyNsReferences = (graph, filePath, importsForExport, identifier) => {
+    const seen = new Set();
+    const walkDown = (path, importMaps, id) => {
+        if (!importMaps)
+            return [false];
+        if (seen.has(path))
+            return [false];
+        seen.add(path);
+        let namespace;
+        const follow = (sources, nextId) => {
+            for (const filePath of sources) {
+                const file = graph.get(filePath);
+                if (!file?.importedBy)
+                    continue;
+                const result = walkDown(filePath, file.importedBy, nextId);
+                if (result[0] === false && result[1])
+                    return result;
+                if (result[1] && !namespace)
+                    namespace = result[1];
+            }
+            return undefined;
+        };
+        for (const ns of importMaps.importNs.keys()) {
+            if (!importMaps.refs.has(ns))
+                return [false, ns];
+            for (const ref of importMaps.refs) {
+                if (ref.startsWith(`${ns}.`))
+                    return [false, ns];
+            }
+            namespace = ns;
+            const nsAliases = getAliasReExportMap(importMaps, ns);
+            if (nsAliases) {
+                for (const [alias, sources] of nsAliases) {
+                    const result = follow(sources, alias);
+                    if (result)
+                        return result;
+                }
+            }
         }
-        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, filePath, file.imported, nextId, seenFiles);
-            if (result[0] === false)
+        const directSources = getPassThroughReExportSources(importMaps, id);
+        if (directSources) {
+            const result = follow(directSources, id);
+            if (result)
                 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 starSources = getStarReExportSources(importMaps);
+        if (starSources) {
+            const result = follow(starSources, id);
+            if (result)
+                return result;
         }
-        const nsReExports = namespaceReExports.get(ns);
-        if (nsReExports) {
-            for (const sources of nsReExports) {
-                const result = followReExports(sources, identifier, false);
+        const [_id, ...rest] = id.split('.');
+        const aliasEntries = getAliasReExportMap(importMaps, _id);
+        if (aliasEntries) {
+            for (const [alias, sources] of aliasEntries) {
+                const result = follow(sources, [alias, ...rest].join('.'));
                 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;
-            }
+        for (const [ns, sources] of importMaps.reExportNs) {
+            const result = follow(sources, `${ns}.${id}`);
+            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);
+        const importedSources = importMaps.import.get(id);
+        if (importedSources) {
+            const result = follow(importedSources, id);
             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];
+        const importAsMap = importMaps.importAs.get(id);
+        if (importAsMap) {
+            for (const [alias, sources] of importAsMap) {
+                const result = follow(sources, alias);
+                if (result)
+                    return result;
+            }
+        }
+        if (namespace)
+            return [true, namespace];
+        return [false];
+    };
+    return walkDown(filePath, importsForExport, identifier);
 };

package/dist/graph-explorer/operations/is-referenced.js

@@ -2,23 +2,23 @@ import { OPAQUE } from '../../constants.js';
 import { getAliasReExportMap, getNamespaceReExportSources, getPassThroughReExportSources, getStarReExportSources, } from '../visitors.js';
 export const isReferenced = (graph, entryPaths, filePath, id, options) => {
     const seen = new Set();
-    const check = (currentPath, currentId) => {
-        const isEntryFile = entryPaths.has(currentPath);
-        let reExportingEntryFile = isEntryFile ? currentPath : undefined;
-        if (seen.has(currentPath))
+    const walkDown = (path, id) => {
+        const isEntryFile = entryPaths.has(path);
+        let reExportingEntryFile = isEntryFile ? path : undefined;
+        if (seen.has(path))
             return [false, reExportingEntryFile];
-        seen.add(currentPath);
-        const restIds = currentId.split('.');
+        seen.add(path);
+        const restIds = id.split('.');
         const identifier = restIds.shift();
-        const file = graph.get(currentPath)?.imported;
+        const file = graph.get(path)?.importedBy;
         if (!identifier || !file) {
             return [false, reExportingEntryFile];
         }
-        const followSources = (sources, nextId) => {
+        const follow = (sources, nextId) => {
             for (const byFilePath of sources) {
                 if (seen.has(byFilePath))
                     continue;
-                const result = check(byFilePath, nextId);
+                const result = walkDown(byFilePath, nextId);
                 if (result[1])
                     reExportingEntryFile = result[1];
                 if (result[0])
@@ -26,12 +26,12 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
             }
             return false;
         };
-        if (file.imported.get(OPAQUE) ||
-            ((identifier === currentId || (identifier !== currentId && file.refs.has(currentId))) &&
-                (file.imported.has(identifier) || file.importedAs.has(identifier)))) {
+        if (file.import.get(OPAQUE) ||
+            ((identifier === id || (identifier !== id && file.refs.has(id))) &&
+                (file.import.has(identifier) || file.importAs.has(identifier)))) {
             return [true, reExportingEntryFile];
         }
-        for (const [exportId, aliases] of file.importedAs) {
+        for (const [exportId, aliases] of file.importAs) {
             if (identifier === exportId) {
                 for (const alias of aliases.keys()) {
                     const aliasedRef = [alias, ...restIds].join('.');
@@ -41,20 +41,20 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
                 }
             }
         }
-        for (const namespace of file.importedNs.keys()) {
-            if (file.refs.has(`${namespace}.${currentId}`)) {
+        for (const namespace of file.importNs.keys()) {
+            if (file.refs.has(`${namespace}.${id}`)) {
                 return [true, reExportingEntryFile];
             }
             const nsAliasMap = getAliasReExportMap(file, namespace);
             if (nsAliasMap) {
                 for (const [alias, sources] of nsAliasMap) {
-                    if (followSources(sources, `${alias}.${currentId}`))
+                    if (follow(sources, `${alias}.${id}`))
                         return [true, reExportingEntryFile];
                 }
             }
             const nsReExportSources = getNamespaceReExportSources(file, namespace);
             if (nsReExportSources) {
-                if (followSources(nsReExportSources, `${namespace}.${currentId}`))
+                if (follow(nsReExportSources, `${namespace}.${id}`))
                     return [true, reExportingEntryFile];
             }
         }
@@ -63,27 +63,26 @@ export const isReferenced = (graph, entryPaths, filePath, id, options) => {
         const aliasMap = getAliasReExportMap(file, identifier);
         if (aliasMap) {
             for (const [alias, sources] of aliasMap) {
-                const ref = [alias, ...restIds].join('.');
-                if (followSources(sources, ref))
+                if (follow(sources, [alias, ...restIds].join('.')))
                     return [true, reExportingEntryFile];
             }
         }
         const directSources = getPassThroughReExportSources(file, identifier);
         const starSources = getStarReExportSources(file);
         if (directSources) {
-            if (followSources(directSources, currentId))
+            if (follow(directSources, id))
                 return [true, reExportingEntryFile];
         }
         else if (starSources) {
-            if (followSources(starSources, currentId))
+            if (follow(starSources, id))
                 return [true, reExportingEntryFile];
         }
-        for (const [namespace, sources] of file.reExportedNs) {
-            if (followSources(sources, `${namespace}.${currentId}`)) {
+        for (const [namespace, sources] of file.reExportNs) {
+            if (follow(sources, `${namespace}.${id}`)) {
                 return [true, reExportingEntryFile];
             }
         }
         return [false, reExportingEntryFile];
     };
-    return check(filePath, id);
+    return walkDown(filePath, id);
 };

package/dist/graph-explorer/visitors.js

@@ -1,6 +1,6 @@
 import { IMPORT_STAR } from '../constants.js';
 export const forEachPassThroughReExport = (importMaps, callback) => {
-    for (const [identifier, sources] of importMaps.reExported) {
+    for (const [identifier, sources] of importMaps.reExport) {
         if (identifier === IMPORT_STAR)
             continue;
         if (callback(identifier, sources) === false)
@@ -9,7 +9,7 @@ export const forEachPassThroughReExport = (importMaps, callback) => {
     return true;
 };
 export const forEachAliasReExport = (importMaps, callback) => {
-    for (const [identifier, aliasMap] of importMaps.reExportedAs) {
+    for (const [identifier, aliasMap] of importMaps.reExportAs) {
         for (const [alias, sources] of aliasMap) {
             if (callback(identifier, alias, sources) === false)
                 return false;
@@ -18,13 +18,13 @@ export const forEachAliasReExport = (importMaps, callback) => {
     return true;
 };
 export const forEachNamespaceReExport = (importMaps, callback) => {
-    for (const [namespace, sources] of importMaps.reExportedNs) {
+    for (const [namespace, sources] of importMaps.reExportNs) {
         if (callback(namespace, sources) === false)
             return false;
     }
     return true;
 };
-export const getStarReExportSources = (importMaps) => importMaps.reExported.get(IMPORT_STAR);
-export const getPassThroughReExportSources = (importMaps, identifier) => importMaps.reExported.get(identifier);
-export const getAliasReExportMap = (importMaps, identifier) => importMaps.reExportedAs.get(identifier);
-export const getNamespaceReExportSources = (importMaps, namespace) => importMaps.reExportedNs.get(namespace);
+export const getStarReExportSources = (importMaps) => importMaps.reExport.get(IMPORT_STAR);
+export const getPassThroughReExportSources = (importMaps, identifier) => importMaps.reExport.get(identifier);
+export const getAliasReExportMap = (importMaps, identifier) => importMaps.reExportAs.get(identifier);
+export const getNamespaceReExportSources = (importMaps, namespace) => importMaps.reExportNs.get(namespace);

package/dist/graph-explorer/walk-down.js

@@ -6,14 +6,14 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
         return false;
     visited.add(key);
     const file = graph.get(filePath);
-    if (!file?.imported)
+    if (!file?.importedBy)
         return false;
     const restIds = identifier.split('.');
     const id = restIds.shift();
     if (!id)
         return false;
-    const imported = file.imported;
-    const importedByFiles = imported.imported.get(id);
+    const imported = file.importedBy;
+    const importedByFiles = imported.import.get(id);
     if (importedByFiles) {
         for (const importingFile of importedByFiles) {
             const isEntry = entryPaths.has(importingFile);
@@ -21,9 +21,9 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
                 return true;
         }
     }
-    const importedAsAliases = imported.importedAs.get(id);
-    if (importedAsAliases) {
-        for (const [alias, byFilePaths] of importedAsAliases) {
+    const importAsAliases = imported.importAs.get(id);
+    if (importAsAliases) {
+        for (const [alias, byFilePaths] of importAsAliases) {
             for (const importingFile of byFilePaths) {
                 const isEntry = entryPaths.has(importingFile);
                 if (visitor(filePath, id, importingFile, alias, isEntry, 'importAs') === STOP)
@@ -31,7 +31,7 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
             }
         }
     }
-    for (const [namespace, byFilePaths] of imported.importedNs) {
+    for (const [namespace, byFilePaths] of imported.importNs) {
         for (const importingFile of byFilePaths) {
             const isEntry = entryPaths.has(importingFile);
             if (visitor(filePath, identifier, importingFile, `${namespace}.${identifier}`, isEntry, 'importNS') === STOP) {
@@ -77,7 +77,7 @@ export const walkDown = (graph, filePath, identifier, visitor, entryPaths, visit
         }
     }
     if (!done) {
-        for (const [namespace, sources] of imported.reExportedNs) {
+        for (const [namespace, sources] of imported.reExportNs) {
             for (const reExportingFile of sources) {
                 const isEntry = entryPaths.has(reExportingFile);
                 if (visitor(filePath, identifier, reExportingFile, `${namespace}.${identifier}`, isEntry, 'reExportNS') === STOP) {

package/dist/plugins/bun/index.js

@@ -5,7 +5,7 @@ const enablers = ['bun'];
 const hasBunTest = (scripts) => scripts && Object.values(scripts).some(script => /(?<=^|\s)bun test/.test(script));
 const isEnabled = ({ manifest }) => !!hasBunTest(manifest.scripts);
 const patterns = ['**/*.{test,spec}.{js,jsx,ts,tsx}', '**/*_{test,spec}.{js,jsx,ts,tsx}'];
-const resolve = (options) => {
+const resolve = options => {
     const scripts = { ...options.rootManifest?.scripts, ...options.manifest.scripts };
     for (const script of Object.values(scripts)) {
         if (/(?<=^|\s)bun test/.test(script)) {

package/dist/plugins/index.d.ts

@@ -66,6 +66,7 @@ export declare const Plugins: {
     nyc: import("../types/config.js").Plugin;
     oclif: import("../types/config.js").Plugin;
     oxlint: import("../types/config.js").Plugin;
+    parcel: import("../types/config.js").Plugin;
     playwright: import("../types/config.js").Plugin;
     'playwright-ct': import("../types/config.js").Plugin;
     'playwright-test': import("../types/config.js").Plugin;

package/dist/plugins/index.js

@@ -65,6 +65,7 @@ import { default as nx } from './nx/index.js';
 import { default as nyc } from './nyc/index.js';
 import { default as oclif } from './oclif/index.js';
 import { default as oxlint } from './oxlint/index.js';
+import { default as parcel } from './parcel/index.js';
 import { default as playwright } from './playwright/index.js';
 import { default as playwrightCt } from './playwright-ct/index.js';
 import { default as playwrightTest } from './playwright-test/index.js';
@@ -192,6 +193,7 @@ export const Plugins = {
     nyc,
     oclif,
     oxlint,
+    parcel,
     playwright,
     'playwright-ct': playwrightCt,
     'playwright-test': playwrightTest,

package/dist/plugins/node/index.js

@@ -9,7 +9,7 @@ const patterns = [
 ];
 const hasNodeTest = (scripts) => scripts && Object.values(scripts).some(script => /(?<=^|\s)node\s(.*)--test/.test(script));
 const entry = ['server.js'];
-const resolve = (options) => {
+const resolve = options => {
     const entries = entry.map(id => toProductionEntry(id));
     if (hasNodeTest(options.manifest.scripts) || hasNodeTest(options.rootManifest?.scripts)) {
         entries.push(...patterns.map(toEntry));