knip 6.14.2 → 6.16.0

package/dist/CacheConsultant.d.ts

@@ -4,6 +4,7 @@ export declare class CacheConsultant<T> {
     private cache;
     getFileDescriptor: (filePath: string) => FileDescriptor<T>;
     reconcile: () => void;
+    removeEntry: (filePath: string) => void;
     constructor(name: string, options: MainOptions);
     getCachedFile(filePath: string): T | undefined;
 }

package/dist/CacheConsultant.js

@@ -6,6 +6,7 @@ export class CacheConsultant {
     cache;
     getFileDescriptor = () => dummyFileDescriptor;
     reconcile = () => { };
+    removeEntry = () => { };
     constructor(name, options) {
         if (!options.isCache)
             return;
@@ -13,6 +14,7 @@ export class CacheConsultant {
         this.cache = new FileEntryCache(cacheName, options.cacheLocation);
         this.getFileDescriptor = timerify(this.cache.getFileDescriptor.bind(this.cache));
         this.reconcile = timerify(this.cache.reconcile.bind(this.cache));
+        this.removeEntry = timerify(this.cache.removeEntry.bind(this.cache));
     }
     getCachedFile(filePath) {
         if (!this.cache)

package/dist/ConfigurationChief.d.ts

@@ -112,6 +112,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        catalyst?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         changelogen?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -212,6 +217,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        fast?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         gatsby?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -287,6 +297,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        lit?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'lockfile-lint'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -332,6 +347,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'nano-spawn'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         'nano-staged'?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -412,6 +432,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        orval?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         oxfmt?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -816,6 +841,7 @@ export declare class ConfigurationChief {
         ignoreDependencies?: (string | RegExp)[] | undefined;
         ignoreMembers?: (string | RegExp)[] | undefined;
         ignoreUnresolved?: (string | RegExp)[] | undefined;
+        ignoreExportsUsedInFile?: boolean | Record<string, boolean | undefined> | undefined;
         includeEntryExports?: boolean | undefined;
     };
     getIgnores(workspaceName: string): {
@@ -829,6 +855,7 @@ export declare class ConfigurationChief {
         paths: Record<string, string[]>;
         ignore: string[];
         ignoreFiles: string[];
+        ignoreExportsUsedInFile: Record<string, boolean | undefined> | import("./types/config.ts").IgnoreExportsUsedInFile;
         isIncludeEntryExports: boolean;
         angular?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         astro?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -841,6 +868,7 @@ export declare class ConfigurationChief {
         bun?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         c8?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         capacitor?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        catalyst?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         changelogen?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         changelogithub?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         changesets?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -861,6 +889,7 @@ export declare class ConfigurationChief {
         execa?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         expo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "expressive-code"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        fast?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         gatsby?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-action"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "github-actions"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -876,6 +905,7 @@ export declare class ConfigurationChief {
         lefthook?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "lint-staged"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         linthtml?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        lit?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "lockfile-lint"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "lost-pixel"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         markdownlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -885,6 +915,7 @@ export declare class ConfigurationChief {
         mocha?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         moonrepo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         msw?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "nano-spawn"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "nano-staged"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         nest?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         netlify?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
@@ -901,6 +932,7 @@ export declare class ConfigurationChief {
         nyc?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oclif?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "openapi-ts"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        orval?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oxfmt?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         oxlint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         "panda-css"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/ConfigurationChief.js

@@ -8,7 +8,6 @@ import { _dirGlob, removeProductionSuffix } from './util/glob.js';
 import { graphSequencer } from './util/graph-sequencer.js';
 import mapWorkspaces from './util/map-workspaces.js';
 import { join, relative } from './util/path.js';
-import { timerify } from './util/Performance.js';
 import { normalizePluginConfig } from './util/plugin.js';
 import { toRegexOrString } from './util/regex.js';
 import { ELLIPSIS } from './util/string.js';
@@ -76,7 +75,7 @@ export class ConfigurationChief {
         this.workspaces = options.workspaces;
         this.rawConfig = options.parsedConfig;
         this.config = this.normalize(options.parsedConfig ?? {});
-        this.findWorkspaceByFilePath = timerify(this.findWorkspaceByFilePath.bind(this), 'findWorkspaceByFilePath');
+        this.findWorkspaceByFilePath = this.findWorkspaceByFilePath.bind(this);
     }
     getConfigurationHints() {
         const hints = [];
@@ -269,9 +268,7 @@ export class ConfigurationChief {
         return this.availableWorkspaceNames.filter(workspaceName => workspaceName !== name && (name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(prefix)));
     }
     getIgnoredWorkspacesFor(name) {
-        return this.ignoredWorkspacePatterns
-            .filter(workspaceName => workspaceName !== name)
-            .filter(workspaceName => name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(name));
+        return this.ignoredWorkspacePatterns.filter(workspaceName => workspaceName !== name && (name === ROOT_WORKSPACE_NAME || workspaceName.startsWith(name)));
     }
     createIgnoredWorkspaceMatcher(name, dir) {
         const ignoredWorkspaces = this.getIgnoredWorkspacesFor(name);
@@ -305,12 +302,12 @@ export class ConfigurationChief {
     }
     getWorkspaceConfig(workspaceName) {
         const key = this.getConfigKeyForWorkspace(workspaceName);
+        if (!key)
+            return {};
         const workspaces = this.rawConfig?.workspaces ?? {};
-        return ((key
-            ? key === ROOT_WORKSPACE_NAME && !(ROOT_WORKSPACE_NAME in workspaces)
-                ? this.rawConfig
-                : workspaces[key]
-            : {}) ?? {});
+        if (key === ROOT_WORKSPACE_NAME && !(ROOT_WORKSPACE_NAME in workspaces))
+            return this.rawConfig ?? {};
+        return workspaces[key] ?? {};
     }
     getIgnores(workspaceName) {
         const workspaceConfig = this.getWorkspaceConfig(workspaceName);
@@ -335,6 +332,7 @@ export class ConfigurationChief {
         const paths = workspaceConfig.paths ?? {};
         const ignore = arrayify(workspaceConfig.ignore);
         const ignoreFiles = arrayify(workspaceConfig.ignoreFiles);
+        const ignoreExportsUsedInFile = workspaceConfig.ignoreExportsUsedInFile ?? this.config.ignoreExportsUsedInFile;
         const isIncludeEntryExports = workspaceConfig.includeEntryExports ?? this.config.isIncludeEntryExports;
         const plugins = {};
         for (const [pluginName, pluginConfig] of Object.entries(this.config.rootPluginConfigs)) {
@@ -346,7 +344,7 @@ export class ConfigurationChief {
                 plugins[pluginName] = normalizePluginConfig(pluginConfig);
             }
         }
-        return { entry, project, paths, ignore, ignoreFiles, isIncludeEntryExports, ...plugins };
+        return { entry, project, paths, ignore, ignoreFiles, ignoreExportsUsedInFile, isIncludeEntryExports, ...plugins };
     }
     findWorkspaceByFilePath(filePath) {
         if (this.workspaceByFileCache.has(filePath))

package/dist/DependencyDeputy.d.ts

@@ -49,10 +49,6 @@ export declare class DependencyDeputy {
     getDevDependencies(workspaceName: string): DependencyArray;
     private dependencyCache;
     getDependencies(workspaceName: string): DependencySet;
-    setInstalledBinaries(workspaceName: string, installedBinaries: Map<string, Set<string>>): void;
-    getInstalledBinaries(workspaceName: string): InstalledBinaries | undefined;
-    setHasTypesIncluded(workspaceName: string, hasTypesIncluded: Set<string>): void;
-    getHasTypesIncluded(workspaceName: string): Set<string> | undefined;
     addReferencedDependency(workspaceName: string, packageName: string): void;
     addReferencedBinary(workspaceName: string, binaryName: string): void;
     setHostDependencies(workspaceName: string, hostDependencies: HostDependencies): void;

package/dist/DependencyDeputy.js

@@ -48,8 +48,8 @@ export class DependencyDeputy {
                 cwd,
             });
             this.setHostDependencies(name, hostDependencies);
-            this.setInstalledBinaries(name, installedBinaries);
-            this.setHasTypesIncluded(name, hasTypesIncluded);
+            this.installedBinaries.set(name, installedBinaries);
+            this.hasTypesIncluded.set(name, hasTypesIncluded);
         }
         const ignoreDependencies = id.flatMap(id => filterIsProduction(id, this.isProduction)).map(toRegexOrString);
         const ignoreBinaries = ib.flatMap(ib => filterIsProduction(ib, this.isProduction)).map(toRegexOrString);
@@ -100,18 +100,6 @@ export class DependencyDeputy {
         this.dependencyCache.set(workspaceName, deps);
         return deps;
     }
-    setInstalledBinaries(workspaceName, installedBinaries) {
-        this.installedBinaries.set(workspaceName, installedBinaries);
-    }
-    getInstalledBinaries(workspaceName) {
-        return this.installedBinaries.get(workspaceName);
-    }
-    setHasTypesIncluded(workspaceName, hasTypesIncluded) {
-        this.hasTypesIncluded.set(workspaceName, hasTypesIncluded);
-    }
-    getHasTypesIncluded(workspaceName) {
-        return this.hasTypesIncluded.get(workspaceName);
-    }
     addReferencedDependency(workspaceName, packageName) {
         if (!this.referencedDependencies.has(workspaceName)) {
             this.referencedDependencies.set(workspaceName, new Set());
@@ -182,7 +170,7 @@ export class DependencyDeputy {
         this.addReferencedBinary(workspace.name, binaryName);
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
         for (const name of workspaceNames) {
-            const binaries = this.getInstalledBinaries(name);
+            const binaries = this.installedBinaries.get(name);
             if (binaries?.has(binaryName)) {
                 const dependencies = binaries.get(binaryName);
                 if (dependencies?.size) {
@@ -210,7 +198,7 @@ export class DependencyDeputy {
         const optionalPeerDependencyIssues = [];
         for (const [workspace, { manifestPath: filePath, manifestStr }] of this._manifests) {
             const referencedDependencies = this.referencedDependencies.get(workspace);
-            const hasTypesIncluded = this.getHasTypesIncluded(workspace);
+            const hasTypesIncluded = this.hasTypesIncluded.get(workspace);
             const peeker = new PackagePeeker(manifestStr);
             const isReferencedDependency = (dependency, visited = new Set()) => {
                 if (referencedDependencies?.has(dependency))

package/dist/IssueCollector.d.ts

@@ -22,6 +22,7 @@ export declare class IssueCollector {
     private unusedIgnoreFilesPatterns;
     constructor(options: MainOptions);
     setWorkspaceFilter(workspaceFilePathFilter: WorkspaceFilePathFilter | undefined): void;
+    private collectIgnorePatterns;
     addIgnorePatterns(entries: {
         pattern: string;
         id: string;

package/dist/IssueCollector.js

@@ -40,37 +40,27 @@ export class IssueCollector {
         if (workspaceFilePathFilter)
             this.workspaceFilter = workspaceFilePathFilter;
     }
-    addIgnorePatterns(entries) {
+    collectIgnorePatterns(entries, patterns, unused, type) {
         for (const entry of entries) {
-            this.ignorePatterns.add(entry.pattern);
+            patterns.add(entry.pattern);
             if (!this.isTrackUnusedIgnorePatterns)
                 continue;
             if (entry.pattern.startsWith('!'))
                 continue;
-            if (this.unusedIgnorePatterns.has(entry.pattern))
+            if (unused.has(entry.pattern))
                 continue;
-            this.unusedIgnorePatterns.set(entry.pattern, {
-                hint: { type: 'ignore', identifier: entry.id, workspaceName: entry.workspaceName },
+            unused.set(entry.pattern, {
+                hint: { type, identifier: entry.id, workspaceName: entry.workspaceName },
                 isMatch: picomatch(entry.pattern, { dot: true }),
             });
         }
-        this.isMatch = createMatcher(this.ignorePatterns);
+        return createMatcher(patterns);
+    }
+    addIgnorePatterns(entries) {
+        this.isMatch = this.collectIgnorePatterns(entries, this.ignorePatterns, this.unusedIgnorePatterns, 'ignore');
     }
     addIgnoreFilesPatterns(entries) {
-        for (const entry of entries) {
-            this.ignoreFilesPatterns.add(entry.pattern);
-            if (!this.isTrackUnusedIgnorePatterns)
-                continue;
-            if (entry.pattern.startsWith('!'))
-                continue;
-            if (this.unusedIgnoreFilesPatterns.has(entry.pattern))
-                continue;
-            this.unusedIgnoreFilesPatterns.set(entry.pattern, {
-                hint: { type: 'ignoreFiles', identifier: entry.id, workspaceName: entry.workspaceName },
-                isMatch: picomatch(entry.pattern, { dot: true }),
-            });
-        }
-        this.isFileMatch = createMatcher(this.ignoreFilesPatterns);
+        this.isFileMatch = this.collectIgnorePatterns(entries, this.ignoreFilesPatterns, this.unusedIgnoreFilesPatterns, 'ignoreFiles');
     }
     markUsedPatterns(filePath, unused) {
         if (unused.size === 0)

package/dist/IssueFixer.js

@@ -100,22 +100,17 @@ class IssueFixer {
         for (const filePath of filePaths) {
             const absFilePath = join(this.options.cwd, filePath);
             const pkg = await load(absFilePath);
-            if (filePath in issues.dependencies) {
-                for (const dependency of Object.keys(issues.dependencies[filePath])) {
-                    if (pkg.dependencies) {
-                        delete pkg.dependencies[dependency];
-                        issues.dependencies[filePath][dependency].isFixed = true;
-                    }
+            const removeDependencies = (key) => {
+                const deps = pkg[key];
+                if (!deps || !(filePath in issues[key]))
+                    return;
+                for (const dependency of Object.keys(issues[key][filePath])) {
+                    delete deps[dependency];
+                    issues[key][filePath][dependency].isFixed = true;
                 }
-            }
-            if (filePath in issues.devDependencies) {
-                for (const dependency of Object.keys(issues.devDependencies[filePath])) {
-                    if (pkg.devDependencies) {
-                        delete pkg.devDependencies[dependency];
-                        issues.devDependencies[filePath][dependency].isFixed = true;
-                    }
-                }
-            }
+            };
+            removeDependencies('dependencies');
+            removeDependencies('devDependencies');
             await save(absFilePath, pkg);
             touchedFiles.add(absFilePath);
         }

package/dist/ProjectPrincipal.d.ts

@@ -15,10 +15,10 @@ export declare class ProjectPrincipal {
     pluginCtx: PluginVisitorContext;
     pluginVisitorObjects: PluginVisitorObject[];
     private _visitor;
+    private _localRefsVisitor;
     syncCompilers: SyncCompilers;
     asyncCompilers: AsyncCompilers;
     private paths;
-    private rootDirs;
     private extensions;
     cache: CacheConsultant<FileNode>;
     toSourceFilePath: ToSourceFilePath;
@@ -30,8 +30,7 @@ export declare class ProjectPrincipal {
     private onPathAdded;
     constructor(options: MainOptions, toSourceFilePath: ToSourceFilePath, findWorkspaceManifestImports?: WorkspaceManifestHandler);
     addCompilers(compilers: [SyncCompilers, AsyncCompilers]): void;
-    addPaths(paths: Paths, basePath: string): void;
-    addRootDirs(rootDirs: string[]): void;
+    addPaths(paths: Paths, basePath: string, scope: string): void;
     init(): void;
     readFile(filePath: string): string;
     private hasAcceptedExtension;

package/dist/ProjectPrincipal.js

@@ -21,13 +21,14 @@ export class ProjectPrincipal {
         sourceText: '',
         addScript: () => { },
         addImport: () => { },
+        markExportRegistered: () => { },
     };
     pluginVisitorObjects = [];
     _visitor;
+    _localRefsVisitor;
     syncCompilers = new Map();
     asyncCompilers = new Map();
-    paths = {};
-    rootDirs = [];
+    paths = new Map();
     extensions = new Set(DEFAULT_EXTENSIONS);
     cache;
     toSourceFilePath;
@@ -61,24 +62,15 @@ export class ProjectPrincipal {
             }
         }
     }
-    addPaths(paths, basePath) {
+    addPaths(paths, basePath, scope) {
         if (!paths)
             return;
+        const scoped = this.paths.get(scope) ?? {};
         for (const key in paths) {
             const prefixes = paths[key].map(prefix => toAbsolute(prefix, basePath));
-            if (key in this.paths) {
-                this.paths[key] = compact([...this.paths[key], ...prefixes]);
-            }
-            else {
-                this.paths[key] = prefixes;
-            }
-        }
-    }
-    addRootDirs(rootDirs) {
-        for (const dir of rootDirs) {
-            if (!this.rootDirs.includes(dir))
-                this.rootDirs.push(dir);
+            scoped[key] = key in scoped ? compact([...scoped[key], ...prefixes]) : prefixes;
         }
+        this.paths.set(scope, scoped);
     }
     init() {
         this.extensions = new Set([
@@ -86,9 +78,8 @@ export class ProjectPrincipal {
             ...getCompilerExtensions([this.syncCompilers, this.asyncCompilers]),
         ]);
         const customCompilerExtensions = getCompilerExtensions([this.syncCompilers, this.asyncCompilers]);
-        const pathsOrUndefined = Object.keys(this.paths).length > 0 ? this.paths : undefined;
-        const rootDirsOrUndefined = this.rootDirs.length > 1 ? this.rootDirs : undefined;
-        this.resolveModule = createCustomModuleResolver({ paths: pathsOrUndefined, rootDirs: rootDirsOrUndefined }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports);
+        const scopedPaths = this.paths.size > 0 ? Array.from(this.paths, ([scope, paths]) => ({ scope, paths })) : undefined;
+        this.resolveModule = createCustomModuleResolver({ scopedPaths }, customCompilerExtensions, this.toSourceFilePath, this.findWorkspaceManifestImports);
     }
     readFile(filePath) {
         return this.fileManager.readFile(filePath);
@@ -223,9 +214,10 @@ export class ProjectPrincipal {
                 options = { ...options, isFixExports: false, isFixTypes: false };
             }
         }
-        if (!this._visitor)
-            this._visitor = buildVisitor(this.pluginVisitorObjects, !!ignoreExportsUsedInFile);
-        return _getImportsAndExports(filePath, sourceText, this.resolveModule, options, ignoreExportsUsedInFile, skipExports, this._visitor, this.pluginVisitorObjects.length > 0 ? this.pluginCtx : undefined, parseResult);
+        const visitor = ignoreExportsUsedInFile
+            ? (this._localRefsVisitor ??= buildVisitor(this.pluginVisitorObjects, true))
+            : (this._visitor ??= buildVisitor(this.pluginVisitorObjects, false));
+        return _getImportsAndExports(filePath, sourceText, this.resolveModule, options, ignoreExportsUsedInFile, skipExports, visitor, this.pluginVisitorObjects.length > 0 ? this.pluginCtx : undefined, parseResult);
     }
     invalidateFile(filePath) {
         this.fileManager.invalidate(filePath);

package/dist/WorkspaceWorker.js

@@ -322,6 +322,7 @@ export class WorkspaceWorker {
                     configFileName: basename(configFilePath),
                 };
                 const cache = {};
+                let hasLoadConfigError = false;
                 const key = `${wsName}:${pluginName}`;
                 if (plugin.resolveConfig && !seen.get(key)?.has(configFilePath)) {
                     if (parsed && isExternalReExportsOnly(parsed)) {
@@ -345,6 +346,7 @@ export class WorkspaceWorker {
                             catch (error) {
                                 if (!(error instanceof Error))
                                     throw error;
+                                hasLoadConfigError = true;
                                 const relPath = toRelative(configFilePath, this.options.cwd);
                                 const cause = formatCauseMessage(error, this.options.cwd);
                                 logError(`Error loading ${relPath} (${cause})`);
@@ -364,7 +366,10 @@ export class WorkspaceWorker {
                     inputs.push(toEntry(configFilePath));
                     storeConfigFilePath(pluginName, toConfig(pluginName, configFilePath));
                     cache.configFile = toEntry(configFilePath);
-                    if (fd?.changed && fd.meta && !seen.get(key)?.has(configFilePath)) {
+                    if (hasLoadConfigError) {
+                        this.cache.removeEntry(configFilePath);
+                    }
+                    else if (fd?.changed && fd.meta && !seen.get(key)?.has(configFilePath)) {
                         fd.meta.data = cache;
                     }
                     if (!seen.has(key))

package/dist/binaries/fallback.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../util/parse-args.js';
 import { compact } from '../util/array.js';
 import { toBinary, toDeferResolve, toEntry } from '../util/input.js';
 import { isValidBinary } from '../util/modules.js';

package/dist/binaries/plugins.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../util/parse-args.js';
 import { pluginArgsMap } from '../plugins.js';
 import { compact } from '../util/array.js';
 import { toBinary, toConfig, toDeferResolve, toDeferResolveEntry, toEntry } from '../util/input.js';

package/dist/binaries/resolvers/bun.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toBinary, toEntry } from '../../util/input.js';
 import { isAbsolute, join } from '../../util/path.js';
 import { _resolveSync } from '../../util/resolve.js';

package/dist/binaries/resolvers/bunx.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { isInternal } from '../../util/path.js';

package/dist/binaries/resolvers/npm.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 export const resolve = (_binary, args, options) => {
     const { fromArgs, manifest } = options;
     const parsed = parseArgs(args, { '--': true });

package/dist/binaries/resolvers/npx.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { isInternal } from '../../util/path.js';

package/dist/binaries/resolvers/pnpm.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toBinary } from '../../util/input.js';
 import { isValidBinary } from '../../util/modules.js';
 import { resolveDlx } from './pnpx.js';

package/dist/binaries/resolvers/pnpx.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 export const resolveDlx = (args, options) => {

package/dist/binaries/resolvers/yarn.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../../util/parse-args.js';
 import { isBinary, isDependency, toBinary, toDependency } from '../../util/input.js';
 import { stripVersionFromSpecifier } from '../../util/modules.js';
 import { join } from '../../util/path.js';

package/dist/binaries/util.d.ts

@@ -1,3 +1,2 @@
-import parseArgs from 'minimist';
 export declare const argsFrom: (args: string[], from: string) => string[];
-export declare const parseNodeArgs: (args: string[]) => parseArgs.ParsedArgs;
+export declare const parseNodeArgs: (args: string[]) => import("../util/parse-args.ts").ParsedArgs;

package/dist/binaries/util.js

@@ -1,4 +1,4 @@
-import parseArgs from 'minimist';
+import parseArgs from '../util/parse-args.js';
 export const argsFrom = (args, from) => args.slice(args.indexOf(from));
 export const parseNodeArgs = (args) => parseArgs(args, {
     string: ['r'],

package/dist/cli.js

@@ -50,6 +50,7 @@ const main = async () => {
             isProduction: options.isProduction,
             isShowProgress: options.isShowProgress,
             isTreatConfigHintsAsErrors: options.isTreatConfigHintsAsErrors,
+            isTreatTagHintsAsErrors: options.isTreatTagHintsAsErrors,
             maxShowIssues: args['max-show-issues'] ? Number(args['max-show-issues']) : undefined,
             options: args['reporter-options'] ?? '',
             preprocessorOptions: args['preprocessor-options'] ?? '',
@@ -75,7 +76,8 @@ const main = async () => {
         }
         if (!args['no-exit-code'] &&
             (totalErrorCount > Number(args['max-issues'] ?? 0) ||
-                (!options.isDisableConfigHints && options.isTreatConfigHintsAsErrors && configurationHints.length > 0))) {
+                (!options.isDisableConfigHints && options.isTreatConfigHintsAsErrors && configurationHints.length > 0) ||
+                (!options.isDisableTagHints && options.isTreatTagHintsAsErrors && tagHints.size > 0))) {
             process.exitCode = 1;
             return;
         }

package/dist/compilers/compilers.d.ts

@@ -1,6 +1,9 @@
 import type { CompilerSync } from './types.ts';
 export declare const fencedCodeBlockMatcher: RegExp;
 export declare const inlineCodeMatcher: RegExp;
+export declare const scriptExtractor: RegExp;
+export declare const blockCommentMatcher: RegExp;
+export declare const lineCommentMatcher: RegExp;
 export declare const importMatcher: RegExp;
 export declare const importsWithinScripts: CompilerSync;
 export declare const scriptBodies: CompilerSync;

package/dist/compilers/compilers.js

@@ -1,27 +1,23 @@
 export const fencedCodeBlockMatcher = /```[\s\S]*?```/g;
 export const inlineCodeMatcher = /`[^`]+`/g;
-const scriptExtractor = /<script\b(?:[^>"']|"[^"]*"|'[^']*')*>([\s\S]*?)<\/script>/gm;
-const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
-const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;
+export const scriptExtractor = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/script>/gi;
+export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
+export const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;
 export const importMatcher = /import(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
 export const importsWithinScripts = (text) => {
     const scripts = [];
-    let scriptMatch;
-    while ((scriptMatch = scriptExtractor.exec(text))) {
-        const body = scriptMatch[1].replace(blockCommentMatcher, '').replace(lineCommentMatcher, '');
-        for (const importMatch of body.matchAll(importMatcher)) {
+    for (const [, , scriptBody] of text.matchAll(scriptExtractor)) {
+        const body = scriptBody.replace(blockCommentMatcher, '').replace(lineCommentMatcher, '');
+        for (const importMatch of body.matchAll(importMatcher))
             scripts.push(importMatch);
-        }
     }
     return scripts.join(';\n');
 };
-const scriptBodyExtractor = /<script\b(?:[^>"']|"[^"]*"|'[^']*')*>(?<body>[\s\S]*?)<\/script>/gm;
 export const scriptBodies = (text) => {
     const scripts = [];
-    let scriptMatch;
-    while ((scriptMatch = scriptBodyExtractor.exec(text))) {
-        if (scriptMatch.groups?.body)
-            scripts.push(scriptMatch.groups.body);
+    for (const [, , body] of text.matchAll(scriptExtractor)) {
+        if (body)
+            scripts.push(body);
     }
     return scripts.join(';\n');
 };