knip 6.5.0 → 6.6.0

package/dist/ConfigurationChief.d.ts

@@ -1,4 +1,4 @@
-import type { Configuration, IgnorePatterns, RawConfiguration, WorkspaceConfiguration } from './types/config.ts';
+import type { Configuration, IgnorePatterns, RawConfiguration, SourceMap, WorkspaceConfiguration } from './types/config.ts';
 import type { ConfigurationHint } from './types/issues.ts';
 import type { WorkspacePackage } from './types/package-json.ts';
 import type { MainOptions } from './util/create-options.ts';
@@ -14,8 +14,7 @@ export type Workspace = {
     manifestPath: string;
     manifestStr: string;
     ignoreMembers: IgnorePatterns;
-    srcDir?: string;
-    outDir?: string;
+    sourceMaps?: SourceMap[];
 };
 export declare class ConfigurationChief {
     cwd: string;
@@ -637,6 +636,11 @@ export declare class ConfigurationChief {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'sveltejs-package'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         sveltekit?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -931,6 +935,7 @@ export declare class ConfigurationChief {
         stryker?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         stylelint?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         svelte?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
+        "sveltejs-package"?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         sveltekit?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         svgo?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;
         svgr?: (boolean | import("./types/config.ts").EnsuredPluginConfiguration) | undefined;

package/dist/WorkspaceWorker.d.ts

@@ -1,6 +1,6 @@
 import { CacheConsultant } from './CacheConsultant.ts';
 import { type Workspace } from './ConfigurationChief.ts';
-import type { HandleInput, RegisterCompiler, RegisterVisitorsOptions, WorkspaceConfiguration } from './types/config.ts';
+import type { HandleInput, RegisterCompiler, RegisterVisitorsOptions, SourceMap, WorkspaceConfiguration } from './types/config.ts';
 import type { ConfigurationHint } from './types/issues.ts';
 import type { PluginName } from './types/PluginNames.ts';
 import type { PackageJson } from './types/package-json.ts';
@@ -60,6 +60,7 @@ export declare class WorkspaceWorker {
     getProductionProjectFilePatterns(negatedTestFilePatterns: string[]): string[];
     private getConfigurationFilePatterns;
     registerCompilers(registerCompiler: RegisterCompiler): Promise<void>;
+    resolveSourceMaps(): Promise<SourceMap[]>;
     registerVisitors(options: RegisterVisitorsOptions): void;
     runPlugins(): Promise<Input[]>;
     private filterTransitiveDependencies;

package/dist/WorkspaceWorker.js

@@ -170,6 +170,24 @@ export class WorkspaceWorker {
             await plugin.registerCompilers({ cwd, hasDependency, registerCompiler });
         }
     }
+    async resolveSourceMaps() {
+        const options = {
+            cwd: this.dir,
+            rootCwd: this.options.cwd,
+            manifest: this.manifest,
+            rootManifest: this.rootManifest,
+            dependencies: this.dependencies,
+        };
+        const pairs = [];
+        for (const pluginName of this.enabledPlugins) {
+            const plugin = Plugins[pluginName];
+            if (!plugin.resolveSourceMap)
+                continue;
+            for (const pair of await plugin.resolveSourceMap(options))
+                pairs.push(pair);
+        }
+        return pairs;
+    }
     registerVisitors(options) {
         for (const pluginName of this.enabledPlugins) {
             if (options.registeredPlugins.has(pluginName))

package/dist/compilers/index.d.ts

@@ -583,6 +583,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
         entry?: string | string[] | undefined;
         project?: string | string[] | undefined;
     } | undefined;
+    'sveltejs-package'?: string | boolean | string[] | {
+        config?: string | string[] | undefined;
+        entry?: string | string[] | undefined;
+        project?: string | string[] | undefined;
+    } | undefined;
     sveltekit?: string | boolean | string[] | {
         config?: string | string[] | undefined;
         entry?: string | string[] | undefined;
@@ -1339,6 +1344,11 @@ export declare const partitionCompilers: (rawLocalConfig: RawConfiguration) => {
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'sveltejs-package'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         sveltekit?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;

package/dist/graph/build.js

@@ -14,7 +14,7 @@ import { getPackageNameFromModuleSpecifier, isStartsLikePackageName, sanitizeSpe
 import { perfObserver } from '../util/Performance.js';
 import { getEntrySpecifiersFromManifest, getManifestImportDependencies } from '../util/package-json.js';
 import { dirname, extname, isAbsolute, isInNodeModules, join, relative } from '../util/path.js';
-import { augmentWorkspace, getToSourcePathsHandler } from '../util/to-source-path.js';
+import { augmentWorkspace, getToSourcePathsHandler, toSourceMappedSpecifiers } from '../util/to-source-path.js';
 import { WorkspaceWorker } from '../WorkspaceWorker.js';
 export async function build({ chief, collector, counselor, deputy, principal, isGitIgnored, streamer, workspaces, options, }) {
     const configFilesMap = new Map();
@@ -57,8 +57,6 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         const tsConfigFilePath = join(dir, options.tsConfigFile ?? 'tsconfig.json');
         const { isFile, compilerOptions, fileNames } = await loadTSConfig(tsConfigFilePath);
         const [definitionPaths, tscSourcePaths] = partition(fileNames, filePath => IS_DTS.test(filePath));
-        if (isFile)
-            augmentWorkspace(workspace, dir, compilerOptions);
         const worker = new WorkspaceWorker({
             name,
             dir,
@@ -89,6 +87,8 @@ export async function build({ chief, collector, counselor, deputy, principal, is
         const extensionGlobStr = `.{${[...DEFAULT_EXTENSIONS, ...extensions].map(ext => ext.slice(1)).join(',')}}`;
         const config = chief.getConfigForWorkspace(name, extensions);
         worker.config = config;
+        const pluginSourceMaps = await worker.resolveSourceMaps();
+        augmentWorkspace(workspace, dir, isFile ? compilerOptions : undefined, pluginSourceMaps);
         const inputs = new Set();
         if (definitionPaths.length > 0) {
             debugLogArray(name, 'Definition paths', definitionPaths);
@@ -105,13 +105,21 @@ export async function build({ chief, collector, counselor, deputy, principal, is
             inputs.add(toProductionEntry(filePath));
         }
         for (const identifier of entrySpecifiersFromManifest) {
-            if (!identifier.startsWith('!') && !isGitIgnored(join(dir, identifier))) {
-                const exists = identifier.includes('*')
-                    ? _syncGlob({ patterns: [identifier], cwd: dir }).length > 0
-                    : existsSync(join(dir, identifier));
-                if (!exists) {
-                    collector.addConfigurationHint({ type: 'package-entry', filePath, identifier, workspaceName: name });
-                }
+            if (identifier.startsWith('!') || isGitIgnored(join(dir, identifier)))
+                continue;
+            if (!identifier.startsWith('.') && !identifier.startsWith('/')) {
+                const packageName = getPackageNameFromModuleSpecifier(identifier);
+                if (packageName && dependencies.has(packageName))
+                    continue;
+            }
+            const abs = prependDir(dir, identifier);
+            const mapped = toSourceMappedSpecifiers(workspace, abs, extensionGlobStr);
+            const hasWildcard = identifier.includes('*');
+            const exists = hasWildcard
+                ? _syncGlob({ patterns: [identifier, ...mapped], cwd: dir }).length > 0
+                : existsSync(abs) || mapped.some(pattern => _syncGlob({ patterns: [pattern], cwd: dir }).length > 0);
+            if (!exists) {
+                collector.addConfigurationHint({ type: 'package-entry', filePath, identifier, workspaceName: name });
             }
         }
         for (const dep of getManifestImportDependencies(manifest))

package/dist/plugins/astro/index.js

@@ -1,8 +1,9 @@
 import { toDependency, toEntry, toProductionEntry } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
+import { getAliasInputs } from '../vitest/helpers.js';
 import compiler from './compiler.js';
 import mdxCompiler from './compiler-mdx.js';
-import { getSrcDir, usesPassthroughImageService } from './resolveFromAST.js';
+import { getSrcDir, getViteAliases, usesPassthroughImageService } from './resolveFromAST.js';
 const title = 'Astro';
 const enablers = ['astro'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -16,12 +17,13 @@ const production = [
     'src/middleware.{js,ts}',
     'src/actions/index.{js,ts}',
 ];
-const resolveFromAST = program => {
+const resolveFromAST = (program, options) => {
     const srcDir = getSrcDir(program);
     const setSrcDir = (entry) => entry.replace(/^src\//, `${srcDir}/`);
     const inputs = [
         ...entry.map(setSrcDir).map(path => toEntry(path)),
         ...production.map(setSrcDir).map(path => toProductionEntry(path)),
+        ...getAliasInputs(getViteAliases(program), options.cwd),
     ];
     if (!usesPassthroughImageService(program))
         inputs.push(toDependency('sharp', { optional: true }));

package/dist/plugins/astro/resolveFromAST.d.ts

@@ -1,3 +1,4 @@
 import type { Program } from 'oxc-parser';
 export declare const getSrcDir: (program: Program) => string;
 export declare const usesPassthroughImageService: (program: Program) => boolean;
+export declare const getViteAliases: (program: Program) => Record<string, string>;

package/dist/plugins/astro/resolveFromAST.js

@@ -1,6 +1,45 @@
-import { collectPropertyValues, hasImportSpecifier } from '../../typescript/ast-helpers.js';
+import { collectPropertyValues, findProperty, getPropertyKey, getStringValue, hasImportSpecifier, } from '../../typescript/ast-helpers.js';
 export const getSrcDir = (program) => {
     const values = collectPropertyValues(program, 'srcDir');
     return values.size > 0 ? Array.from(values)[0] : 'src';
 };
 export const usesPassthroughImageService = (program) => hasImportSpecifier(program, 'astro/config', 'passthroughImageService');
+const findFirstStringArg = (node) => {
+    const literal = getStringValue(node);
+    if (literal)
+        return literal;
+    if (node?.type === 'CallExpression' || node?.type === 'NewExpression') {
+        for (const arg of node.arguments ?? []) {
+            const found = findFirstStringArg(arg);
+            if (found)
+                return found;
+        }
+    }
+};
+export const getViteAliases = (program) => {
+    const aliases = {};
+    for (const node of program.body ?? []) {
+        if (node.type !== 'ExportDefaultDeclaration')
+            continue;
+        const decl = node.declaration;
+        const root = decl?.type === 'ObjectExpression'
+            ? decl
+            : decl?.type === 'CallExpression' && decl.arguments?.[0]?.type === 'ObjectExpression'
+                ? decl.arguments[0]
+                : undefined;
+        const aliasNode = findProperty(findProperty(findProperty(root, 'vite'), 'resolve'), 'alias');
+        if (aliasNode?.type !== 'ObjectExpression')
+            continue;
+        for (const prop of aliasNode.properties ?? []) {
+            if (prop.type !== 'Property')
+                continue;
+            const key = getPropertyKey(prop);
+            if (!key)
+                continue;
+            const raw = findFirstStringArg(prop.value);
+            if (raw)
+                aliases[key] = raw;
+        }
+    }
+    return aliases;
+};

package/dist/plugins/index.d.ts

@@ -120,6 +120,7 @@ export declare const Plugins: {
     stryker: import("../types/config.ts").Plugin;
     stylelint: import("../types/config.ts").Plugin;
     svelte: import("../types/config.ts").Plugin;
+    'sveltejs-package': import("../types/config.ts").Plugin;
     sveltekit: import("../types/config.ts").Plugin;
     svgo: import("../types/config.ts").Plugin;
     svgr: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -114,6 +114,7 @@ import { default as storybook } from './storybook/index.js';
 import { default as stryker } from './stryker/index.js';
 import { default as stylelint } from './stylelint/index.js';
 import { default as svelte } from './svelte/index.js';
+import { default as sveltejsPackage } from './sveltejs-package/index.js';
 import { default as sveltekit } from './sveltekit/index.js';
 import { default as svgo } from './svgo/index.js';
 import { default as svgr } from './svgr/index.js';
@@ -262,6 +263,7 @@ export const Plugins = {
     stryker,
     stylelint,
     svelte,
+    'sveltejs-package': sveltejsPackage,
     sveltekit,
     svgo,
     svgr,

package/dist/plugins/sveltejs-package/helpers.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_INPUT = "src/lib";
+export declare const DEFAULT_OUTPUT = "dist";
+interface IO {
+    input: string;
+    output: string;
+}
+export declare const parseScripts: (scripts: Record<string, string | undefined> | undefined) => IO[];
+export {};

package/dist/plugins/sveltejs-package/helpers.js

@@ -0,0 +1,65 @@
+import parseArgs from 'minimist';
+import { parse } from 'unbash';
+const BIN = 'svelte-package';
+export const DEFAULT_INPUT = 'src/lib';
+export const DEFAULT_OUTPUT = 'dist';
+const parseCommandIO = (args) => {
+    const parsed = parseArgs(args, { string: ['i', 'o', 'input', 'output'], alias: { input: ['i'], output: ['o'] } });
+    return { input: parsed.input ?? DEFAULT_INPUT, output: parsed.output ?? DEFAULT_OUTPUT };
+};
+const collectFromCommands = (statements, out) => {
+    for (const stmt of statements)
+        visit(stmt.command, out);
+};
+const visit = (node, out) => {
+    switch (node.type) {
+        case 'Command':
+            if (node.name?.value === BIN)
+                out.push(parseCommandIO(node.suffix.map(w => w.value)));
+            return;
+        case 'AndOr':
+        case 'Pipeline':
+            for (const n of node.commands)
+                visit(n, out);
+            return;
+        case 'If':
+            collectFromCommands(node.clause.commands, out);
+            collectFromCommands(node.then.commands, out);
+            if (node.else)
+                visit(node.else, out);
+            return;
+        case 'While':
+            collectFromCommands(node.clause.commands, out);
+            collectFromCommands(node.body.commands, out);
+            return;
+        case 'For':
+        case 'Select':
+        case 'Subshell':
+        case 'BraceGroup':
+            collectFromCommands(node.body.commands, out);
+            return;
+        case 'CompoundList':
+            collectFromCommands(node.commands, out);
+            return;
+        case 'Function':
+        case 'Coproc':
+            visit(node.body, out);
+            return;
+        case 'Statement':
+            visit(node.command, out);
+    }
+};
+export const parseScripts = (scripts) => {
+    const out = [];
+    for (const script of Object.values(scripts ?? {})) {
+        if (typeof script !== 'string' || !script.includes(BIN))
+            continue;
+        try {
+            const parsed = parse(script);
+            if (parsed.commands)
+                collectFromCommands(parsed.commands, out);
+        }
+        catch { }
+    }
+    return out;
+};

package/dist/plugins/sveltejs-package/index.d.ts

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

package/dist/plugins/sveltejs-package/index.js

@@ -0,0 +1,27 @@
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import { DEFAULT_INPUT, DEFAULT_OUTPUT, parseScripts } from './helpers.js';
+const title = '@sveltejs/package';
+const enablers = ['@sveltejs/package'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const resolveSourceMap = ({ cwd, manifest }) => {
+    const ios = parseScripts(manifest.scripts);
+    const effective = ios.length > 0 ? ios : [{ input: DEFAULT_INPUT, output: DEFAULT_OUTPUT }];
+    const seen = new Set();
+    const pairs = [];
+    for (const { input, output } of effective) {
+        const key = `${input}→${output}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        pairs.push({ srcDir: join(cwd, input), outDir: join(cwd, output) });
+    }
+    return pairs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    resolveSourceMap,
+};
+export default plugin;

package/dist/plugins/vitest/helpers.d.ts

@@ -1,3 +1,5 @@
-import type { ViteConfig } from './types.ts';
+import { type Input } from '../../util/input.ts';
+import type { AliasOptions, ViteConfig } from './types.ts';
 export declare const getEnvSpecifier: (env: string) => string;
+export declare const getAliasInputs: (aliasOptions: AliasOptions, cwd: string) => Input[];
 export declare const getExternalReporters: (reporters?: ViteConfig['test']['reporters']) => string[];

package/dist/plugins/vitest/helpers.js

@@ -1,3 +1,5 @@
+import { toAlias } from '../../util/input.js';
+import { join, toPosix } from '../../util/path.js';
 const environments = {
     node: null,
     jsdom: null,
@@ -29,6 +31,22 @@ const builtInReporters = [
     'tree',
     'verbose',
 ];
+const addStar = (value) => (value.endsWith('*') ? value : join(value, '*').replace(/\/\*\*$/, '/*'));
+export const getAliasInputs = (aliasOptions, cwd) => {
+    const inputs = [];
+    for (const [alias, value] of Object.entries(aliasOptions)) {
+        if (!value)
+            continue;
+        const prefixes = [value]
+            .flat()
+            .filter((value) => typeof value === 'string')
+            .map(prefix => (toPosix(prefix).startsWith(cwd) ? prefix : join(cwd, prefix)));
+        if (alias.length > 1)
+            inputs.push(toAlias(alias, prefixes));
+        inputs.push(toAlias(addStar(alias), prefixes.map(addStar)));
+    }
+    return inputs;
+};
 export const getExternalReporters = (reporters) => reporters
     ? [reporters]
         .flat()

package/dist/plugins/vitest/index.js

@@ -1,10 +1,10 @@
 import { DEFAULT_EXTENSIONS } from '../../constants.js';
 import { _glob } from '../../util/glob.js';
-import { toAlias, toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
-import { isAbsolute, isInternal, join, toAbsolute, toPosix } from '../../util/path.js';
+import { toConfig, toDeferResolve, toDependency, toEntry } from '../../util/input.js';
+import { isAbsolute, isInternal, join, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getIndexHtmlEntries } from '../vite/helpers.js';
-import { getEnvSpecifier, getExternalReporters } from './helpers.js';
+import { getAliasInputs, getEnvSpecifier, getExternalReporters } from './helpers.js';
 const title = 'Vitest';
 const enablers = ['vitest'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
@@ -106,23 +106,9 @@ export const resolveConfig = async (localConfig, options) => {
             }
         }
     }
-    const addStar = (value) => (value.endsWith('*') ? value : join(value, '*').replace(/\/\*\*$/, '/*'));
     const addAliases = (aliasOptions) => {
-        for (const [alias, value] of Object.entries(aliasOptions)) {
-            if (!value)
-                continue;
-            const prefixes = [value]
-                .flat()
-                .filter(value => typeof value === 'string')
-                .map(prefix => {
-                if (toPosix(prefix).startsWith(options.cwd))
-                    return prefix;
-                return join(options.cwd, prefix);
-            });
-            if (alias.length > 1)
-                inputs.add(toAlias(alias, prefixes));
-            inputs.add(toAlias(addStar(alias), prefixes.map(addStar)));
-        }
+        for (const input of getAliasInputs(aliasOptions, options.cwd))
+            inputs.add(input);
     };
     const seenRoots = new Set();
     for (const cfg of configs) {

package/dist/reporters/trace.js

@@ -1,4 +1,4 @@
-import pc from 'picocolors';
+import st from '../util/colors.js';
 import { toRelative } from '../util/path.js';
 import { toRegexOrString } from '../util/regex.js';
 import { Table } from '../util/table.js';
@@ -19,8 +19,8 @@ export default ({ graph, explorer, options, workspaceFilePathFilter }) => {
                     continue;
                 seen.add(key);
                 table.row();
-                table.cell('filePath', pc.whiteBright(`${toRel(_import.filePath)}${pos}`));
-                table.cell('package', pc.cyanBright(packageName));
+                table.cell('filePath', st.whiteBright(`${toRel(_import.filePath)}${pos}`));
+                table.cell('package', st.cyanBright(packageName));
             }
         }
         for (const line of table.toRows())

package/dist/reporters/util/util.d.ts

@@ -1,8 +1,8 @@
 import { ISSUE_TYPE_TITLE } from '../../constants.ts';
 import type { Issue, IssueRecords, IssueSeverity, IssueSymbol, IssueType } from '../../types/issues.ts';
 import { Table } from '../../util/table.ts';
-export declare const dim: import("picocolors/types").Formatter;
-export declare const bright: import("picocolors/types").Formatter;
+export declare const dim: (text: string | number | null | undefined) => string;
+export declare const bright: (text: string | number | null | undefined) => string;
 export declare const getIssueTypeTitle: (reportType: keyof typeof ISSUE_TYPE_TITLE) => "Duplicate exports" | "Exported types in used namespace" | "Exports in used namespace" | "Referenced optional peerDependencies" | "Unlisted binaries" | "Unlisted dependencies" | "Unresolved imports" | "Unused catalog entries" | "Unused dependencies" | "Unused devDependencies" | "Unused exported enum members" | "Unused exported namespace members" | "Unused exported types" | "Unused exports" | "Unused files";
 export declare const getColoredTitle: (title: string, count: number) => string;
 export declare const getDimmedTitle: (title: string, count: number) => string;

package/dist/reporters/util/util.js

@@ -1,19 +1,18 @@
-import picocolors from 'picocolors';
 import { ISSUE_TYPE_TITLE, SYMBOL_TYPE } from '../../constants.js';
+import st from '../../util/colors.js';
 import { relative } from '../../util/path.js';
 import { Table } from '../../util/table.js';
 const plain = (text) => text;
-export const dim = picocolors.gray;
-export const bright = picocolors.whiteBright;
-const yellow = picocolors.yellow;
+export const dim = st.gray;
+export const bright = st.whiteBright;
 export const getIssueTypeTitle = (reportType) => ISSUE_TYPE_TITLE[reportType];
-export const getColoredTitle = (title, count) => `${picocolors.yellowBright(picocolors.underline(title))} (${count})`;
-export const getDimmedTitle = (title, count) => `${yellow(`${picocolors.underline(title)} (${count})`)}`;
+export const getColoredTitle = (title, count) => `${st.style(['yellowBright', 'underline'], title)} (${count})`;
+export const getDimmedTitle = (title, count) => `${st.yellow(`${st.underline(title)} (${count})`)}`;
 export const getIssueLine = ({ owner, filePath, symbols, parentSymbol, severity }, cwd) => {
     const symbol = symbols ? `: ${symbols.map(s => s.symbol).join(', ')}` : '';
     const parent = parentSymbol ? ` (${parentSymbol})` : '';
     const print = severity === 'warn' ? dim : plain;
-    return `${owner ? `${picocolors.cyan(owner)} ` : ''}${print(`${relative(cwd, filePath)}${symbol}${parent}`)}`;
+    return `${owner ? `${st.cyan(owner)} ` : ''}${print(`${relative(cwd, filePath)}${symbol}${parent}`)}`;
 };
 export const convert = (issue) => ({
     namespace: 'parentSymbol' in issue ? issue.parentSymbol : undefined,
@@ -32,12 +31,14 @@ const sortByPos = (a, b) => {
         : filePathA.localeCompare(filePathB);
 };
 const highlightSymbol = (issue) => (_) => {
-    if (issue.specifier && issue.specifier !== issue.symbol && issue.specifier.includes(issue.symbol)) {
-        const parts = issue.specifier.split(issue.symbol);
-        const rest = parts.slice(1).join('');
-        return [dim(parts[0]), bright(issue.symbol), dim(rest)].join('');
+    const { specifier, symbol } = issue;
+    if (specifier && specifier !== symbol) {
+        const idx = specifier.indexOf(symbol);
+        if (idx !== -1) {
+            return `${dim(specifier.slice(0, idx))}${bright(symbol)}${dim(specifier.slice(idx + symbol.length))}`;
+        }
     }
-    return issue.symbol;
+    return symbol;
 };
 export const getTableForType = (issues, cwd, options = { isUseColors: true }) => {
     const table = new Table({ truncateStart: ['filePath'], noTruncate: ['symbolType'] });

package/dist/reporters/watch.js

@@ -1,4 +1,4 @@
-import picocolors from 'picocolors';
+import st from '../util/colors.js';
 import { perfObserver } from '../util/Performance.js';
 import { prettyMilliseconds } from '../util/string.js';
 import { flattenIssues, getIssueTypeTitle, getTableForType } from './util/util.js';
@@ -12,7 +12,7 @@ export default (options, { issues, streamer, duration, size }) => {
             const issuesForType = flattenIssues(issues[reportType]);
             if (issuesForType.length > 0) {
                 if (title) {
-                    lines.push(`${picocolors.yellowBright(picocolors.underline(title))} (${issuesForType.length})`);
+                    lines.push(`${st.style(['yellowBright', 'underline'], title)} (${issuesForType.length})`);
                 }
                 lines.push(...getTableForType(issuesForType, options.cwd).toRows());
             }
@@ -23,8 +23,8 @@ export default (options, { issues, streamer, duration, size }) => {
     const ms = duration ?? perfObserver.getCurrentDurationInMs();
     const summary = `${size} files (${prettyMilliseconds(ms)} • ${mem}MB)`;
     const messages = totalIssues === 0
-        ? ['✂️  Excellent, Knip found no issues.', '', picocolors.gray(summary)]
-        : [...lines, '', picocolors.gray(summary)];
+        ? ['✂️  Excellent, Knip found no issues.', '', st.gray(summary)]
+        : [...lines, '', st.gray(summary)];
     if (options.isDebug)
         console.log(messages.join('\n'));
     else

package/dist/schema/configuration.d.ts

@@ -581,6 +581,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>]>>;
+    'sveltejs-package': 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>]>>;
     sveltekit: 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>>]>>;
@@ -1328,6 +1333,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>]>>;
+    'sveltejs-package': 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>]>>;
     sveltekit: 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>>]>>;
@@ -2092,6 +2102,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>]>>;
+        'sveltejs-package': 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>]>>;
         sveltekit: 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

@@ -586,6 +586,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>]>;
+    'sveltejs-package': 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>]>;
     sveltekit: 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

@@ -126,6 +126,7 @@ export const pluginsSchema = z.object({
     stryker: pluginSchema,
     stylelint: pluginSchema,
     svelte: pluginSchema,
+    'sveltejs-package': pluginSchema,
     sveltekit: pluginSchema,
     svgo: pluginSchema,
     svgr: pluginSchema,

package/dist/types/PluginNames.d.ts

@@ -1,2 +1,2 @@
-export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-og-canvas' | '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' | 'execa' | 'expo' | 'expressive-code' | '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' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'qwik' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltekit' | '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' | 'zx';
-export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-og-canvas', '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', 'execa', 'expo', 'expressive-code', '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', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nx', 'nyc', 'oclif', 'openapi-ts', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'preconstruct', 'prettier', 'prisma', 'qwik', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltekit', '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', 'zx'];
+export type PluginName = 'angular' | 'astro' | 'astro-db' | 'astro-og-canvas' | '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' | 'execa' | 'expo' | 'expressive-code' | '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' | 'nitro' | 'node' | 'node-modules-inspector' | 'nodemon' | 'npm-package-json-lint' | 'nuxt' | 'nx' | 'nyc' | 'oclif' | 'openapi-ts' | 'oxfmt' | 'oxlint' | 'panda-css' | 'parcel' | 'payload' | 'pino' | 'playwright' | 'playwright-ct' | 'playwright-test' | 'plop' | 'pm2' | 'pnpm' | 'postcss' | 'preconstruct' | 'prettier' | 'prisma' | 'qwik' | 'raycast' | 'react-cosmos' | 'react-email' | 'react-native' | 'react-router' | 'relay' | 'release-it' | 'remark' | 'remix' | 'rolldown' | 'rollup' | 'rsbuild' | 'rslib' | 'rspack' | 'rstest' | 'sanity' | 'semantic-release' | 'sentry' | 'serverless-framework' | 'simple-git-hooks' | 'size-limit' | 'sst' | 'starlight' | 'stencil' | 'storybook' | 'stryker' | 'stylelint' | 'svelte' | 'sveltejs-package' | 'sveltekit' | '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' | 'zx';
+export declare const pluginNames: readonly ['angular', 'astro', 'astro-db', 'astro-og-canvas', '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', 'execa', 'expo', 'expressive-code', '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', 'nitro', 'node', 'node-modules-inspector', 'nodemon', 'npm-package-json-lint', 'nuxt', 'nx', 'nyc', 'oclif', 'openapi-ts', 'oxfmt', 'oxlint', 'panda-css', 'parcel', 'payload', 'pino', 'playwright', 'playwright-ct', 'playwright-test', 'plop', 'pm2', 'pnpm', 'postcss', 'preconstruct', 'prettier', 'prisma', 'qwik', 'raycast', 'react-cosmos', 'react-email', 'react-native', 'react-router', 'relay', 'release-it', 'remark', 'remix', 'rolldown', 'rollup', 'rsbuild', 'rslib', 'rspack', 'rstest', 'sanity', 'semantic-release', 'sentry', 'serverless-framework', 'simple-git-hooks', 'size-limit', 'sst', 'starlight', 'stencil', 'storybook', 'stryker', 'stylelint', 'svelte', 'sveltejs-package', 'sveltekit', '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', 'zx'];

package/dist/types/PluginNames.js

@@ -115,6 +115,7 @@ export const pluginNames = [
     'stryker',
     'stylelint',
     'svelte',
+    'sveltejs-package',
     'sveltekit',
     'svgo',
     'svgr',

package/dist/types/config.d.ts

@@ -96,6 +96,18 @@ type PluginSetup = () => Promise<void> | void;
 export type IsLoadConfig = (options: PluginOptions, dependencies: Set<string>) => boolean;
 export type ResolveConfig<T = any> = (config: T, options: PluginOptions) => Promise<Input[]> | Input[];
 export type Resolve = (options: PluginOptions) => Promise<Input[]> | Input[];
+export type SourceMap = {
+    srcDir: string;
+    outDir: string;
+};
+export interface ResolveSourceMapOptions {
+    cwd: string;
+    manifest: PackageJson;
+    dependencies: Set<string>;
+    rootCwd: string;
+    rootManifest: PackageJson | undefined;
+}
+export type ResolveSourceMap = (options: ResolveSourceMapOptions) => Promise<SourceMap[]> | SourceMap[];
 export type HandleInput = (input: Input) => string | undefined;
 export type RegisterCompilerInput = {
     extension: string;
@@ -141,6 +153,7 @@ export interface Plugin {
     isLoadConfig?: IsLoadConfig;
     resolveConfig?: ResolveConfig;
     resolve?: Resolve;
+    resolveSourceMap?: ResolveSourceMap;
     resolveFromAST?: ResolveFromAST;
     isFilterTransitiveDependencies?: boolean;
     registerCompilers?: RegisterCompilers;

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

@@ -1,4 +1,6 @@
 import type { ParseResult, Program } from 'oxc-parser';
+export declare const getStringValue: (node: any) => string | undefined;
+export declare const getPropertyKey: (prop: any) => string | undefined;
 export declare const getImportMap: (program: Program) => Map<string, string>;
 export declare const getDefaultImportName: (importMap: Map<string, string>, specifier: string) => string | undefined;
 export declare const getPropertyValues: (node: any, propertyName: string) => Set<string>;

package/dist/typescript/ast-helpers.js

@@ -3,7 +3,8 @@ import stripJsonComments from 'strip-json-comments';
 import { extname, isInternal } from '../util/path.js';
 import { parseFile } from './visitors/helpers.js';
 const isStringLiteral = (node) => node?.type === 'StringLiteral' || (node?.type === 'Literal' && typeof node.value === 'string');
-const getStringValue = (node) => (isStringLiteral(node) ? node.value : undefined);
+export const getStringValue = (node) => (isStringLiteral(node) ? node.value : undefined);
+export const getPropertyKey = (prop) => prop?.key?.type === 'Identifier' ? prop.key.name : getStringValue(prop?.key);
 export const getImportMap = (program) => {
     const importMap = new Map();
     for (const node of program.body ?? []) {
@@ -101,9 +102,8 @@ export const findProperty = (node, name) => {
     if (node?.type !== 'ObjectExpression')
         return;
     for (const prop of node.properties ?? []) {
-        if (prop.type === 'Property' && (prop.key?.name === name || prop.key?.value === name)) {
+        if (prop.type === 'Property' && getPropertyKey(prop) === name)
             return prop.value;
-        }
     }
 };
 export const getStringValues = (node) => {

package/dist/util/colors.d.ts

@@ -0,0 +1,18 @@
+import { styleText } from 'node:util';
+type Modifier = Parameters<typeof styleText>[0];
+type Input = string | number | null | undefined;
+declare const st: {
+    red: (text: Input) => string;
+    green: (text: Input) => string;
+    yellow: (text: Input) => string;
+    cyan: (text: Input) => string;
+    white: (text: Input) => string;
+    gray: (text: Input) => string;
+    dim: (text: Input) => string;
+    underline: (text: Input) => string;
+    cyanBright: (text: Input) => string;
+    whiteBright: (text: Input) => string;
+    yellowBright: (text: Input) => string;
+    style: (mods: Modifier, text: Input) => string;
+};
+export default st;

package/dist/util/colors.js

@@ -0,0 +1,24 @@
+import { styleText } from 'node:util';
+const isColors = !process.env.NO_COLOR && (process.env.FORCE_COLOR === '1' || !!process.stdout.isTTY);
+const make = (mod) => (text) => {
+    const str = String(text);
+    return isColors ? styleText(mod, str, { validateStream: false }) : str;
+};
+const st = {
+    red: make('red'),
+    green: make('green'),
+    yellow: make('yellow'),
+    cyan: make('cyan'),
+    white: make('white'),
+    gray: make('gray'),
+    dim: make('dim'),
+    underline: make('underline'),
+    cyanBright: make('cyanBright'),
+    whiteBright: make('whiteBright'),
+    yellowBright: make('yellowBright'),
+    style: (mods, text) => {
+        const str = String(text);
+        return isColors ? styleText(mods, str, { validateStream: false }) : str;
+    },
+};
+export default st;

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

@@ -621,6 +621,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        'sveltejs-package'?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         sveltekit?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1379,6 +1384,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            'sveltejs-package'?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             sveltekit?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;

package/dist/util/debug.js

@@ -1,14 +1,12 @@
 import util, { parseArgs } from 'node:util';
-import picocolors from 'picocolors';
+import st from './colors.js';
 const { values } = parseArgs({ strict: false, options: { debug: { type: 'boolean' } } });
 const IS_DEBUG_ENABLED = values.debug ?? false;
 const IS_COLORS = !process.env.NO_COLOR;
 const noop = () => { };
 const inspectOptions = { maxArrayLength: null, depth: null, colors: IS_COLORS };
 export const inspect = (obj) => console.log(util.inspect(obj, inspectOptions));
-const ctx = (text) => typeof text === 'string'
-    ? picocolors.yellow(`[${text}]`)
-    : `${picocolors.yellow(`[${text[0]}]`)} ${picocolors.cyan(text[1])}`;
+const ctx = (text) => typeof text === 'string' ? st.yellow(`[${text}]`) : `${st.yellow(`[${text[0]}]`)} ${st.cyan(text[1])}`;
 const logArray = (collection) => {
     console.log(util.inspect(collection.sort(), inspectOptions));
 };

package/dist/util/glob-core.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
-import { promisify } from 'node:util';
-import { walk as _walk } from '@nodelib/fs.walk';
+import { basename } from 'node:path';
+import { fdir } from 'fdir';
 import { glob as tinyGlob } from 'tinyglobby';
 import picomatch from 'picomatch';
 import { GLOBAL_IGNORE_PATTERNS } from '../constants.js';
@@ -10,7 +10,6 @@ import { isDirectory, isFile } from './fs.js';
 import { timerify } from './Performance.js';
 import { expandIgnorePatterns, parseAndConvertGitignorePatterns } from './parse-and-convert-gitignores.js';
 import { dirname, join, relative, toPosix } from './path.js';
-const walk = promisify(_walk);
 const cachedGitIgnores = new Map();
 const cachedGlobIgnores = new Map();
 const isGitRoot = (dir) => isDirectory(dir, '.git') || isFile(dir, '.git');
@@ -155,19 +154,24 @@ export const findAndParseGitignores = async (cwd, workspaceDirs) => {
             };
         }
     }
-    const entryFilter = (entry) => {
-        if (entry.dirent.isFile() && entry.name === '.gitignore') {
-            addFile(entry.path);
+    const cwdPrefixLen = cwd.length + 1;
+    const walkGitignores = async () => {
+        await new fdir()
+            .withFullPaths()
+            .exclude((_dirName, dirPath) => {
+            const absPath = toPosix(dirPath.slice(0, -1));
+            return (isRelevantDir && !isRelevantDir(absPath)) || getMatcher()(absPath.slice(cwdPrefixLen));
+        })
+            .filter((filePath, isDir) => {
+            if (isDir || basename(filePath) !== '.gitignore')
+                return false;
+            addFile(filePath);
             return true;
-        }
-        return false;
+        })
+            .crawl(cwd)
+            .withPromise();
     };
-    const deepFilter = (entry) => (!isRelevantDir || isRelevantDir(toPosix(entry.path))) && !getMatcher()(relative(cwd, entry.path));
-    await walk(cwd, {
-        concurrency: 16,
-        entryFilter,
-        deepFilter,
-    });
+    await timerify(walkGitignores)();
     if (unignores.size > 0) {
         const unignorePaths = new Set();
         for (const u of unignores) {

package/dist/util/log.js

@@ -1,7 +1,7 @@
-import picocolors from 'picocolors';
+import st from './colors.js';
 export const logWarning = (prefix, message) => {
-    console.warn(`${picocolors.yellow(prefix)}: ${message}`);
+    console.warn(`${st.yellow(prefix)}: ${message}`);
 };
 export const logError = (prefix, message) => {
-    console.error(`${picocolors.red(prefix)}: ${message}`);
+    console.error(`${st.red(prefix)}: ${message}`);
 };

package/dist/util/to-source-path.d.ts

@@ -1,6 +1,8 @@
+import type { SourceMap } from '../types/config.ts';
 import type { CompilerOptions } from '../types/project.ts';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.ts';
-export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions) => void;
+export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions | undefined, pluginSourceMaps?: SourceMap[]) => void;
 export declare const getModuleSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
 export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, dir: string, extensions: (string | undefined) | undefined, label: string) => Promise<string[]>;
+export declare const toSourceMappedSpecifiers: (ws: Workspace | undefined, absSpecifier: string, extensions?: string) => string[];
 export type ToSourceFilePath = ReturnType<typeof getModuleSourcePathHandler>;

package/dist/util/to-source-path.js

@@ -7,11 +7,26 @@ const defaultExtensions = `.{${[...DEFAULT_EXTENSIONS].map(ext => ext.slice(1)).
 const hasTSExt = /(?<!\.d)\.(m|c)?tsx?$/;
 const matchExt = /(\.d)?\.(m|c)?(j|t)s$/;
 const sourceExtensions = [...DEFAULT_EXTENSIONS];
-export const augmentWorkspace = (workspace, dir, compilerOptions) => {
+const tsconfigSourceMap = (dir, compilerOptions) => {
     const srcDir = join(dir, 'src');
     const outDirHasSrc = compilerOptions.outDir && isDirectory(compilerOptions.outDir, 'src');
-    workspace.srcDir = compilerOptions.rootDir ?? (outDirHasSrc ? dir : isDirectory(srcDir) ? srcDir : dir);
-    workspace.outDir = compilerOptions.outDir || workspace.srcDir;
+    const resolvedSrc = compilerOptions.rootDir ?? (outDirHasSrc ? dir : isDirectory(srcDir) ? srcDir : dir);
+    return { srcDir: resolvedSrc, outDir: compilerOptions.outDir || resolvedSrc };
+};
+export const augmentWorkspace = (workspace, dir, compilerOptions, pluginSourceMaps = []) => {
+    const all = compilerOptions ? [...pluginSourceMaps, tsconfigSourceMap(dir, compilerOptions)] : pluginSourceMaps;
+    if (all.length === 0)
+        return;
+    workspace.sourceMaps = all.sort((a, b) => b.outDir.length - a.outDir.length);
+};
+const isUnderOutDir = (absPath, outDir) => absPath === outDir || absPath.startsWith(`${outDir}/`);
+const isUnderSrcDir = (absPath, srcDir) => absPath === srcDir || absPath.startsWith(`${srcDir}/`);
+const rewritePattern = (sourceMaps, absSpecifier, extensions) => {
+    for (const { srcDir, outDir } of sourceMaps) {
+        if (!isUnderSrcDir(absSpecifier, srcDir) && isUnderOutDir(absSpecifier, outDir)) {
+            return srcDir + absSpecifier.slice(outDir.length).replace(matchExt, extensions);
+        }
+    }
 };
 export const getModuleSourcePathHandler = (chief) => {
     const toSourceMapCache = new Map();
@@ -21,16 +36,18 @@ export const getModuleSourcePathHandler = (chief) => {
         if (toSourceMapCache.has(filePath))
             return toSourceMapCache.get(filePath);
         const workspace = chief.findWorkspaceByFilePath(filePath);
-        if (workspace?.srcDir && workspace.outDir) {
-            if (filePath.startsWith(workspace.outDir) || workspace.srcDir === workspace.outDir) {
-                const basePath = filePath.replace(workspace.outDir, workspace.srcDir).replace(matchExt, '');
-                const srcFilePath = findFileWithExtensions(basePath, sourceExtensions);
-                if (srcFilePath) {
-                    toSourceMapCache.set(filePath, srcFilePath);
-                    if (srcFilePath !== filePath) {
-                        debugLog('*', `Source mapping ${toRelative(filePath, chief.cwd)} → ${toRelative(srcFilePath, chief.cwd)}`);
-                        return srcFilePath;
-                    }
+        if (!workspace?.sourceMaps)
+            return;
+        for (const { srcDir, outDir } of workspace.sourceMaps) {
+            if (!(isUnderOutDir(filePath, outDir) || srcDir === outDir))
+                continue;
+            const basePath = (srcDir + filePath.slice(outDir.length)).replace(matchExt, '');
+            const srcFilePath = findFileWithExtensions(basePath, sourceExtensions);
+            if (srcFilePath) {
+                toSourceMapCache.set(filePath, srcFilePath);
+                if (srcFilePath !== filePath) {
+                    debugLog('*', `Source mapping ${toRelative(filePath, chief.cwd)} → ${toRelative(srcFilePath, chief.cwd)}`);
+                    return srcFilePath;
                 }
             }
         }
@@ -42,16 +59,22 @@ export const getToSourcePathsHandler = (chief) => {
         for (const specifier of specifiers) {
             const absSpecifier = isAbsolute(specifier) ? specifier : prependDirToPattern(dir, specifier);
             const ws = chief.findWorkspaceByFilePath(absSpecifier);
-            if (ws?.srcDir && ws.outDir && !absSpecifier.startsWith(ws.srcDir) && absSpecifier.startsWith(ws.outDir)) {
-                const pattern = absSpecifier.replace(ws.outDir, ws.srcDir).replace(matchExt, extensions);
-                patterns.add(pattern);
-            }
-            else {
-                patterns.add(absSpecifier);
-            }
+            const mapped = ws?.sourceMaps && rewritePattern(ws.sourceMaps, absSpecifier, extensions);
+            patterns.add(mapped ?? absSpecifier);
         }
         const filePaths = await _glob({ patterns: Array.from(patterns), cwd: dir, label });
         debugLogArray(toRelative(dir, chief.cwd), 'Source mapping (package.json)', filePaths);
         return filePaths;
     };
 };
+export const toSourceMappedSpecifiers = (ws, absSpecifier, extensions = defaultExtensions) => {
+    const out = [];
+    if (!ws?.sourceMaps)
+        return out;
+    for (const { srcDir, outDir } of ws.sourceMaps) {
+        if (!isUnderSrcDir(absSpecifier, srcDir) && isUnderOutDir(absSpecifier, outDir)) {
+            out.push(srcDir + absSpecifier.slice(outDir.length).replace(matchExt, extensions));
+        }
+    }
+    return out;
+};

package/dist/util/trace.js

@@ -1,13 +1,13 @@
-import pc from 'picocolors';
+import st from './colors.js';
 export const formatTrace = (node, toRelative, isReferenced, memberStatuses) => {
     const lines = [];
-    const file = pc.white;
-    const id = pc.cyanBright;
-    const ref = pc.cyanBright;
-    const via = pc.dim;
-    const ok = pc.green;
-    const fail = pc.red;
-    const dim = pc.dim;
+    const file = st.white;
+    const id = st.cyanBright;
+    const ref = st.cyanBright;
+    const via = st.dim;
+    const ok = st.green;
+    const fail = st.red;
+    const dim = st.dim;
     const entryMarker = node.isEntry ? dim(' ⎆') : '';
     lines.push(`${file(toRelative(node.filePath))}${dim(':')}${id(node.identifier)}${entryMarker}`);
     const formatVia = (child) => {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "6.5.0";
+export declare const version = "6.6.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '6.5.0';
+export const version = '6.6.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "6.5.0",
+  "version": "6.6.0",
   "description": "Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects",
   "keywords": [
     "analysis",
@@ -77,14 +77,13 @@
     }
   },
   "dependencies": {
-    "@nodelib/fs.walk": "^1.2.3",
+    "fdir": "^6.5.0",
     "formatly": "^0.3.0",
     "get-tsconfig": "4.14.0",
     "jiti": "^2.6.0",
     "minimist": "^1.2.8",
     "oxc-parser": "^0.126.0",
     "oxc-resolver": "^11.19.1",
-    "picocolors": "^1.1.1",
     "picomatch": "^4.0.4",
     "smol-toml": "^1.6.1",
     "strip-json-comments": "5.0.3",