knip 4.0.3 → 4.1.0

package/dist/DependencyDeputy.js

@@ -1,5 +1,5 @@
 import { isBuiltin } from 'node:module';
-import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, ROOT_WORKSPACE_NAME, } from './constants.js';
+import { IGNORE_DEFINITELY_TYPED, IGNORED_DEPENDENCIES, IGNORED_GLOBAL_BINARIES, IGNORED_RUNTIME_DEPENDENCIES, ROOT_WORKSPACE_NAME, } from './constants.js';
 import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
 import { hasMatch, hasMatchInArray, hasMatchInSet, toRegexOrString, findKey } from './util/regex.js';
 export class DependencyDeputy {
@@ -111,6 +111,8 @@ export class DependencyDeputy {
     maybeAddReferencedExternalDependency(workspace, packageName) {
         if (isBuiltin(packageName))
             return true;
+        if (IGNORED_RUNTIME_DEPENDENCIES.has(packageName))
+            return true;
         if (packageName === workspace.pkgName)
             return true;
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
@@ -132,7 +134,7 @@ export class DependencyDeputy {
         return false;
     }
     maybeAddReferencedBinary(workspace, binaryName) {
-        if (IGNORED_GLOBAL_BINARIES.includes(binaryName))
+        if (IGNORED_GLOBAL_BINARIES.has(binaryName))
             return true;
         this.addReferencedBinary(workspace.name, binaryName);
         const workspaceNames = this.isStrict ? [workspace.name] : [workspace.name, ...[...workspace.ancestors].reverse()];
@@ -269,7 +271,7 @@ export class DependencyDeputy {
             const peerDependencies = this.getPeerDependencies(workspaceName);
             ignoreDependencies
                 .filter(packageName => {
-                if (hasMatchInArray(IGNORED_DEPENDENCIES, packageName))
+                if (hasMatchInSet(IGNORED_DEPENDENCIES, packageName))
                     return true;
                 if (this.ignoreDependencies.includes(packageName))
                     return true;
@@ -282,7 +284,7 @@ export class DependencyDeputy {
             });
             ignoreBinaries
                 .filter(binaryName => {
-                if (hasMatchInArray(IGNORED_GLOBAL_BINARIES, binaryName))
+                if (hasMatchInSet(IGNORED_GLOBAL_BINARIES, binaryName))
                     return true;
                 if (this.ignoreBinaries.includes(binaryName))
                     return true;
@@ -300,7 +302,7 @@ export class DependencyDeputy {
         const peerDependencies = this.getPeerDependencies(ROOT_WORKSPACE_NAME);
         Array.from(rootIgnoreDependencies.keys())
             .filter(packageName => {
-            if (hasMatchInArray(IGNORED_DEPENDENCIES, packageName))
+            if (hasMatchInSet(IGNORED_DEPENDENCIES, packageName))
                 return true;
             const isReferenced = rootIgnoreDependencies.get(packageName) !== 0;
             const isListed = hasMatchInArray(dependencies, packageName) && !hasMatchInArray(peerDependencies, packageName);
@@ -309,7 +311,7 @@ export class DependencyDeputy {
             .forEach(identifier => configurationHints.add({ workspaceName: ROOT_WORKSPACE_NAME, identifier, type: 'ignoreDependencies' }));
         Array.from(rootIgnoreBinaries.keys())
             .filter(binaryName => {
-            if (hasMatchInArray(IGNORED_GLOBAL_BINARIES, binaryName))
+            if (hasMatchInSet(IGNORED_GLOBAL_BINARIES, binaryName))
                 return true;
             const isReferenced = rootIgnoreBinaries.get(binaryName) !== 0;
             const isInstalled = hasMatchInArray(Array.from(installedBinaries?.keys() ?? []), binaryName);

package/dist/binaries/bash-parser.js

@@ -19,7 +19,7 @@ export const getBinariesFromScript = (script, { cwd, manifest, knownGlobalsOnly
                     return [];
                 if (binary.startsWith('-') || binary.startsWith('"') || binary.startsWith('..'))
                     return [];
-                if (['bun', 'deno'].includes(binary))
+                if (['deno'].includes(binary))
                     return [];
                 const args = node.suffix?.map(arg => arg.text) ?? [];
                 if (['!', 'test'].includes(binary))

package/dist/binaries/resolvers/bun.d.ts

@@ -0,0 +1,2 @@
+import type { Resolver } from '../types.js';
+export declare const resolve: Resolver;

package/dist/binaries/resolvers/bun.js

@@ -0,0 +1,17 @@
+import parseArgs from 'minimist';
+import { tryResolveFilePath } from '../util.js';
+const commands = ['add', 'create', 'init', 'install', 'link', 'pm', 'remove', 'run', 'update'];
+export const resolve = (_binary, args, { manifest, cwd, fromArgs }) => {
+    const scripts = manifest.scripts ? Object.keys(manifest.scripts) : [];
+    const parsed = parseArgs(args);
+    const [command, script] = parsed._;
+    if (command === 'run' && scripts.includes(script))
+        return [];
+    if (commands.includes(command))
+        return [];
+    const filePath = command === 'run' ? script : command;
+    const specifier = tryResolveFilePath(cwd, filePath);
+    if (specifier)
+        return [specifier];
+    return fromArgs(args);
+};

package/dist/binaries/resolvers/index.d.ts

@@ -1,3 +1,4 @@
+export * as bun from './bun.js';
 export * as c8 from './c8.js';
 export * as dotenv from './dotenv.js';
 export * as node from './node.js';

package/dist/binaries/resolvers/index.js

@@ -1,3 +1,4 @@
+export * as bun from './bun.js';
 export * as c8 from './c8.js';
 export * as dotenv from './dotenv.js';
 export * as node from './node.js';

package/dist/constants.d.ts

@@ -3,8 +3,9 @@ export declare const ROOT_WORKSPACE_NAME = ".";
 export declare const KNIP_CONFIG_LOCATIONS: string[];
 export declare const DEFAULT_EXTENSIONS: string[];
 export declare const GLOBAL_IGNORE_PATTERNS: string[];
-export declare const IGNORED_GLOBAL_BINARIES: string[];
-export declare const IGNORED_DEPENDENCIES: string[];
+export declare const IGNORED_GLOBAL_BINARIES: Set<string>;
+export declare const IGNORED_DEPENDENCIES: Set<string>;
+export declare const IGNORED_RUNTIME_DEPENDENCIES: Set<string>;
 export declare const DUMMY_VIRTUAL_FILE_EXTENSIONS: Set<string>;
 export declare const IGNORED_FILE_EXTENSIONS: Set<string>;
 export declare const IGNORE_DEFINITELY_TYPED: string[];

package/dist/constants.js

@@ -11,7 +11,7 @@ export const KNIP_CONFIG_LOCATIONS = [
 ];
 export const DEFAULT_EXTENSIONS = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.mts', '.cts'];
 export const GLOBAL_IGNORE_PATTERNS = ['**/node_modules/**', '.yarn'];
-export const IGNORED_GLOBAL_BINARIES = [
+export const IGNORED_GLOBAL_BINARIES = new Set([
     'bash',
     'bun',
     'bunx',
@@ -30,6 +30,8 @@ export const IGNORED_GLOBAL_BINARIES = [
     'find',
     'git',
     'grep',
+    'gzip',
+    'ls',
     'mkdir',
     'mv',
     'node',
@@ -45,8 +47,9 @@ export const IGNORED_GLOBAL_BINARIES = [
     'true',
     'yarn',
     'xargs',
-];
-export const IGNORED_DEPENDENCIES = ['knip', 'typescript'];
+]);
+export const IGNORED_DEPENDENCIES = new Set(['knip', 'typescript']);
+export const IGNORED_RUNTIME_DEPENDENCIES = new Set(['bun']);
 export const DUMMY_VIRTUAL_FILE_EXTENSIONS = new Set(['.html', '.jpeg', '.jpg', '.png', '.svg', '.webp']);
 export const IGNORED_FILE_EXTENSIONS = new Set([
     '.avif',

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

@@ -0,0 +1,139 @@
+import type { EleventyConfig } from './types.js';
+export declare class DummyEleventyConfig {
+    constructor();
+    _getUniqueId(): void;
+    reset(): void;
+    versionCheck(): void;
+    on(): void;
+    emit(): void;
+    _enablePluginExecution(): void;
+    addMarkdownHighlighter(): void;
+    addLiquidTag(): void;
+    addLiquidFilter(): void;
+    addNunjucksAsyncFilter(): void;
+    addNunjucksFilter(): void;
+    addHandlebarsHelper(): void;
+    addFilter(): void;
+    addAsyncFilter(): void;
+    getFilter(): void;
+    addNunjucksTag(): void;
+    addGlobalData(): void;
+    addNunjucksGlobal(): void;
+    addTransform(): void;
+    addLinter(): void;
+    addLayoutAlias(): void;
+    setLayoutResolution(): void;
+    enableLayoutResolution(): void;
+    getCollections(): void;
+    addCollection(): void;
+    addPlugin(): void;
+    _getPluginName(): void;
+    _executePlugin(): void;
+    getNamespacedName(): void;
+    namespace(): void;
+    addPassthroughCopy(input: string | Record<string, string>): void;
+    _normalizeTemplateFormats(): void;
+    setTemplateFormats(): void;
+    addTemplateFormats(): void;
+    setLibrary(): void;
+    amendLibrary(): void;
+    setPugOptions(): void;
+    setLiquidOptions(): void;
+    setNunjucksEnvironmentOptions(): void;
+    setNunjucksPrecompiledTemplates(): void;
+    setEjsOptions(): void;
+    setDynamicPermalinks(): void;
+    setUseGitIgnore(): void;
+    addShortcode(): void;
+    addAsyncShortcode(): void;
+    addNunjucksAsyncShortcode(): void;
+    addNunjucksShortcode(): void;
+    addLiquidShortcode(): void;
+    addHandlebarsShortcode(): void;
+    addPairedShortcode(): void;
+    addPairedAsyncShortcode(): void;
+    addPairedNunjucksAsyncShortcode(): void;
+    addPairedNunjucksShortcode(): void;
+    addPairedLiquidShortcode(): void;
+    addPairedHandlebarsShortcode(): void;
+    addJavaScriptFunction(): void;
+    setDataDeepMerge(): void;
+    isDataDeepMergeModified(): void;
+    addWatchTarget(): void;
+    setWatchJavaScriptDependencies(): void;
+    setServerOptions(): void;
+    setBrowserSyncConfig(): void;
+    setChokidarConfig(): void;
+    setWatchThrottleWaitTime(): void;
+    setFrontMatterParsingOptions(): void;
+    setQuietMode(): void;
+    addExtension(): void;
+    addDataExtension(): void;
+    setUseTemplateCache(): void;
+    setPrecompiledCollections(): void;
+    setServerPassthroughCopyBehavior(): void;
+    addUrlTransform(): void;
+    setDataFileSuffixes(): void;
+    setDataFileBaseName(): void;
+    getMergingConfigObject(): void;
+    _uniqueId: {};
+    events: {};
+    benchmarkManager: {};
+    benchmarks: {};
+    collections: {};
+    precompiledCollections: {};
+    templateFormats: {};
+    liquidOptions: {};
+    liquidTags: {};
+    liquidFilters: {};
+    liquidShortcodes: {};
+    liquidPairedShortcodes: {};
+    nunjucksEnvironmentOptions: {};
+    nunjucksPrecompiledTemplates: {};
+    nunjucksFilters: {};
+    nunjucksAsyncFilters: {};
+    nunjucksTags: {};
+    nunjucksGlobals: {};
+    nunjucksShortcodes: {};
+    nunjucksAsyncShortcodes: {};
+    nunjucksPairedShortcodes: {};
+    nunjucksAsyncPairedShortcodes: {};
+    javascriptFunctions: {};
+    markdownHighlighter: null;
+    libraryOverrides: {};
+    passthroughCopies: Record<string, Record<never, never>>;
+    layoutAliases: {};
+    layoutResolution: boolean;
+    linters: {};
+    transforms: {};
+    activeNamespace: string;
+    DateTime: {};
+    dynamicPermalinks: boolean;
+    useGitIgnore: boolean;
+    ignores: Set<unknown>;
+    watchIgnores: Set<unknown>;
+    dataDeepMerge: boolean;
+    extensionMap: Set<unknown>;
+    watchJavaScriptDependencies: boolean;
+    additionalWatchTargets: never[];
+    serverOptions: {};
+    globalData: {};
+    chokidarConfig: {};
+    watchThrottleWaitTime: number;
+    dataExtensions: Map<any, any>;
+    quietMode: boolean;
+    plugins: never[];
+    _pluginExecution: boolean;
+    useTemplateCache: boolean;
+    dataFilterSelectors: Set<unknown>;
+    libraryAmendments: {};
+    serverPassthroughCopyBehavior: string;
+    urlTransforms: never[];
+    dataFileSuffixesOverride: boolean;
+    dataFileDirBaseNameOverride: boolean;
+    frontMatterParsingOptions: {
+        engines: {};
+    };
+    templateFormatsAdded: {};
+}
+export declare const defaultEleventyConfig: EleventyConfig;

package/dist/plugins/eleventy/helpers.js

@@ -0,0 +1,156 @@
+export class DummyEleventyConfig {
+    constructor() { }
+    _getUniqueId() { }
+    reset() { }
+    versionCheck() { }
+    on() { }
+    emit() { }
+    _enablePluginExecution() { }
+    addMarkdownHighlighter() { }
+    addLiquidTag() { }
+    addLiquidFilter() { }
+    addNunjucksAsyncFilter() { }
+    addNunjucksFilter() { }
+    addHandlebarsHelper() { }
+    addFilter() { }
+    addAsyncFilter() { }
+    getFilter() { }
+    addNunjucksTag() { }
+    addGlobalData() { }
+    addNunjucksGlobal() { }
+    addTransform() { }
+    addLinter() { }
+    addLayoutAlias() { }
+    setLayoutResolution() { }
+    enableLayoutResolution() { }
+    getCollections() { }
+    addCollection() { }
+    addPlugin() { }
+    _getPluginName() { }
+    _executePlugin() { }
+    getNamespacedName() { }
+    namespace() { }
+    addPassthroughCopy(input) {
+        if (typeof input === 'string') {
+            this.passthroughCopies[input] = {};
+        }
+        else {
+            for (let [inputPath] of Object.entries(input)) {
+                this.passthroughCopies[inputPath] = {};
+            }
+        }
+    }
+    _normalizeTemplateFormats() { }
+    setTemplateFormats() { }
+    addTemplateFormats() { }
+    setLibrary() { }
+    amendLibrary() { }
+    setPugOptions() { }
+    setLiquidOptions() { }
+    setNunjucksEnvironmentOptions() { }
+    setNunjucksPrecompiledTemplates() { }
+    setEjsOptions() { }
+    setDynamicPermalinks() { }
+    setUseGitIgnore() { }
+    addShortcode() { }
+    addAsyncShortcode() { }
+    addNunjucksAsyncShortcode() { }
+    addNunjucksShortcode() { }
+    addLiquidShortcode() { }
+    addHandlebarsShortcode() { }
+    addPairedShortcode() { }
+    addPairedAsyncShortcode() { }
+    addPairedNunjucksAsyncShortcode() { }
+    addPairedNunjucksShortcode() { }
+    addPairedLiquidShortcode() { }
+    addPairedHandlebarsShortcode() { }
+    addJavaScriptFunction() { }
+    setDataDeepMerge() { }
+    isDataDeepMergeModified() { }
+    addWatchTarget() { }
+    setWatchJavaScriptDependencies() { }
+    setServerOptions() { }
+    setBrowserSyncConfig() { }
+    setChokidarConfig() { }
+    setWatchThrottleWaitTime() { }
+    setFrontMatterParsingOptions() { }
+    setQuietMode() { }
+    addExtension() { }
+    addDataExtension() { }
+    setUseTemplateCache() { }
+    setPrecompiledCollections() { }
+    setServerPassthroughCopyBehavior() { }
+    addUrlTransform() { }
+    setDataFileSuffixes() { }
+    setDataFileBaseName() { }
+    getMergingConfigObject() { }
+    _uniqueId = {};
+    events = {};
+    benchmarkManager = {};
+    benchmarks = {};
+    collections = {};
+    precompiledCollections = {};
+    templateFormats = {};
+    liquidOptions = {};
+    liquidTags = {};
+    liquidFilters = {};
+    liquidShortcodes = {};
+    liquidPairedShortcodes = {};
+    nunjucksEnvironmentOptions = {};
+    nunjucksPrecompiledTemplates = {};
+    nunjucksFilters = {};
+    nunjucksAsyncFilters = {};
+    nunjucksTags = {};
+    nunjucksGlobals = {};
+    nunjucksShortcodes = {};
+    nunjucksAsyncShortcodes = {};
+    nunjucksPairedShortcodes = {};
+    nunjucksAsyncPairedShortcodes = {};
+    javascriptFunctions = {};
+    markdownHighlighter = null;
+    libraryOverrides = {};
+    passthroughCopies = {};
+    layoutAliases = {};
+    layoutResolution = true;
+    linters = {};
+    transforms = {};
+    activeNamespace = '';
+    DateTime = {};
+    dynamicPermalinks = true;
+    useGitIgnore = true;
+    ignores = new Set();
+    watchIgnores = new Set();
+    dataDeepMerge = true;
+    extensionMap = new Set();
+    watchJavaScriptDependencies = true;
+    additionalWatchTargets = [];
+    serverOptions = {};
+    globalData = {};
+    chokidarConfig = {};
+    watchThrottleWaitTime = 0;
+    dataExtensions = new Map();
+    quietMode = false;
+    plugins = [];
+    _pluginExecution = false;
+    useTemplateCache = true;
+    dataFilterSelectors = new Set();
+    libraryAmendments = {};
+    serverPassthroughCopyBehavior = '';
+    urlTransforms = [];
+    dataFileSuffixesOverride = false;
+    dataFileDirBaseNameOverride = false;
+    frontMatterParsingOptions = {
+        engines: {},
+    };
+    templateFormatsAdded = {};
+}
+export const defaultEleventyConfig = {
+    dir: {
+        input: '.',
+        output: '_site',
+        includes: '_includes',
+        layouts: '_includes',
+        data: '_data',
+    },
+    templateFormats: '11ty.js',
+};

package/dist/plugins/eleventy/index.d.ts

@@ -3,8 +3,10 @@ declare const _default: {
     NAME: string;
     ENABLERS: string[];
     isEnabled: IsPluginEnabledCallback;
+    CONFIG_FILE_PATTERNS: string[];
     ENTRY_FILE_PATTERNS: string[];
     PRODUCTION_ENTRY_FILE_PATTERNS: string[];
+    PROJECT_FILE_PATTERNS: string[];
     findDependencies: GenericPluginCallback;
 };
 export default _default;

package/dist/plugins/eleventy/index.js

@@ -1,23 +1,63 @@
+import { DEFAULT_EXTENSIONS } from '../../constants.js';
+import { isDirectory } from '../../util/fs.js';
+import { dirname, isInternal, join } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
-import { hasDependency } from '../../util/plugin.js';
-import { toEntryPattern, toProductionEntryPattern } from '../../util/protocols.js';
+import { hasDependency, load } from '../../util/plugin.js';
+import { toProductionEntryPattern } from '../../util/protocols.js';
+import { DummyEleventyConfig, defaultEleventyConfig } from './helpers.js';
 const NAME = 'Eleventy';
 const ENABLERS = ['@11ty/eleventy'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
-const ENTRY_FILE_PATTERNS = ['.eleventy.js', 'eleventy.config.{js,cjs}'];
+const CONFIG_FILE_PATTERNS = ['.eleventy.js', 'eleventy.config.{js,cjs}'];
+const ENTRY_FILE_PATTERNS = [];
 const PRODUCTION_ENTRY_FILE_PATTERNS = ['posts/**/*.11tydata.js', '_data/**/*.{js,cjs,mjs}'];
+const PROJECT_FILE_PATTERNS = [];
 const findEleventyDependencies = async (configFilePath, options) => {
     const { config } = options;
-    return config.entry
-        ? config.entry.map(toProductionEntryPattern)
-        : [...ENTRY_FILE_PATTERNS.map(toEntryPattern), ...PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern)];
+    let localConfig = (await load(configFilePath));
+    if (!localConfig)
+        return config.entry
+            ? config.entry.map(toProductionEntryPattern)
+            : PRODUCTION_ENTRY_FILE_PATTERNS.map(toProductionEntryPattern);
+    const dummyUserConfig = new DummyEleventyConfig();
+    if (typeof localConfig === 'function')
+        localConfig = await localConfig(dummyUserConfig);
+    const inputDir = localConfig?.dir?.input || defaultEleventyConfig.dir.input;
+    const dataDir = localConfig?.dir?.data || defaultEleventyConfig.dir.data;
+    const templateFormats = localConfig.templateFormats || defaultEleventyConfig.templateFormats;
+    const exts = DEFAULT_EXTENSIONS.map(extname => extname.slice(1)).join(',');
+    const copiedPackages = new Set();
+    const copiedEntries = new Set();
+    for (const path of Object.keys(dummyUserConfig.passthroughCopies)) {
+        const isDir = !path.includes('*') && isDirectory(join(dirname(configFilePath), path));
+        if (isDir) {
+            copiedEntries.add(join(path, `**/*.{${exts}}`));
+        }
+        else if (isInternal(path)) {
+            copiedEntries.add(path);
+        }
+        else {
+            copiedPackages.add(path);
+        }
+    }
+    return [
+        ...(config?.entry ?? [
+            join(inputDir, dataDir, '**/*.js'),
+            join(inputDir, `**/*.{${typeof templateFormats === 'string' ? templateFormats : templateFormats.join(',')}}`),
+            join(inputDir, '**/*.11tydata.js'),
+            ...copiedEntries,
+        ]).map(toProductionEntryPattern),
+        ...copiedPackages,
+    ];
 };
 const findDependencies = timerify(findEleventyDependencies);
 export default {
     NAME,
     ENABLERS,
     isEnabled,
+    CONFIG_FILE_PATTERNS,
     ENTRY_FILE_PATTERNS,
     PRODUCTION_ENTRY_FILE_PATTERNS,
+    PROJECT_FILE_PATTERNS,
     findDependencies,
 };

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

@@ -0,0 +1,10 @@
+export type EleventyConfig = {
+    dir: {
+        input: string;
+        output: string;
+        includes: string;
+        layouts: string;
+        data: string;
+    };
+    templateFormats: string | string[];
+};

package/dist/plugins/eleventy/types.js

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

package/dist/typescript/visitors/helpers.d.ts

@@ -1,4 +1,6 @@
+import ts from 'typescript';
 import type { BoundSourceFile } from '../SourceFile.js';
 export declare const isNotJS: (sourceFile: BoundSourceFile) => boolean;
 export declare const isJS: (sourceFile: BoundSourceFile) => boolean;
 export declare function getJSXImplicitImportBase(sourceFile: BoundSourceFile): string | undefined;
+export declare function hasImportSpecifier(node: ts.Statement, name: string): boolean;

package/dist/typescript/visitors/helpers.js

@@ -8,3 +8,11 @@ export function getJSXImplicitImportBase(sourceFile) {
         : jsxImportSourcePragmas;
     return jsxImportSourcePragma?.arguments.factory;
 }
+export function hasImportSpecifier(node, name) {
+    return (ts.isImportDeclaration(node) &&
+        ts.isStringLiteral(node.moduleSpecifier) &&
+        node.moduleSpecifier.text === name &&
+        !!node.importClause?.namedBindings &&
+        ts.isNamedImports(node.importClause.namedBindings) &&
+        node.importClause.namedBindings.elements.some(element => element.name.text === '$'));
+}

package/dist/typescript/visitors/scripts/bun.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (sourceFile: ts.SourceFile) => (node: ts.Node, options: import("../../getImportsAndExports.js").GetImportsAndExportsOptions) => string | string[] | undefined;
+export default _default;

package/dist/typescript/visitors/scripts/bun.js

@@ -0,0 +1,9 @@
+import ts from 'typescript';
+import { stripQuotes } from '../../ast-helpers.js';
+import { hasImportSpecifier } from '../helpers.js';
+import { scriptVisitor as visit } from '../index.js';
+export default visit(sourceFile => sourceFile.statements.some(node => hasImportSpecifier(node, 'bun')), node => {
+    if (ts.isTaggedTemplateExpression(node) && node.tag.getText() === '$') {
+        return stripQuotes(node.template.getText());
+    }
+});

package/dist/typescript/visitors/scripts/execa.js

@@ -1,18 +1,11 @@
 import ts from 'typescript';
 import { stripQuotes } from '../../ast-helpers.js';
+import { hasImportSpecifier } from '../helpers.js';
 import { scriptVisitor as visit } from '../index.js';
-export default visit(sourceFile => sourceFile.statements.some(statementImportsExeca$), node => {
+export default visit(sourceFile => sourceFile.statements.some(node => hasImportSpecifier(node, 'execa')), node => {
     if (ts.isTaggedTemplateExpression(node)) {
         if (node.tag.getText() === '$' || (ts.isCallExpression(node.tag) && node.tag.expression.getText() === '$')) {
             return stripQuotes(node.template.getText());
         }
     }
 });
-function statementImportsExeca$(node) {
-    return (ts.isImportDeclaration(node) &&
-        ts.isStringLiteral(node.moduleSpecifier) &&
-        node.moduleSpecifier.text === 'execa' &&
-        !!node.importClause?.namedBindings &&
-        ts.isNamedImports(node.importClause.namedBindings) &&
-        node.importClause.namedBindings.elements.some(element => element.name.text === '$'));
-}

package/dist/typescript/visitors/scripts/index.js

@@ -1,5 +1,6 @@
 import ts from 'typescript';
+import bun from './bun.js';
 import execa from './execa.js';
 import zx from './zx.js';
-const visitors = [execa, zx];
+const visitors = [bun, execa, zx];
 export default (sourceFile) => visitors.map(v => v(sourceFile));

package/dist/util/globby.js

@@ -118,10 +118,7 @@ export async function globby(patterns, options) {
             ignore.push(...i.ignores);
     }
     const { dir, ...fastGlobOptions } = { ...options, ignore };
-    debugLogObject(relative(options.cwd, options.dir) || ROOT_WORKSPACE_NAME, `Glob options`, {
-        patterns,
-        ...fastGlobOptions,
-    });
+    debugLogObject(relative(options.cwd, dir) || ROOT_WORKSPACE_NAME, `Glob options`, { patterns, ...options });
     return fastGlob(patterns, fastGlobOptions);
 }
 export async function isGitIgnoredFn(options) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.0.3";
+export declare const version = "4.1.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '4.0.3';
+export const version = '4.1.0';

package/package.json

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