knip 6.23.0 → 6.24.0

package/LICENSE

@@ -1,6 +1,6 @@
 ISC License (ISC)
 
-Copyright 2022-2025 Lars Kappert
+Copyright 2022-2026 Lars Kappert
 
 Permission to use, copy, modify, and/or distribute this software for any purpose
 with or without fee is hereby granted, provided that the above copyright notice

package/dist/ProjectPrincipal.js

@@ -130,11 +130,9 @@ export class ProjectPrincipal {
     }
     async runAsyncCompilers() {
         const add = timerify(this.fileManager.compileAndAddSourceFile.bind(this.fileManager));
-        const extensions = Array.from(this.asyncCompilers.keys());
-        const files = Array.from(this.projectPaths).filter(filePath => extensions.includes(extname(filePath)));
-        for (const filePath of files) {
-            await add(filePath);
-        }
+        for (const filePath of this.projectPaths)
+            if (this.asyncCompilers.has(extname(filePath)))
+                await add(filePath);
     }
     walkAndAnalyze(analyzeFile) {
         this.resolvedFiles.clear();

package/dist/WorkspaceWorker.d.ts

@@ -17,6 +17,7 @@ type WorkspaceManagerOptions = {
     rootManifest: Manifest | undefined;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getManifest: (dir: string) => Manifest | undefined;
     readFile: (filePath: string) => string;
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
@@ -38,6 +39,7 @@ export declare class WorkspaceWorker {
     dependencies: DependencySet;
     handleInput: HandleInput;
     findWorkspaceByFilePath: (filePath: string) => Workspace | undefined;
+    getManifest: (dir: string) => Manifest | undefined;
     readFile: (filePath: string) => string;
     negatedWorkspacePatterns: string[];
     ignoredWorkspacePatterns: string[];
@@ -47,7 +49,7 @@ export declare class WorkspaceWorker {
     enabledPluginsInAncestors: string[];
     cache: CacheConsultant<CacheItem>;
     configFilesMap: Map<string, Map<PluginName, Set<string>>>;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, readFile, configFilesMap, options, }: WorkspaceManagerOptions);
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readFile, configFilesMap, options, }: WorkspaceManagerOptions);
     init(): Promise<void>;
     private determineEnabledPlugins;
     private getConfigForPlugin;

package/dist/WorkspaceWorker.js

@@ -32,6 +32,7 @@ export class WorkspaceWorker {
     dependencies;
     handleInput;
     findWorkspaceByFilePath;
+    getManifest;
     readFile;
     negatedWorkspacePatterns = [];
     ignoredWorkspacePatterns = [];
@@ -41,7 +42,7 @@ export class WorkspaceWorker {
     enabledPluginsInAncestors;
     cache;
     configFilesMap;
-    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, readFile, configFilesMap, options, }) {
+    constructor({ name, dir, config, manifest, dependencies, rootManifest, negatedWorkspacePatterns, ignoredWorkspacePatterns, enabledPluginsInAncestors, handleInput, findWorkspaceByFilePath, getManifest, readFile, configFilesMap, options, }) {
         this.name = name;
         this.dir = dir;
         this.config = config;
@@ -54,6 +55,7 @@ export class WorkspaceWorker {
         this.configFilesMap = configFilesMap;
         this.handleInput = handleInput;
         this.findWorkspaceByFilePath = findWorkspaceByFilePath;
+        this.getManifest = getManifest;
         this.readFile = readFile;
         this.options = options;
         this.cache = new CacheConsultant(`plugins-${name}`, options);
@@ -211,7 +213,8 @@ export class WorkspaceWorker {
         const isProduction = this.options.isProduction;
         const knownBinsOnly = false;
         const rootManifest = this.rootManifest;
-        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly };
+        const getManifest = this.getManifest;
+        const baseOptions = { manifest, rootManifest, cwd, rootCwd, containingFilePath, knownBinsOnly, getManifest };
         const baseScriptOptions = { ...baseOptions, isProduction, enabledPlugins: this.enabledPlugins };
         const [productionScripts, developmentScripts] = getFilteredScripts(manifest.scripts ?? {});
         const inputsFromManifest = _getInputsFromScripts(Object.values(developmentScripts), baseOptions);

package/dist/binaries/resolvers/yarn.js

@@ -49,15 +49,16 @@ const resolveDlx = (args, options) => {
     return [...packages.map(id => toDependency(id)), ...command].map(id => isDependency(id) || isBinary(id) ? Object.assign(id, { optional: true }) : id);
 };
 export const resolve = (_binary, args, options) => {
-    const { manifest, fromArgs, cwd, rootCwd } = options;
+    const { manifest, fromArgs, cwd, rootCwd, getManifest } = options;
     const parsed = parseArgs(args, { boolean: ['top-level'], string: ['cwd'], '--': true });
     const dir = parsed['top-level'] ? rootCwd : parsed.cwd ? join(cwd, parsed.cwd) : undefined;
     const [command, binary] = parsed._;
     if (!command && !binary)
         return [];
+    const dirManifest = (dir && getManifest(dir)) || manifest;
     const _childArgs = parsed['--'] && parsed['--'].length > 0 ? fromArgs(parsed['--'], { knownBinsOnly: true }) : [];
     if (command === 'run') {
-        if (manifest.scriptNames.has(binary))
+        if (dirManifest.scriptNames.has(binary))
             return _childArgs;
         const bin = toBinary(binary, { optional: true });
         if (dir)
@@ -70,7 +71,7 @@ export const resolve = (_binary, args, options) => {
         const argsForDlx = args.filter(arg => arg !== 'dlx');
         return resolveDlx(argsForDlx, options);
     }
-    if ((!dir && manifest.scriptNames.has(command)) || commands.includes(command))
+    if (dirManifest.scriptNames.has(command) || commands.includes(command))
         return _childArgs;
     const opts = dir ? { cwd: dir } : {};
     return fromArgs(argsFrom(args, command === 'exec' ? binary : command), opts);

package/dist/compilers/compilers.d.ts

@@ -2,10 +2,12 @@ import type { CompilerSync } from './types.ts';
 export declare const fencedCodeBlockMatcher: RegExp;
 export declare const inlineCodeMatcher: RegExp;
 export declare const scriptExtractor: RegExp;
+export declare const styleExtractor: 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;
+export declare const getStyleLang: (attrs: string) => string | undefined;
 export declare const frontmatterMatcher: RegExp;
 export declare const importsWithinFrontmatter: (text: string, keys?: string[]) => string;

package/dist/compilers/compilers.js

@@ -1,26 +1,37 @@
 export const fencedCodeBlockMatcher = /```[\s\S]*?```/g;
 export const inlineCodeMatcher = /`[^`]+`/g;
 export const scriptExtractor = /<script\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/script>/gi;
+export const styleExtractor = /<style\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/style>/gi;
+const langAttrMatcher = /\blang\s*=\s*["']([^"']+)["']/i;
 export const blockCommentMatcher = /\/\*[\s\S]*?\*\//g;
 export const lineCommentMatcher = /^[ \t]*\/\/.*$/gm;
 export const importMatcher = /import(?:\s*\(\s*['"][^'"]+['"][^)]*\)|(?!\s*\()[^'"]+['"][^'"]+['"])/g;
 export const importsWithinScripts = (text) => {
     const scripts = [];
-    for (const [, , scriptBody] of text.matchAll(scriptExtractor)) {
+    scriptExtractor.lastIndex = 0;
+    let scriptMatch;
+    while ((scriptMatch = scriptExtractor.exec(text))) {
+        const scriptBody = scriptMatch[2];
         const body = scriptBody.replace(blockCommentMatcher, '').replace(lineCommentMatcher, '');
-        for (const importMatch of body.matchAll(importMatcher))
-            scripts.push(importMatch);
+        let importMatch;
+        importMatcher.lastIndex = 0;
+        while ((importMatch = importMatcher.exec(body)))
+            scripts.push(importMatch[0]);
     }
     return scripts.join(';\n');
 };
 export const scriptBodies = (text) => {
     const scripts = [];
-    for (const [, , body] of text.matchAll(scriptExtractor)) {
+    scriptExtractor.lastIndex = 0;
+    let match;
+    while ((match = scriptExtractor.exec(text))) {
+        const body = match[2];
         if (body)
             scripts.push(body);
     }
     return scripts.join(';\n');
 };
+export const getStyleLang = (attrs) => attrs.match(langAttrMatcher)?.[1]?.toLowerCase();
 export const frontmatterMatcher = /^---\r?\n([\s\S]*?)\r?\n---/;
 export const importsWithinFrontmatter = (text, keys = []) => {
     const frontmatter = text.match(frontmatterMatcher)?.[1];

package/dist/compilers/index.d.ts

@@ -1611,5 +1611,5 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
     syncCompilers: Record<string, true | CompilerSync>;
     asyncCompilers: Record<string, CompilerAsync>;
 };
-export declare const getIncludedCompilers: (syncCompilers: RawSyncCompilers, asyncCompilers: AsyncCompilers, dependencies: DependencySet) => Compilers;
+export declare const getIncludedCompilers: (syncCompilers: RawSyncCompilers, asyncCompilers: AsyncCompilers, dependencies: DependencySet, onReferencedDependency?: (packageName: string) => void) => Compilers;
 export declare const getCompilerExtensions: (compilers: [SyncCompilers, AsyncCompilers]) => string[];

package/dist/compilers/index.js

@@ -1,5 +1,7 @@
+import LESS from './less.js';
 import MDX from './mdx.js';
 import SCSS from './scss.js';
+import STYLUS from './stylus.js';
 const isAsyncCompiler = (fn) => (fn ? fn.constructor.name === 'AsyncFunction' : false);
 export const normalizeCompilerExtension = (ext) => ext.replace(/^\.*/, '.');
 export const partitionCompilers = (rawLocalConfig) => {
@@ -26,16 +28,29 @@ export const partitionCompilers = (rawLocalConfig) => {
     }
     return { ...rawLocalConfig, syncCompilers, asyncCompilers };
 };
-const compilers = new Map([
-    ['.mdx', MDX],
-    ['.sass', SCSS],
-    ['.scss', SCSS],
-]);
-export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies) => {
-    const hasDependency = (packageName) => dependencies.has(packageName);
-    for (const [extension, { condition, compiler }] of compilers) {
-        if ((!syncCompilers.has(extension) && condition(hasDependency)) || syncCompilers.get(extension) === true) {
-            syncCompilers.set(extension, compiler);
+const compilers = [
+    { extensions: ['.mdx'], ...MDX },
+    { extensions: ['.sass', '.scss'], ...SCSS },
+    { extensions: ['.less'], ...LESS },
+    { extensions: ['.styl', '.stylus'], ...STYLUS },
+];
+export const getIncludedCompilers = (syncCompilers, asyncCompilers, dependencies, onReferencedDependency) => {
+    for (const { extensions, dependencies: compilerDependencies, compiler } of compilers) {
+        let hasCompilerDependency = false;
+        for (const dependency of compilerDependencies) {
+            if (dependencies.has(dependency)) {
+                hasCompilerDependency = true;
+                if (onReferencedDependency)
+                    onReferencedDependency(dependency);
+                else
+                    break;
+            }
+        }
+        for (const extension of extensions) {
+            const existingCompiler = syncCompilers.get(extension);
+            if (existingCompiler === true || (existingCompiler === undefined && hasCompilerDependency)) {
+                syncCompilers.set(extension, compiler);
+            }
         }
     }
     return [syncCompilers, asyncCompilers];

package/dist/compilers/less.d.ts

@@ -0,0 +1,7 @@
+import type { CompilerSync } from './types.ts';
+export declare const compiler: CompilerSync;
+declare const _default: {
+    dependencies: string[];
+    compiler: CompilerSync;
+};
+export default _default;

package/dist/compilers/less.js

@@ -0,0 +1,37 @@
+import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+const dependencies = ['less'];
+const importMatcher = /@import\s+(?:\([^)]*\)\s+)?(?:url\(\s*['"]?([^'")\s]+)['"]?\s*\)|['"]([^'"]+)['"])/g;
+const isExternalUrl = (s) => s.startsWith('//') || s.startsWith('http://') || s.startsWith('https://');
+const candidates = (specifier) => {
+    const { dir, name } = splitSpec(specifier);
+    if (name.endsWith('.less') || name.endsWith('.css'))
+        return [`${dir}/${name}`];
+    return [`${dir}/${name}.less`];
+};
+export const compiler = text => {
+    if (!text.includes('@import'))
+        return '';
+    const out = [];
+    let i = 0;
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(text))) {
+        let spec = match[1] ?? match[2];
+        if (!spec || isExternalUrl(spec))
+            continue;
+        let isBare = isScopedPackage(spec);
+        if (isTildePackage(spec)) {
+            spec = spec.slice(1);
+            isBare = true;
+        }
+        if (isBare) {
+            out.push(`import _$${i++} from '${spec}';`);
+        }
+        else {
+            for (const s of candidates(spec))
+                out.push(`import _$${i++} from '${s}';`);
+        }
+    }
+    return out.join('\n');
+};
+export default { dependencies, compiler };

package/dist/compilers/mdx.d.ts

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

package/dist/compilers/mdx.js

@@ -1,5 +1,5 @@
 import { fencedCodeBlockMatcher, frontmatterMatcher, inlineCodeMatcher } from './compilers.js';
-const mdxDependencies = [
+const dependencies = [
     '@mdx-js/esbuild',
     '@mdx-js/loader',
     '@mdx-js/mdx',
@@ -10,13 +10,19 @@ const mdxDependencies = [
     '@mdx-js/vue',
     'remark-mdx',
 ];
-const condition = (hasDependency) => mdxDependencies.some(hasDependency);
 const mdxImportMatcher = /^import[^'"]+['"][^'"]+['"]/gm;
-const compiler = (text) => [
-    ...text
+const compiler = (text) => {
+    if (!text.includes('import'))
+        return '';
+    const imports = [];
+    const source = text
         .replace(frontmatterMatcher, '')
         .replace(fencedCodeBlockMatcher, '')
-        .replace(inlineCodeMatcher, '')
-        .matchAll(mdxImportMatcher),
-].join('\n');
-export default { condition, compiler };
+        .replace(inlineCodeMatcher, '');
+    let match;
+    mdxImportMatcher.lastIndex = 0;
+    while ((match = mdxImportMatcher.exec(source)))
+        imports.push(match[0]);
+    return imports.join('\n');
+};
+export default { dependencies, compiler };

package/dist/compilers/scss.d.ts

@@ -1,6 +1,7 @@
-import type { CompilerSync, HasDependency } from './types.ts';
+import type { CompilerSync } from './types.ts';
+export declare const compiler: CompilerSync;
 declare const _default: {
-    condition: (hasDependency: HasDependency) => boolean;
+    dependencies: string[];
     compiler: CompilerSync;
 };
 export default _default;

package/dist/compilers/scss.js

@@ -1,13 +1,8 @@
-import { basename, dirname } from '../util/path.js';
-const condition = (hasDependency) => hasDependency('sass') || hasDependency('sass-embedded') || hasDependency('node-sass');
+import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+const dependencies = ['sass', 'sass-embedded', 'node-sass'];
 const importMatcher = /@(?:use|import|forward)\s+['"](pkg:)?([^'"]+)['"]/g;
-const isAlias = (s) => (s.charCodeAt(0) === 64 && s.charCodeAt(1) === 47) || s.charCodeAt(0) === 126 || s.charCodeAt(0) === 35;
-const isScopedPackage = (s) => s.charCodeAt(0) === 64 && s.charCodeAt(1) !== 47;
-const isTildePackage = (s) => s.charCodeAt(0) === 126 && s.charCodeAt(1) !== 47;
 const candidates = (specifier) => {
-    const spec = specifier.startsWith('.') || isAlias(specifier) ? specifier : `./${specifier}`;
-    const name = basename(spec);
-    const dir = dirname(spec);
+    const { dir, name } = splitSpec(specifier);
     const hasExt = name.endsWith('.scss') || name.endsWith('.sass');
     const bases = hasExt ? [name] : [`${name}.scss`, `${name}.sass`];
     const out = [];
@@ -18,10 +13,14 @@ const candidates = (specifier) => {
     }
     return out;
 };
-const compiler = text => {
+export const compiler = text => {
+    if (!text.includes('@use') && !text.includes('@import') && !text.includes('@forward'))
+        return '';
     const out = [];
     let i = 0;
-    for (const match of text.matchAll(importMatcher)) {
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(text))) {
         let spec = match[2];
         if (!spec || spec.startsWith('sass:'))
             continue;
@@ -30,10 +29,14 @@ const compiler = text => {
             spec = spec.slice(1);
             isBare = true;
         }
-        const specs = isBare ? [spec] : candidates(spec);
-        for (const s of specs)
-            out.push(`import _$${i++} from '${s}';`);
+        if (isBare) {
+            out.push(`import _$${i++} from '${spec}';`);
+        }
+        else {
+            for (const s of candidates(spec))
+                out.push(`import _$${i++} from '${s}';`);
+        }
     }
     return out.join('\n');
 };
-export default { condition, compiler };
+export default { dependencies, compiler };

package/dist/compilers/shared.d.ts

@@ -0,0 +1,6 @@
+export declare const isScopedPackage: (s: string) => boolean;
+export declare const isTildePackage: (s: string) => boolean;
+export declare const splitSpec: (specifier: string) => {
+    dir: string;
+    name: string;
+};

package/dist/compilers/shared.js

@@ -0,0 +1,9 @@
+import { basename, dirname } from '../util/path.js';
+const isAlias = (s) => (s.charCodeAt(0) === 64 && s.charCodeAt(1) === 47) || s.charCodeAt(0) === 126 || s.charCodeAt(0) === 35;
+export const isScopedPackage = (s) => s.charCodeAt(0) === 64 && s.charCodeAt(1) !== 47;
+export const isTildePackage = (s) => s.charCodeAt(0) === 126 && s.charCodeAt(1) !== 47;
+const ensureRelative = (spec) => (spec.startsWith('.') || isAlias(spec) ? spec : `./${spec}`);
+export const splitSpec = (specifier) => {
+    const spec = ensureRelative(specifier);
+    return { dir: dirname(spec), name: basename(spec) };
+};

package/dist/compilers/style-preprocessors.d.ts

@@ -0,0 +1,2 @@
+import type { CompilerSync } from './types.ts';
+export declare const stylePreprocessorImports: CompilerSync;

package/dist/compilers/style-preprocessors.js

@@ -0,0 +1,41 @@
+import { getStyleLang, styleExtractor } from './compilers.js';
+import { compiler as lessCompiler } from './less.js';
+import { compiler as scssCompiler } from './scss.js';
+import { compiler as stylusCompiler } from './stylus.js';
+export const stylePreprocessorImports = (text, path) => {
+    let scss = '';
+    let less = '';
+    let stylus = '';
+    styleExtractor.lastIndex = 0;
+    let match;
+    while ((match = styleExtractor.exec(text))) {
+        const attrs = match[1];
+        const body = match[2];
+        if (!body)
+            continue;
+        switch (getStyleLang(attrs)) {
+            case 'scss':
+            case 'sass':
+                scss = scss ? `${scss}\n${body}` : body;
+                break;
+            case 'less':
+                less = less ? `${less}\n${body}` : body;
+                break;
+            case 'styl':
+            case 'stylus':
+                stylus = stylus ? `${stylus}\n${body}` : body;
+        }
+    }
+    let out = scss ? scssCompiler(scss, path) : '';
+    if (less) {
+        const imports = lessCompiler(less, path);
+        if (imports)
+            out = out ? `${out}\n${imports}` : imports;
+    }
+    if (stylus) {
+        const imports = stylusCompiler(stylus, path);
+        if (imports)
+            out = out ? `${out}\n${imports}` : imports;
+    }
+    return out;
+};

package/dist/compilers/stylus.d.ts

@@ -0,0 +1,7 @@
+import type { CompilerSync } from './types.ts';
+export declare const compiler: CompilerSync;
+declare const _default: {
+    dependencies: string[];
+    compiler: CompilerSync;
+};
+export default _default;

package/dist/compilers/stylus.js

@@ -0,0 +1,36 @@
+import { isScopedPackage, isTildePackage, splitSpec } from './shared.js';
+const dependencies = ['stylus'];
+const importMatcher = /@(?:import|require)\s+['"]([^'"]+)['"]/g;
+const candidates = (specifier) => {
+    const { dir, name } = splitSpec(specifier);
+    if (name.endsWith('.styl') || name.endsWith('.stylus') || name.endsWith('.css'))
+        return [`${dir}/${name}`];
+    return [`${dir}/${name}.styl`, `${dir}/${name}/index.styl`];
+};
+export const compiler = text => {
+    if (!text.includes('@import') && !text.includes('@require'))
+        return '';
+    const out = [];
+    let i = 0;
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(text))) {
+        let spec = match[1];
+        if (!spec || spec.includes('*'))
+            continue;
+        let isBare = isScopedPackage(spec);
+        if (isTildePackage(spec)) {
+            spec = spec.slice(1);
+            isBare = true;
+        }
+        if (isBare) {
+            out.push(`import _$${i++} from '${spec}';`);
+        }
+        else {
+            for (const s of candidates(spec))
+                out.push(`import _$${i++} from '${s}';`);
+        }
+    }
+    return out.join('\n');
+};
+export default { dependencies, compiler };

package/dist/constants.js

@@ -155,6 +155,8 @@ export const FOREIGN_FILE_EXTENSIONS = new Set([
     '.sass',
     '.scss',
     '.sh',
+    '.styl',
+    '.stylus',
     '.svg',
     '.ttf',
     '.webp',

package/dist/graph/build.js

@@ -28,6 +28,17 @@ export async function build({ chief, collector, counselor, deputy, principal, is
     const handleInput = createInputHandler(deputy, chief, isGitIgnored, addIssue, externalRefsFromInputs, options);
     const rawRootManifest = chief.getManifestForWorkspace('.');
     const rootManifest = rawRootManifest ? createManifest(rawRootManifest) : undefined;
+    const manifestsByWorkspaceName = new Map();
+    const getManifest = (dir) => {
+        const workspace = chief.findWorkspaceByFilePath(`${dir}/`);
+        if (!workspace)
+            return undefined;
+        if (!manifestsByWorkspaceName.has(workspace.name)) {
+            const raw = chief.getManifestForWorkspace(workspace.name);
+            manifestsByWorkspaceName.set(workspace.name, raw ? createManifest(raw) : undefined);
+        }
+        return manifestsByWorkspaceName.get(workspace.name);
+    };
     for (const workspace of workspaces) {
         const { name, dir, manifestPath, manifestStr } = workspace;
         const manifest = chief.getManifestForWorkspace(name);
@@ -70,6 +81,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             rootManifest,
             handleInput: (input) => handleInput(input, workspace),
             findWorkspaceByFilePath: chief.findWorkspaceByFilePath.bind(chief),
+            getManifest,
             negatedWorkspacePatterns: chief.getNegatedWorkspacePatterns(name),
             ignoredWorkspacePatterns: chief.getIgnoredWorkspacesFor(name),
             enabledPluginsInAncestors: ancestors.flatMap(ancestor => enabledPluginsStore.get(ancestor) ?? []),
@@ -78,7 +90,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             options,
         });
         await worker.init();
-        const compilers = getIncludedCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, dependencies);
+        const compilers = getIncludedCompilers(chief.config.syncCompilers, chief.config.asyncCompilers, dependencies, dep => deputy.addReferencedDependency(name, dep));
         const registerCompiler = async ({ extension, compiler }) => {
             const ext = normalizeCompilerExtension(extension);
             if (compilers[0].has(ext))
@@ -359,6 +371,7 @@ export async function build({ chief, collector, counselor, deputy, principal, is
                     dependencies,
                     manifest: createManifest(manifest),
                     rootManifest,
+                    getManifest,
                 };
                 const inputs = _getInputsFromScripts(file.scripts, opts);
                 for (const input of inputs) {

package/dist/plugins/astro/compiler-mdx.js

@@ -1,8 +1,17 @@
 import { fencedCodeBlockMatcher, importMatcher, importsWithinFrontmatter, inlineCodeMatcher, } from '../../compilers/compilers.js';
 const frontmatterImportFields = ['layout'];
 const compiler = (text) => {
-    const imports = text.replace(fencedCodeBlockMatcher, '').replace(inlineCodeMatcher, '').matchAll(importMatcher);
     const frontmatterImports = importsWithinFrontmatter(text, frontmatterImportFields);
-    return [...imports, frontmatterImports].join('\n');
+    if (!text.includes('import'))
+        return frontmatterImports;
+    const imports = [];
+    const source = text.replace(fencedCodeBlockMatcher, '').replace(inlineCodeMatcher, '');
+    let match;
+    importMatcher.lastIndex = 0;
+    while ((match = importMatcher.exec(source)))
+        imports.push(match[0]);
+    if (frontmatterImports)
+        imports.push(frontmatterImports);
+    return imports.join('\n');
 };
 export default compiler;

package/dist/plugins/astro/compiler.js

@@ -1,17 +1,21 @@
 import { frontmatterMatcher, scriptBodies } from '../../compilers/compilers.js';
+import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
 const propsDeclMatcher = /(?:^|[\s;])(?:interface|type)\s+Props\b/;
 const compiler = (text, path) => {
-    const scripts = [];
+    let out = '';
     const frontmatter = text.match(frontmatterMatcher);
     if (frontmatter?.[1]) {
         let fm = frontmatter[1];
         if (propsDeclMatcher.test(fm) && text.includes('Astro.props'))
             fm += '\ntype __knip_astro_props = Props;';
-        scripts.push(fm);
+        out = fm;
     }
     const scriptContent = scriptBodies(text, path);
     if (scriptContent)
-        scripts.push(scriptContent);
-    return scripts.join('\n');
+        out = out ? `${out}\n${scriptContent}` : scriptContent;
+    const styleImports = stylePreprocessorImports(text, path);
+    if (styleImports)
+        out = out ? `${out}\n${styleImports}` : styleImports;
+    return out;
 };
 export default compiler;

package/dist/plugins/github-actions/index.js

@@ -18,7 +18,7 @@ export const getActionDependencies = (config, options) => {
     return scripts.map(script => join(configFileDir, script));
 };
 const resolveConfig = async (config, options) => {
-    const { rootCwd, getInputsFromScripts, isProduction } = options;
+    const { rootCwd, getInputsFromScripts, isProduction, getManifest } = options;
     const inputs = new Set();
     const jobs = findByKeyDeep(config, 'steps');
     for (const steps of jobs) {
@@ -30,7 +30,8 @@ const resolveConfig = async (config, options) => {
             const workingDir = step['working-directory'];
             const dir = join(rootCwd, path && workingDir ? relative(workingDir, path) : workingDir ? workingDir : '.');
             if (step.run) {
-                for (const input of getInputsFromScripts([step.run], { knownBinsOnly: true })) {
+                const manifest = getManifest(dir) ?? options.manifest;
+                for (const input of getInputsFromScripts([step.run], { knownBinsOnly: true, manifest })) {
                     if (isDeferResolveEntry(input) && path && !workingDir) {
                         input.specifier = relative(join(dir, path), join(rootCwd, input.specifier));
                     }

package/dist/plugins/nuxt/index.js

@@ -82,10 +82,12 @@ const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
                 if (store)
                     store.push(...components);
                 else
-                    componentMap.set(id, [...components]);
+                    componentMap.set(id, components);
             }
         }
         const getSyntheticImports = (identifiers, templateTags) => {
+            if (importMap.size === 0 && (!templateTags || componentMap.size === 0))
+                return [];
             const syntheticImports = [];
             for (const [name, specifier] of importMap) {
                 if (identifiers.has(name))
@@ -113,7 +115,7 @@ const registerCompilers = async ({ cwd, hasDependency, registerCompiler }) => {
                 scripts.push(descriptor.script.content);
             if (descriptor.scriptSetup?.content)
                 scripts.push(descriptor.scriptSetup.content);
-            const identifiers = collectIdentifiers(scripts.join('\n'), path);
+            const identifiers = scripts.length === 0 ? new Set() : collectIdentifiers(scripts.join('\n'), path);
             let templateTags;
             if (descriptor.template?.ast) {
                 const info = collectTemplateInfo(descriptor.template.ast);

package/dist/plugins/prisma/compiler.js

@@ -1,7 +1,10 @@
 const directiveMatcher = /generator\s+(?!client)\w+\s*\{\s*provider\s*=\s*"([^"]+)"[^}]*\}/g;
 const compiler = (text) => {
+    if (!text.includes('generator'))
+        return '';
     const imports = [];
     let match;
+    directiveMatcher.lastIndex = 0;
     while ((match = directiveMatcher.exec(text))) {
         if (match[1]) {
             imports.push(`import '${match[1]}';`);

package/dist/plugins/stencil/index.js

@@ -1,6 +1,10 @@
+import { Visitor } from 'oxc-parser';
+import scss from '../../compilers/scss.js';
+import { IMPORT_FLAGS } from '../../constants.js';
 import { toConfig, toEntry, toProductionEntry } from '../../util/input.js';
+import { dirname, join } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
-import { collectPropertyValues } from '../../typescript/ast-helpers.js';
+import { collectPropertyValues, getPropertyValues } from '../../typescript/ast-helpers.js';
 import { createCustomElementVisitor } from '../_custom-elements/custom-element-visitor.js';
 const title = 'Stencil';
 const enablers = ['@stencil/core'];
@@ -9,8 +13,49 @@ const config = ['stencil.config.{ts,js}'];
 const production = ['src/**/*.tsx'];
 const entry = ['**/*.spec.{ts,tsx}', '**/*.e2e.{ts,tsx}'];
 const isStencilSpecifier = (specifier) => specifier === '@stencil/core';
+const registerCompilers = ({ hasDependency, registerCompiler }) => {
+    if (hasDependency('@stencil/sass'))
+        for (const ext of ['.scss', '.sass'])
+            registerCompiler({ extension: ext, compiler: scss.compiler });
+};
 const registerVisitors = ({ ctx, registerVisitor }) => {
     registerVisitor(createCustomElementVisitor(ctx, isStencilSpecifier, { decoratorName: 'Component' }));
+    const componentNames = new Set();
+    registerVisitor({
+        Program() {
+            componentNames.clear();
+        },
+        ImportDeclaration(node) {
+            if (!isStencilSpecifier(node.source?.value))
+                return;
+            for (const spec of node.specifiers ?? []) {
+                if (spec.type === 'ImportSpecifier' &&
+                    spec.imported.type === 'Identifier' &&
+                    spec.imported.name === 'Component')
+                    componentNames.add(spec.local.name);
+            }
+        },
+        ClassDeclaration(node) {
+            resolveStyleUrls(node);
+        },
+    });
+    function resolveStyleUrls(node) {
+        const dir = dirname(ctx.filePath);
+        for (const decorator of node.decorators ?? []) {
+            const expr = decorator.expression;
+            if (expr?.type !== 'CallExpression')
+                continue;
+            if (expr.callee?.type !== 'Identifier' || !componentNames.has(expr.callee.name))
+                continue;
+            const arg = expr.arguments?.[0];
+            if (arg?.type !== 'ObjectExpression')
+                continue;
+            for (const url of getPropertyValues(arg, 'styleUrl'))
+                ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
+            for (const url of getPropertyValues(arg, 'styleUrls'))
+                ctx.addImport(join(dir, url), arg.start, IMPORT_FLAGS.NONE);
+        }
+    }
 };
 const resolveFromAST = program => {
     const inputs = [];
@@ -22,6 +67,18 @@ const resolveFromAST = program => {
     for (const script of collectPropertyValues(program, 'globalScript')) {
         inputs.push(toProductionEntry(script));
     }
+    for (const style of collectPropertyValues(program, 'globalStyle')) {
+        inputs.push(toProductionEntry(style));
+    }
+    new Visitor({
+        ObjectExpression(node) {
+            const typeValues = getPropertyValues(node, 'type');
+            if (!typeValues.has('global-style'))
+                return;
+            for (const input of getPropertyValues(node, 'input'))
+                inputs.push(toProductionEntry(input));
+        },
+    }).visit(program);
     for (const tsconfig of collectPropertyValues(program, 'tsconfig')) {
         inputs.push(toConfig('typescript', tsconfig));
     }
@@ -41,6 +98,7 @@ const plugin = {
     entry,
     production,
     resolveFromAST,
+    registerCompilers,
     registerVisitors,
 };
 export default plugin;

package/dist/plugins/svelte/compiler.d.ts

@@ -1,2 +1,3 @@
-declare const compiler: import("../../compilers/types.ts").CompilerSync;
+import type { CompilerSync } from '../../compilers/types.ts';
+declare const compiler: CompilerSync;
 export default compiler;

package/dist/plugins/svelte/compiler.js

@@ -1,3 +1,10 @@
 import { importsWithinScripts } from '../../compilers/compilers.js';
-const compiler = importsWithinScripts;
+import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
+const compiler = (text, path) => {
+    const scripts = importsWithinScripts(text, path);
+    const styles = stylePreprocessorImports(text, path);
+    if (!scripts)
+        return styles;
+    return styles ? `${scripts};\n${styles}` : scripts;
+};
 export default compiler;

package/dist/plugins/tailwind/compiler.js

@@ -1,8 +1,11 @@
 const directiveMatcher = /@(?:import|config|plugin)\s+['"]([^'"]+)['"][^;]*;/g;
 const compiler = (text) => {
+    if (!text.includes('@import') && !text.includes('@config') && !text.includes('@plugin'))
+        return '';
     const imports = [];
     let match;
     let index = 0;
+    directiveMatcher.lastIndex = 0;
     while ((match = directiveMatcher.exec(text)))
         if (match[1])
             imports.push(`import _$${index++} from '${match[1]}';`);

package/dist/plugins/tailwind/index.js

@@ -5,8 +5,12 @@ const enablers = ['tailwindcss', '@tailwindcss/vite', '@tailwindcss/postcss', '@
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
 const entry = ['tailwind.config.{js,cjs,mjs,ts,cts,mts}'];
 const registerCompilers = ({ registerCompiler, hasDependency }) => {
-    if (enablers.some(enabler => hasDependency(enabler)))
+    for (const enabler of enablers) {
+        if (!hasDependency(enabler))
+            continue;
         registerCompiler({ extension: '.css', compiler });
+        break;
+    }
 };
 const plugin = {
     title,

package/dist/plugins/vue/compiler.d.ts

@@ -1,2 +1,3 @@
-declare const compiler: import("../../compilers/types.ts").CompilerSync;
+import type { CompilerSync } from '../../compilers/types.ts';
+declare const compiler: CompilerSync;
 export default compiler;

package/dist/plugins/vue/compiler.js

@@ -1,3 +1,10 @@
 import { scriptBodies } from '../../compilers/compilers.js';
-const compiler = scriptBodies;
+import { stylePreprocessorImports } from '../../compilers/style-preprocessors.js';
+const compiler = (text, path) => {
+    const scripts = scriptBodies(text, path);
+    const styles = stylePreprocessorImports(text, path);
+    if (!scripts)
+        return styles;
+    return styles ? `${scripts};\n${styles}` : scripts;
+};
 export default compiler;

package/dist/reporters/compact.js

@@ -5,11 +5,10 @@ const logIssueRecord = (issues, cwd) => {
         console.log(getIssueLine(issue, cwd));
 };
 export default ({ report, issues, isShowProgress, cwd }) => {
-    const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
     for (const [reportType, isReportType] of Object.entries(report)) {
         if (isReportType) {
-            const title = reportMultipleGroups && getIssueTypeTitle(reportType);
+            const title = getIssueTypeTitle(reportType);
             const issuesForType = reportType === 'duplicates'
                 ? flattenIssues(issues[reportType])
                 : Object.values(issues[reportType])

package/dist/reporters/symbols.js

@@ -2,11 +2,10 @@ import { printConfigurationHints, printTagHints } from './util/configuration-hin
 import { dim, flattenIssues, getColoredTitle, getIssueTypeTitle, getTableForType } from './util/util.js';
 export default (options) => {
     const { report, issues, isDisableConfigHints, isDisableTagHints, isShowProgress } = options;
-    const reportMultipleGroups = Object.values(report).filter(Boolean).length > 1;
     let totalIssues = 0;
     for (const [reportType, isReportType] of Object.entries(report)) {
         if (isReportType) {
-            const title = reportMultipleGroups && getIssueTypeTitle(reportType);
+            const title = getIssueTypeTitle(reportType);
             const issuesForType = flattenIssues(issues[reportType]);
             if (issuesForType.length > 0) {
                 title && console.log(getColoredTitle(title, issuesForType.length));

package/dist/types/config.d.ts

@@ -76,6 +76,7 @@ interface BaseOptions {
     cwd: string;
     manifest: Manifest;
     rootManifest: Manifest | undefined;
+    getManifest: (dir: string) => Manifest | undefined;
 }
 type IsPluginEnabledOptions = {
     cwd: string;

package/dist/types.d.ts

@@ -1,3 +1,3 @@
 export type { RawConfigurationOrFn as KnipConfig, RawConfiguration as KnipConfiguration, WorkspaceProjectConfig, } from './types/config.ts';
-export type { Preprocessor, Reporter, ReporterOptions } from './types/issues.ts';
+export type { Issue, IssueRecords, IssueType, Preprocessor, Reporter, ReporterOptions } from './types/issues.ts';
 export type { JSONReport, JSONReportEntry, JSONReportItem, JSONReportNamedItem } from './reporters/json.ts';

package/dist/typescript/SourceFileManager.js

@@ -11,8 +11,9 @@ export class SourceFileManager {
         this.asyncCompilers = compilers[1];
     }
     readFile(filePath) {
-        if (this.sourceTextCache.has(filePath))
-            return this.sourceTextCache.get(filePath);
+        const cachedSourceText = this.sourceTextCache.get(filePath);
+        if (cachedSourceText !== undefined)
+            return cachedSourceText;
         const ext = extname(filePath);
         const compiler = this.syncCompilers.get(ext);
         if (FOREIGN_FILE_EXTENSIONS.has(ext) && !compiler) {

package/dist/typescript/ast-nodes.d.ts

@@ -19,4 +19,5 @@ export declare const getStringValue: (node: any) => string | undefined;
 export declare const getSafeScriptFromArgs: (executable: any, argsArray: any) => string | undefined;
 export declare const shouldCountRefs: (ignoreExportsUsedInFile: IgnoreExportsUsedInFile, type: SymbolType) => boolean | undefined;
 export declare function extractNamespaceMembers(decl: TSModuleDeclaration, options: GetImportsAndExportsOptions, lineStarts: number[], getJSDocTags: (start: number) => Set<string>, prefix?: string): ExportMember[];
+export declare const collectAugmentationRefs: (node: TSModuleDeclaration) => string[];
 export declare function extractEnumMembers(decl: TSEnumDeclaration, options: GetImportsAndExportsOptions, lineStarts: number[], getJSDocTags: (start: number) => Set<string>): ExportMember[];

package/dist/typescript/ast-nodes.js

@@ -1,4 +1,4 @@
-import { parseSync, rawTransferSupported, } from 'oxc-parser';
+import { parseSync, rawTransferSupported, visitorKeys, } from 'oxc-parser';
 import { DEFAULT_EXTENSIONS, FIX_FLAGS, SYMBOL_TYPE } from '../constants.js';
 import { extname } from '../util/path.js';
 import { timerify } from '../util/Performance.js';
@@ -131,6 +131,56 @@ export function extractNamespaceMembers(decl, options, lineStarts, getJSDocTags,
     }
     return members;
 }
+export const collectAugmentationRefs = (node) => {
+    if (!node.body || node.body.type !== 'TSModuleBlock')
+        return [];
+    const body = node.body.body;
+    const declared = new Set();
+    for (const stmt of body) {
+        const decl = stmt.type === 'ExportNamedDeclaration' && stmt.declaration ? stmt.declaration : stmt;
+        if ('id' in decl && decl.id?.type === 'Identifier')
+            declared.add(decl.id.name);
+        else if (decl.type === 'VariableDeclaration')
+            for (const d of decl.declarations)
+                if (d.id.type === 'Identifier')
+                    declared.add(d.id.name);
+    }
+    const refs = [];
+    const seen = new Set();
+    const add = (ref) => {
+        if (ref?.type === 'Identifier' && !declared.has(ref.name) && !seen.has(ref.name)) {
+            seen.add(ref.name);
+            refs.push(ref.name);
+        }
+    };
+    const visit = (n) => {
+        const type = n?.type;
+        if (!type)
+            return;
+        if (type === 'TSTypeReference')
+            add(n.typeName);
+        else if (type === 'TSInterfaceHeritage')
+            add(n.expression);
+        const keys = visitorKeys[type];
+        if (!keys)
+            return;
+        for (const key of keys) {
+            const val = n[key];
+            if (!val)
+                continue;
+            if (Array.isArray(val)) {
+                for (const item of val)
+                    if (item)
+                        visit(item);
+            }
+            else
+                visit(val);
+        }
+    };
+    for (const stmt of body)
+        visit(stmt);
+    return refs;
+};
 export function extractEnumMembers(decl, options, lineStarts, getJSDocTags) {
     if (!decl.body?.members)
         return [];

package/dist/typescript/comments.js

@@ -1,6 +1,7 @@
 import { IMPORT_FLAGS } from '../constants.js';
 const jsDocImportRe = /import\(\s*['"]([^'"]+)['"]\s*\)(?:\.(\w+))?/g;
 const jsDocImportTagRe = /@import\s+(?:\{[^}]*\}|\*\s+as\s+\w+)\s+from\s+['"]([^'"]+)['"]/g;
+const jsDocTypeTagRe = /@(?:type|typedef|callback|param|arg|argument|property|prop|returns?|yields?|throws?|exception|this|extends|augments|implements|enum|template|satisfies|const|constant|member|var|namespace|module)\b/;
 const jsxImportSourceRe = /@jsxImportSource\s+(\S+)/;
 const referenceRe = /\s*<reference\s+(types|path)\s*=\s*"([^"]+)"[^/]*\/>/;
 const envPragmaRe = /@(vitest|jest)-environment\s+([@\w./-]+)/g;
@@ -18,6 +19,26 @@ const resolveEnvironmentPragma = (tool, value) => {
         return '@edge-runtime/vm';
     return value;
 };
+const isInJsDocTypeExpression = (text, index) => {
+    let depth = 0;
+    for (let pos = index - 1; pos >= 0; pos--) {
+        const char = text.charCodeAt(pos);
+        if (char === 125) {
+            depth++;
+        }
+        else if (char === 123) {
+            if (depth > 0) {
+                depth--;
+            }
+            else {
+                const line = text.slice(text.lastIndexOf('\n', pos - 1) + 1, pos);
+                if (jsDocTypeTagRe.test(line))
+                    return true;
+            }
+        }
+    }
+    return false;
+};
 export const extractImportsFromComments = (comments, firstStmtStart, addImport) => {
     for (const comment of comments) {
         const text = comment.value;
@@ -25,9 +46,7 @@ export const extractImportsFromComments = (comments, firstStmtStart, addImport)
         if (comment.type === 'Block') {
             jsDocImportRe.lastIndex = 0;
             while ((results = jsDocImportRe.exec(text)) !== null) {
-                const before = text.slice(0, results.index);
-                const lastOpen = before.lastIndexOf('{');
-                if (lastOpen === -1 || before.indexOf('}', lastOpen) !== -1)
+                if (!isInJsDocTypeExpression(text, results.index))
                     continue;
                 const specifier = results[1];
                 const member = results[2];

package/dist/typescript/visitors/walk.js

@@ -3,7 +3,7 @@ import { FIX_FLAGS, IMPORT_FLAGS, OPAQUE, SYMBOL_TYPE } from '../../constants.js
 import { addValue } from '../../util/module-graph.js';
 import { isInNodeModules } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
-import { getLineAndCol, getStringValue, isStringLiteral } from '../ast-nodes.js';
+import { collectAugmentationRefs, getLineAndCol, getStringValue, isStringLiteral, } from '../ast-nodes.js';
 import { EMPTY_TAGS } from './jsdoc.js';
 import { handleCallExpression, handleNewExpression, trackCustomElementRegistry } from './calls.js';
 import { handleExportAssignment, handleExportDefault, handleExportNamed, handleExpressionStatement, } from './exports.js';
@@ -211,6 +211,12 @@ const coreVisitorObject = {
     },
     TSModuleDeclaration(node) {
         state.nsRanges.push([node.start, node.end]);
+        if (node.kind !== 'global' && isStringLiteral(node.id)) {
+            const specifier = getStringValue(node.id);
+            if (specifier.startsWith('.'))
+                for (const name of collectAugmentationRefs(node))
+                    state.addImport(specifier, name, undefined, undefined, node.id.start, IMPORT_FLAGS.TYPE_ONLY);
+        }
     },
     ClassDeclaration(node) {
         state.classNameStack.push(node.id?.name ?? '');

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.23.0";
+export declare const version = "6.24.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.23.0';
+export const version = '6.24.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.23.0",
+  "version": "6.24.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",