knip 4.0.2 → 4.0.4

package/dist/DependencyDeputy.js

@@ -132,7 +132,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 +269,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 +282,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 +300,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 +309,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/constants.d.ts

@@ -3,8 +3,8 @@ 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 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',
@@ -45,8 +45,8 @@ export const IGNORED_GLOBAL_BINARIES = [
     'true',
     'yarn',
     'xargs',
-];
-export const IGNORED_DEPENDENCIES = ['knip', 'typescript'];
+]);
+export const IGNORED_DEPENDENCIES = new Set(['knip', 'typescript']);
 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/plugins/postcss/index.js

@@ -2,7 +2,7 @@ import { basename } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 const NAME = 'PostCSS';
-const ENABLERS = ['postcss', 'next'];
+const ENABLERS = ['postcss', 'postcss-cli', 'next'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 const CONFIG_FILE_PATTERNS = ['postcss.config.{cjs,js}', 'postcss.config.json', 'package.json'];
 const findPostCSSDependencies = async (configFilePath, options) => {

package/dist/plugins/stylelint/index.js

@@ -5,6 +5,12 @@ const NAME = 'Stylelint';
 const ENABLERS = ['stylelint'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, ENABLERS);
 const CONFIG_FILE_PATTERNS = ['.stylelintrc', '.stylelintrc.{cjs,js,json,yaml,yml}', 'stylelint.config.{cjs,mjs,js}'];
+const findDependenciesInConfig = (config) => {
+    const extend = config.extends ? [config.extends].flat().filter(id => !isInternal(id)) : [];
+    const plugins = config.plugins ? [config.plugins].flat().filter(id => !isInternal(id)) : [];
+    const overrideConfigs = 'overrides' in config ? config.overrides.flatMap(findDependenciesInConfig) : [];
+    return [...extend, ...plugins, ...overrideConfigs];
+};
 const findPluginDependencies = async (configFilePath, options) => {
     const { manifest, isProduction } = options;
     if (isProduction)
@@ -12,9 +18,7 @@ const findPluginDependencies = async (configFilePath, options) => {
     const localConfig = basename(configFilePath) === 'package.json' ? manifest.stylelint : await load(configFilePath);
     if (!localConfig)
         return [];
-    const extend = localConfig.extends ? [localConfig.extends].flat().filter(extend => !isInternal(extend)) : [];
-    const plugins = localConfig.plugins ? [localConfig.plugins].flat().filter(plugin => !isInternal(plugin)) : [];
-    return [...extend, ...plugins];
+    return findDependenciesInConfig(localConfig);
 };
 const findDependencies = timerify(findPluginDependencies);
 export default {

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

@@ -1,4 +1,7 @@
-export type PluginConfig = {
+export type BaseStyleLintConfig = {
     extends?: string | string[];
     plugins?: string[];
 };
+export type StyleLintConfig = BaseStyleLintConfig & {
+    overrides: BaseStyleLintConfig[];
+};

package/dist/plugins/webpack/index.js

@@ -1,5 +1,5 @@
 import { compact } from '../../util/array.js';
-import { join, relative } from '../../util/path.js';
+import { isInternal, join, relative } from '../../util/path.js';
 import { timerify } from '../../util/Performance.js';
 import { hasDependency, load } from '../../util/plugin.js';
 import { toEntryPattern, toProductionEntryPattern } from '../../util/protocols.js';
@@ -23,16 +23,16 @@ const resolveRuleSetDependencies = (rule) => {
     let useItem = rule.use ?? rule.loader ?? rule;
     if (typeof useItem === 'function')
         useItem = useItem(info);
-    return [useItem].flat().flatMap((useItem) => {
-        if (!useItem)
+    if (typeof useItem === 'string' && hasBabelOptions(rule)) {
+        return [useItem, ...getDependenciesFromConfig(rule.options)];
+    }
+    return [useItem].flat().flatMap((item) => {
+        if (!item)
             return [];
-        if (hasBabelOptions(useItem)) {
-            return [
-                ...resolveUseItem(useItem),
-                ...getDependenciesFromConfig(useItem.options),
-            ];
+        if (hasBabelOptions(item)) {
+            return [...resolveUseItem(item), ...getDependenciesFromConfig(item.options)];
         }
-        return resolveUseItem(useItem);
+        return resolveUseItem(item);
     });
 };
 const resolveUseItem = (use) => {
@@ -74,9 +74,14 @@ export const findWebpackDependenciesFromConfig = async ({ config, cwd }) => {
                 });
             }
             entries.forEach(entry => {
-                const item = relative(cwd, join(options.context ? options.context : cwd, entry));
-                const value = options.mode === 'development' ? toEntryPattern(item) : toProductionEntryPattern(item);
-                entryPatterns.add(value);
+                if (!isInternal(entry)) {
+                    dependencies.add(entry);
+                }
+                else {
+                    const item = relative(cwd, join(options.context ? options.context : cwd, entry));
+                    const value = options.mode === 'development' ? toEntryPattern(item) : toProductionEntryPattern(item);
+                    entryPatterns.add(value);
+                }
             });
         }
     }

package/dist/typescript/visitors/dynamic-imports/jsDocType.js

@@ -7,7 +7,7 @@ const getImportSpecifiers = (node) => {
             const importClause = node.argument;
             if (ts.isLiteralTypeNode(importClause) && ts.isStringLiteral(importClause.literal)) {
                 const identifier = node.qualifier && ts.isIdentifier(node.qualifier) ? String(node.qualifier.escapedText) : 'default';
-                imports.push({ specifier: importClause.literal.text, identifier, pos: undefined });
+                imports.push({ specifier: importClause.literal.text, identifier, pos: importClause.literal.pos });
             }
         }
         ts.forEachChild(node, visit);

package/dist/typescript/visitors/exports/moduleExportsAccessExpression.js

@@ -26,11 +26,11 @@ export default visit(isJS, (node, { isFixExports }) => {
                     if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
                         return expr.properties.map(node => {
                             const fix = isFixExports ? [node.getStart(), node.getEnd()] : undefined;
-                            return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.pos, fix };
+                            return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.getStart(), fix };
                         });
                     }
                     else {
-                        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: expr.pos, fix: undefined };
+                        return { node, identifier: 'default', type: SymbolType.UNKNOWN, pos: expr.pos + 1, fix: undefined };
                     }
                 }
             }

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.2";
+export declare const version = "4.0.4";

package/dist/version.js

@@ -1 +1 @@
-export const version = '4.0.2';
+export const version = '4.0.4';

package/package.json

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