knip 5.79.0 → 5.80.0

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/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/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/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/parcel/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.js';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/parcel/index.js

@@ -0,0 +1,54 @@
+import { toDeferResolve } from '../../util/input.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Parcel';
+const enablers = ['parcel', '@parcel/core'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['.parcelrc'];
+const resolveConfig = async (config) => {
+    const dependencies = [];
+    if (typeof config.extends === 'string') {
+        dependencies.push(config.extends);
+    }
+    else if (Array.isArray(config.extends)) {
+        dependencies.push(...config.extends);
+    }
+    const extractPlugins = (plugins) => {
+        if (!plugins)
+            return [];
+        return typeof plugins === 'string' ? [plugins] : plugins;
+    };
+    const extractPluginsFromMap = (pluginMap) => {
+        if (!pluginMap)
+            return [];
+        return Object.values(pluginMap).flatMap(extractPlugins);
+    };
+    if (config.resolvers)
+        dependencies.push(...extractPlugins(config.resolvers));
+    if (config.transformers)
+        dependencies.push(...extractPluginsFromMap(config.transformers));
+    if (config.bundler)
+        dependencies.push(config.bundler);
+    if (config.namers)
+        dependencies.push(...extractPlugins(config.namers));
+    if (config.runtimes)
+        dependencies.push(...extractPluginsFromMap(config.runtimes));
+    if (config.packagers)
+        dependencies.push(...extractPluginsFromMap(config.packagers));
+    if (config.optimizers)
+        dependencies.push(...extractPluginsFromMap(config.optimizers));
+    if (config.compressors)
+        dependencies.push(...extractPluginsFromMap(config.compressors));
+    if (config.reporters)
+        dependencies.push(...extractPlugins(config.reporters));
+    if (config.validators)
+        dependencies.push(...extractPluginsFromMap(config.validators));
+    return dependencies.map(id => toDeferResolve(id));
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    resolveConfig,
+};
+export default plugin;

package/dist/plugins/parcel/types.d.ts

@@ -0,0 +1,13 @@
+export type ParcelConfig = {
+    extends?: string | string[];
+    resolvers?: string | string[];
+    transformers?: Record<string, string | string[]>;
+    bundler?: string;
+    namers?: string | string[];
+    runtimes?: Record<string, string | string[]>;
+    packagers?: Record<string, string | string[]>;
+    optimizers?: Record<string, string | string[]>;
+    compressors?: Record<string, string | string[]>;
+    reporters?: string | string[];
+    validators?: Record<string, string | string[]>;
+};

package/dist/plugins/parcel/types.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/configuration.d.ts

@@ -337,6 +337,11 @@ export declare const workspaceConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    parcel: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     playwright: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -979,6 +984,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>>;
+    parcel: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>>;
     playwright: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
@@ -1610,6 +1620,11 @@ export declare const knipConfigurationSchema: z.ZodMiniObject<{
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         }, z.core.$strip>]>>;
+        parcel: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+            config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+            project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        }, z.core.$strip>]>>;
         playwright: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
             config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
             entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.d.ts

@@ -341,6 +341,11 @@ export declare const pluginsSchema: z.ZodMiniObject<{
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
     }, z.core.$strip>]>;
+    parcel: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
+        config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+        project: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
+    }, z.core.$strip>]>;
     playwright: z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>, z.ZodMiniObject<{
         config: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;
         entry: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniString<string>>]>>;

package/dist/schema/plugins.js

@@ -77,6 +77,7 @@ export const pluginsSchema = z.object({
     nyc: pluginSchema,
     oclif: pluginSchema,
     oxlint: pluginSchema,
+    parcel: pluginSchema,
     playwright: pluginSchema,
     'playwright-ct': pluginSchema,
     'playwright-test': pluginSchema,

package/dist/session/build-maps.js

@@ -128,19 +128,19 @@ export const buildInternalImports = (fileNode, explorer, importLookup) => {
         });
     };
     for (const [importedFilePath, importMaps] of fileNode.imports.internal) {
-        for (const identifier of importMaps.imported.keys()) {
+        for (const identifier of importMaps.import.keys()) {
             const _import = getImport(importedFilePath, identifier);
             addInternalImport(importedFilePath, identifier, _import.identifier, _import.line, _import.col);
         }
-        for (const [identifier, aliasMap] of importMaps.importedAs) {
+        for (const [identifier, aliasMap] of importMaps.importAs) {
             for (const [alias] of aliasMap) {
                 const _import = getImport(importedFilePath, identifier);
                 addInternalImport(importedFilePath, identifier, alias, _import.line, _import.col);
             }
         }
-        if (importMaps.importedNs.size > 0) {
+        if (importMaps.importNs.size > 0) {
             const _import = getImport(importedFilePath, IMPORT_STAR);
-            for (const namespace of importMaps.importedNs.keys()) {
+            for (const namespace of importMaps.importNs.keys()) {
                 addInternalImport(importedFilePath, namespace, namespace, _import.line, _import.col);
             }
         }

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'astro-db' | 'ava' | 'babel' | 'biome' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'knex' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'mdx' | 'mdxlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'oxlint' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'react-cosmos' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'travis' | 'ts-node' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
-export declare const pluginNames: readonly ["angular", "astro", "astro-db", "ava", "babel", "biome", "bumpp", "bun", "c8", "capacitor", "changelogen", "changelogithub", "changesets", "commitizen", "commitlint", "convex", "create-typescript-app", "cspell", "cucumber", "cypress", "danger", "dependency-cruiser", "docusaurus", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-action", "github-actions", "glob", "graphql-codegen", "hardhat", "husky", "i18next-parser", "jest", "karma", "knex", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "mdx", "mdxlint", "metro", "mocha", "moonrepo", "msw", "nano-staged", "nest", "netlify", "next", "next-intl", "next-mdx", "node", "node-modules-inspector", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "oxlint", "playwright", "playwright-ct", "playwright-test", "plop", "pnpm", "postcss", "preconstruct", "prettier", "prisma", "react-cosmos", "react-router", "relay", "release-it", "remark", "remix", "rollup", "rsbuild", "rslib", "rspack", "rstest", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "sst", "starlight", "storybook", "stryker", "stylelint", "svelte", "svgo", "svgr", "swc", "syncpack", "tailwind", "tanstack-router", "taskfile", "travis", "ts-node", "tsdown", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitepress", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];
+export type PluginName = 'angular' | 'astro' | 'astro-db' | 'ava' | 'babel' | 'biome' | 'bumpp' | 'bun' | 'c8' | 'capacitor' | 'changelogen' | 'changelogithub' | 'changesets' | 'commitizen' | 'commitlint' | 'convex' | 'create-typescript-app' | 'cspell' | 'cucumber' | 'cypress' | 'danger' | 'dependency-cruiser' | 'docusaurus' | 'dotenv' | 'drizzle' | 'eleventy' | 'eslint' | 'expo' | 'gatsby' | 'github-action' | 'github-actions' | 'glob' | 'graphql-codegen' | 'hardhat' | 'husky' | 'i18next-parser' | 'jest' | 'karma' | 'knex' | 'ladle' | 'lefthook' | 'lint-staged' | 'linthtml' | 'lockfile-lint' | 'lost-pixel' | 'markdownlint' | 'mdx' | 'mdxlint' | 'metro' | 'mocha' | 'moonrepo' | 'msw' | 'nano-staged' | 'nest' | 'netlify' | 'next' | 'next-intl' | 'next-mdx' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'oxlint' | 'parcel' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'react-cosmos' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'semantic-release' | 'sentry' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'svgo' | 'svgr' | 'swc' | 'syncpack' | 'tailwind' | 'tanstack-router' | 'taskfile' | 'travis' | 'ts-node' | 'tsdown' | 'tsup' | 'tsx' | 'typedoc' | 'typescript' | 'unbuild' | 'unocss' | 'vercel-og' | 'vike' | 'vite' | 'vitepress' | 'vitest' | 'vue' | 'webdriver-io' | 'webpack' | 'wireit' | 'wrangler' | 'xo' | 'yarn' | 'yorkie';
+export declare const pluginNames: readonly ["angular", "astro", "astro-db", "ava", "babel", "biome", "bumpp", "bun", "c8", "capacitor", "changelogen", "changelogithub", "changesets", "commitizen", "commitlint", "convex", "create-typescript-app", "cspell", "cucumber", "cypress", "danger", "dependency-cruiser", "docusaurus", "dotenv", "drizzle", "eleventy", "eslint", "expo", "gatsby", "github-action", "github-actions", "glob", "graphql-codegen", "hardhat", "husky", "i18next-parser", "jest", "karma", "knex", "ladle", "lefthook", "lint-staged", "linthtml", "lockfile-lint", "lost-pixel", "markdownlint", "mdx", "mdxlint", "metro", "mocha", "moonrepo", "msw", "nano-staged", "nest", "netlify", "next", "next-intl", "next-mdx", "node", "node-modules-inspector", "nodemon", "npm-package-json-lint", "nuxt", "nx", "nyc", "oclif", "oxlint", "parcel", "playwright", "playwright-ct", "playwright-test", "plop", "pnpm", "postcss", "preconstruct", "prettier", "prisma", "react-cosmos", "react-router", "relay", "release-it", "remark", "remix", "rollup", "rsbuild", "rslib", "rspack", "rstest", "semantic-release", "sentry", "simple-git-hooks", "size-limit", "sst", "starlight", "storybook", "stryker", "stylelint", "svelte", "svgo", "svgr", "swc", "syncpack", "tailwind", "tanstack-router", "taskfile", "travis", "ts-node", "tsdown", "tsup", "tsx", "typedoc", "typescript", "unbuild", "unocss", "vercel-og", "vike", "vite", "vitepress", "vitest", "vue", "webdriver-io", "webpack", "wireit", "wrangler", "xo", "yarn", "yorkie"];

package/dist/types/PluginNames.js

@@ -66,6 +66,7 @@ export const pluginNames = [
     'nyc',
     'oclif',
     'oxlint',
+    'parcel',
     'playwright',
     'playwright-ct',
     'playwright-test',

package/dist/types/module-graph.d.ts

@@ -15,12 +15,12 @@ export type IdToFileMap = Map<Identifier, Set<FilePath>>;
 export type IdToNsToFileMap = Map<Identifier, Map<NamespaceOrAlias, Set<FilePath>>>;
 export type ImportMaps = {
     refs: References;
-    imported: IdToFileMap;
-    importedAs: IdToNsToFileMap;
-    importedNs: IdToFileMap;
-    reExported: IdToFileMap;
-    reExportedAs: IdToNsToFileMap;
-    reExportedNs: IdToFileMap;
+    import: IdToFileMap;
+    importAs: IdToNsToFileMap;
+    importNs: IdToFileMap;
+    reExport: IdToFileMap;
+    reExportNs: IdToFileMap;
+    reExportAs: IdToNsToFileMap;
 };
 export type ImportMap = Map<FilePath, ImportMaps>;
 export interface Import extends Position {
@@ -66,7 +66,7 @@ export type FileNode = {
     exports: ExportMap;
     duplicates: Iterable<Array<IssueSymbol>>;
     scripts: Set<string>;
-    imported: undefined | ImportMaps;
+    importedBy: undefined | ImportMaps;
     internalImportCache: undefined | ImportMap;
 };
 export type ModuleGraph = Map<FilePath, FileNode>;

package/dist/typescript/find-internal-references.d.ts

@@ -1,3 +1,3 @@
 import ts from 'typescript';
 import type { ExportWithSymbol, MemberWithSymbol } from './get-imports-and-exports.js';
-export declare const hasRefsInFile: (item: ExportWithSymbol | MemberWithSymbol, sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker) => boolean;
+export declare const _hasRefsInFile: (item: ExportWithSymbol | MemberWithSymbol, sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker) => boolean;

package/dist/typescript/find-internal-references.js

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import { timerify } from '../util/Performance.js';
 import { isIdChar } from '../util/regex.js';
 const findInFlow = (flowNode, targetSymbol) => {
     if (!flowNode?.node)
@@ -7,7 +8,7 @@ const findInFlow = (flowNode, targetSymbol) => {
         return true;
     return findInFlow(flowNode.antecedent, targetSymbol);
 };
-export const hasRefsInFile = (item, sourceFile, typeChecker) => {
+const hasRefsInFile = (item, sourceFile, typeChecker) => {
     if (!item.symbol)
         return false;
     if (item.identifier === '')
@@ -46,3 +47,4 @@ export const hasRefsInFile = (item, sourceFile, typeChecker) => {
     }
     return false;
 };
+export const _hasRefsInFile = timerify(hasRefsInFile);

package/dist/typescript/get-imports-and-exports.js

@@ -7,7 +7,7 @@ import { timerify } from '../util/Performance.js';
 import { dirname, isInNodeModules, resolve } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
 import { getAccessMembers, getDestructuredNames, getJSDocTags, getLineAndCharacterOfPosition, getTypeRef, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isInForIteration, isObjectEnumerationCallExpressionArgument, isReferencedInExport, } from './ast-helpers.js';
-import { hasRefsInFile } from './find-internal-references.js';
+import { _hasRefsInFile } from './find-internal-references.js';
 import { getImportsFromPragmas } from './pragmas/index.js';
 import getDynamicImportVisitors from './visitors/dynamic-imports/index.js';
 import getExportVisitors from './visitors/exports/index.js';
@@ -105,26 +105,26 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         const nsOrAlias = symbol ? String(symbol.escapedName) : options.alias;
         if (modifiers & IMPORT_FLAGS.RE_EXPORT) {
             if (isStar && namespace) {
-                addValue(importMaps.reExportedNs, namespace, sourceFile.fileName);
+                addValue(importMaps.reExportNs, namespace, sourceFile.fileName);
             }
             else if (nsOrAlias) {
-                addNsValue(importMaps.reExportedAs, identifier, nsOrAlias, sourceFile.fileName);
+                addNsValue(importMaps.reExportAs, identifier, nsOrAlias, sourceFile.fileName);
             }
             else {
-                addValue(importMaps.reExported, identifier, sourceFile.fileName);
+                addValue(importMaps.reExport, identifier, sourceFile.fileName);
             }
         }
         else {
             if (nsOrAlias && nsOrAlias !== identifier) {
                 if (isStar) {
-                    addValue(importMaps.importedNs, nsOrAlias, sourceFile.fileName);
+                    addValue(importMaps.importNs, nsOrAlias, sourceFile.fileName);
                 }
                 else {
-                    addNsValue(importMaps.importedAs, identifier, nsOrAlias, sourceFile.fileName);
+                    addNsValue(importMaps.importAs, identifier, nsOrAlias, sourceFile.fileName);
                 }
             }
             else if (identifier !== IMPORT_STAR) {
-                addValue(importMaps.imported, identifier, sourceFile.fileName);
+                addValue(importMaps.import, identifier, sourceFile.fileName);
             }
             if (symbol)
                 importedInternalSymbols.set(symbol, filePath);
@@ -209,13 +209,13 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 const internalImport = internal.get(importedSymbolFilePath);
                 if (internalImport) {
                     if (importId !== identifier) {
-                        addNsValue(internalImport.reExportedAs, importId, identifier, sourceFile.fileName);
+                        addNsValue(internalImport.reExportAs, importId, identifier, sourceFile.fileName);
                     }
                     else if (symbol.declarations && ts.isNamespaceImport(symbol.declarations[0])) {
-                        addValue(internalImport.reExportedNs, identifier, sourceFile.fileName);
+                        addValue(internalImport.reExportNs, identifier, sourceFile.fileName);
                     }
                     else {
-                        addValue(internalImport.reExported, importId, sourceFile.fileName);
+                        addValue(internalImport.reExport, importId, sourceFile.fileName);
                     }
                 }
             }
@@ -354,7 +354,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                                 if (_node && ts.isIdentifier(_node.name)) {
                                     const varName = _node.name.text;
                                     if (exports.has(varName)) {
-                                        addNsValue(imports.reExportedAs, id, [varName, ...path].join('.'), sourceFile.fileName);
+                                        addNsValue(imports.reExportAs, id, [varName, ...path].join('.'), sourceFile.fileName);
                                     }
                                     else if (path.length === 0) {
                                         addImportAlias(varName, id, filePath);
@@ -380,7 +380,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                                     ts.isIdentifier(node.parent.name)) {
                                     const aliasName = node.parent.name.text;
                                     if (exports.has(aliasName)) {
-                                        addNsValue(imports.reExportedAs, id, aliasName, sourceFile.fileName);
+                                        addNsValue(imports.reExportAs, id, aliasName, sourceFile.fileName);
                                     }
                                     else {
                                         addImportAlias(aliasName, id, filePath);
@@ -403,7 +403,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                                         addImportAlias(`${_node.name.text}.${id}`, id, filePath);
                                     imports.refs.add(id);
                                 }
-                                else if (imports.importedNs.has(id) && isConsiderReferencedNS(node)) {
+                                else if (imports.importNs.has(id) && isConsiderReferencedNS(node)) {
                                     imports.refs.add(id);
                                 }
                                 else if (isObjectEnumerationCallExpressionArgument(node)) {
@@ -440,11 +440,11 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         item.referencedIn = referencedInExport.get(id);
         if (shouldCountRefs(ignoreExportsUsedInFile, item.type) ||
             (item.symbol?.valueDeclaration && ts.isBindingElement(item.symbol.valueDeclaration))) {
-            item.hasRefsInFile = hasRefsInFile(item, sourceFile, typeChecker);
+            item.hasRefsInFile = _hasRefsInFile(item, sourceFile, typeChecker);
         }
         for (const member of item.members) {
             if (item.type === 'enum' || shouldCountRefs(ignoreExportsUsedInFile, member.type)) {
-                member.hasRefsInFile = hasRefsInFile(member, sourceFile, typeChecker);
+                member.hasRefsInFile = _hasRefsInFile(member, sourceFile, typeChecker);
             }
             delete member.symbol;
         }
@@ -455,7 +455,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         exports,
         duplicates: [...aliasedExports.values()],
         scripts,
-        imported: undefined,
+        importedBy: undefined,
         internalImportCache: undefined,
     };
 };

package/dist/util/create-options.d.ts

@@ -380,6 +380,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             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;
@@ -1011,6 +1016,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 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/util/module-graph.js

@@ -1,31 +1,31 @@
 const updateImportMaps = (fromImportMaps, toImportMaps) => {
     for (const id of fromImportMaps.refs)
         toImportMaps.refs.add(id);
-    for (const [id, v] of fromImportMaps.imported)
-        addValues(toImportMaps.imported, id, v);
-    for (const [id, v] of fromImportMaps.importedAs)
-        addNsValues(toImportMaps.importedAs, id, v);
-    for (const [id, v] of fromImportMaps.importedNs)
-        addValues(toImportMaps.importedNs, id, v);
-    for (const [id, v] of fromImportMaps.reExported)
-        addValues(toImportMaps.reExported, id, v);
-    for (const [id, v] of fromImportMaps.reExportedAs)
-        addNsValues(toImportMaps.reExportedAs, id, v);
-    for (const [id, v] of fromImportMaps.reExportedNs)
-        addValues(toImportMaps.reExportedNs, id, v);
+    for (const [id, v] of fromImportMaps.import)
+        addValues(toImportMaps.import, id, v);
+    for (const [id, v] of fromImportMaps.importAs)
+        addNsValues(toImportMaps.importAs, id, v);
+    for (const [id, v] of fromImportMaps.importNs)
+        addValues(toImportMaps.importNs, id, v);
+    for (const [id, v] of fromImportMaps.reExport)
+        addValues(toImportMaps.reExport, id, v);
+    for (const [id, v] of fromImportMaps.reExportAs)
+        addNsValues(toImportMaps.reExportAs, id, v);
+    for (const [id, v] of fromImportMaps.reExportNs)
+        addValues(toImportMaps.reExportNs, id, v);
 };
 export const updateImportMap = (file, importMap, graph) => {
-    for (const [importedFilePath, fileImportMaps] of importMap) {
-        const importMaps = file.imports.internal.get(importedFilePath);
+    for (const [importedByFilePath, fileImportMaps] of importMap) {
+        const importMaps = file.imports.internal.get(importedByFilePath);
         if (!importMaps)
-            file.imports.internal.set(importedFilePath, fileImportMaps);
+            file.imports.internal.set(importedByFilePath, fileImportMaps);
         else
             updateImportMaps(fileImportMaps, importMaps);
-        const importedFile = graph.get(importedFilePath) ?? createFileNode();
-        if (!importedFile.imported)
-            importedFile.imported = createImports();
-        updateImportMaps(fileImportMaps, importedFile.imported);
-        graph.set(importedFilePath, importedFile);
+        const importedByFile = graph.get(importedByFilePath) ?? createFileNode();
+        if (!importedByFile.importedBy)
+            importedByFile.importedBy = createImports();
+        updateImportMaps(fileImportMaps, importedByFile.importedBy);
+        graph.set(importedByFilePath, importedByFile);
     }
 };
 export const createFileNode = () => ({
@@ -41,17 +41,17 @@ export const createFileNode = () => ({
     exports: new Map(),
     duplicates: new Set(),
     scripts: new Set(),
-    imported: undefined,
+    importedBy: undefined,
     internalImportCache: undefined,
 });
 export const createImports = () => ({
     refs: new Set(),
-    imported: new Map(),
-    importedAs: new Map(),
-    importedNs: new Map(),
-    reExported: new Map(),
-    reExportedAs: new Map(),
-    reExportedNs: new Map(),
+    import: new Map(),
+    importAs: new Map(),
+    importNs: new Map(),
+    reExport: new Map(),
+    reExportAs: new Map(),
+    reExportNs: new Map(),
 });
 export const addValue = (map, id, value) => {
     if (map.has(id))

package/dist/util/trace.js

@@ -8,7 +8,7 @@ export const formatTrace = (node, toRelative, isReferenced) => {
     const ok = pc.green;
     const fail = pc.red;
     const dim = pc.dim;
-    const entryMarker = node.isEntry ? dim(' ◯') : '';
+    const entryMarker = node.isEntry ? dim(' ⎆') : '';
     lines.push(`${file(toRelative(node.filePath))}${dim(':')}${id(node.identifier)}${entryMarker}`);
     const formatVia = (child) => {
         if (!child.via)
@@ -22,7 +22,7 @@ export const formatTrace = (node, toRelative, isReferenced) => {
     const formatChild = (child, prefix, isLast) => {
         const connector = isLast ? '└── ' : '├── ';
         const childPrefix = isLast ? '    ' : '│   ';
-        const entryMarker = child.isEntry ? dim(' ◯') : '';
+        const entryMarker = child.isEntry ? dim(' ⎆') : '';
         const isLeaf = child.children.length === 0;
         const leafMarker = isLeaf && !child.via?.startsWith('reExport') ? (isReferenced ? ok(' ✓') : fail(' ✗')) : '';
         lines.push(`${dim(prefix)}${dim(connector)}${file(toRelative(child.filePath))}${dim(':')}${formatVia(child)}${entryMarker}${leafMarker}`);

package/dist/util/watch.js

@@ -71,7 +71,7 @@ export const getSessionHandler = async (options, { analyzedFiles, analyzeSourceF
         else {
             for (const [filePath, file] of graph) {
                 if (filePaths.includes(filePath)) {
-                    file.imported = undefined;
+                    file.importedBy = undefined;
                 }
                 else {
                     graph.delete(filePath);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.79.0";
+export declare const version = "5.80.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.79.0';
+export const version = '5.80.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.79.0",
+  "version": "5.80.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {