knip 5.30.6 → 5.32.0

package/dist/typescript/get-imports-and-exports.js

@@ -6,8 +6,8 @@ import { addNsValue, addValue, createImports } from '../util/dependency-graph.js
 import { getPackageNameFromFilePath, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { extname, isInNodeModules } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
-import { getAccessMembers, getDestructuredIds, getJSDocTags, getLineAndCharacterOfPosition, getTypeName, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isReferencedInExportedType, } from './ast-helpers.js';
-import { findInternalReferences } from './find-internal-references.js';
+import { getAccessMembers, getDestructuredIds, getJSDocTags, getLineAndCharacterOfPosition, getTypeName, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isObjectEnumerationCallExpressionArgument, isReferencedInExportedType, } from './ast-helpers.js';
+import { findInternalReferences, isType } from './find-internal-references.js';
 import getDynamicImportVisitors from './visitors/dynamic-imports/index.js';
 import getExportVisitors from './visitors/exports/index.js';
 import { getImportsFromPragmas } from './visitors/helpers.js';
@@ -47,6 +47,35 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
     const importedInternalSymbols = new Map();
     const referencedSymbolsInExportedTypes = new Set();
     const visitors = getVisitors(sourceFile);
+    const addNsMemberRefs = (internalImport, namespace, member) => {
+        if (typeof member === 'string') {
+            internalImport.refs.add(`${namespace}.${member}`);
+            traceRefs.add(`${namespace}.${member}`);
+        }
+        else {
+            for (const m of member) {
+                internalImport.refs.add(`${namespace}.${m}`);
+                traceRefs.add(`${namespace}.${m}`);
+            }
+        }
+    };
+    const maybeAddAliasedExport = (node, alias) => {
+        const identifier = node?.getText();
+        if (node && identifier) {
+            const symbol = sourceFile.symbol?.exports?.get(identifier);
+            if (symbol?.valueDeclaration) {
+                if (!aliasedExports.has(identifier)) {
+                    const pos = getLineAndCharacterOfPosition(symbol.valueDeclaration, symbol.valueDeclaration.pos);
+                    aliasedExports.set(identifier, [{ symbol: identifier, ...pos }]);
+                }
+                const aliasedExport = aliasedExports.get(identifier);
+                if (aliasedExport) {
+                    const pos = getLineAndCharacterOfPosition(node, node.pos);
+                    aliasedExport.push({ symbol: alias, ...pos });
+                }
+            }
+        }
+    };
     const addInternalImport = (options) => {
         const { identifier, symbol, filePath, namespace, alias, specifier, isReExport } = options;
         const isStar = identifier === IMPORT_STAR;
@@ -124,27 +153,6 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
             }
         }
     };
-    const maybeAddAccessExpressionAsNsImport = (namespace, member) => {
-        const symbol = sourceFile.locals?.get(namespace);
-        if (symbol) {
-            const importedSymbolFilePath = importedInternalSymbols.get(symbol);
-            if (importedSymbolFilePath) {
-                const internalImport = internalImports.get(importedSymbolFilePath);
-                if (internalImport) {
-                    if (typeof member === 'string') {
-                        internalImport.refs.add(`${namespace}.${member}`);
-                        traceRefs.add(`${namespace}.${member}`);
-                    }
-                    else {
-                        for (const m of member) {
-                            internalImport.refs.add(`${namespace}.${m}`);
-                            traceRefs.add(`${namespace}.${m}`);
-                        }
-                    }
-                }
-            }
-        }
-    };
     const addExport = ({ node, symbol, identifier, type, pos, members = [], fix }) => {
         if (options.skipExports)
             return;
@@ -200,33 +208,15 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
         }
     };
     const addScript = (script) => scripts.add(script);
-    const maybeAddAliasedExport = (node, alias) => {
-        const identifier = node?.getText();
-        if (node && identifier) {
-            const symbol = sourceFile.symbol?.exports?.get(identifier);
-            if (symbol?.valueDeclaration) {
-                if (!aliasedExports.has(identifier)) {
-                    const pos = getLineAndCharacterOfPosition(symbol.valueDeclaration, symbol.valueDeclaration.pos);
-                    aliasedExports.set(identifier, [{ symbol: identifier, ...pos }]);
-                }
-                const aliasedExport = aliasedExports.get(identifier);
-                if (aliasedExport) {
-                    const pos = getLineAndCharacterOfPosition(node, node.pos);
-                    aliasedExport.push({ symbol: alias, ...pos });
-                }
-            }
-        }
+    const getImport = (id, node) => {
+        const local = sourceFile.locals?.get(id);
+        const symbol = node.symbol ?? node.parent.symbol ?? local;
+        const filePath = importedInternalSymbols.get(symbol) ?? (local && importedInternalSymbols.get(local));
+        return { symbol, filePath };
     };
     const visit = (node) => {
         const addImportWithNode = (result) => addImport(result, node);
-        for (const visitor of visitors.dynamicImport) {
-            const result = visitor(node, options);
-            result && (Array.isArray(result) ? result.forEach(addImportWithNode) : addImportWithNode(result));
-        }
-        const isTopLevel = node.parent &&
-            ('commonJsModuleIndicator' in sourceFile
-                ? node.parent.parent === sourceFile || node.parent === sourceFile
-                : node.parent === sourceFile);
+        const isTopLevel = node !== sourceFile && ts.isInTopLevelContext(node);
         if (isTopLevel) {
             for (const visitor of visitors.import) {
                 const result = visitor(node, options);
@@ -237,18 +227,21 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
                 result && (Array.isArray(result) ? result.forEach(addExport) : addExport(result));
             }
         }
+        for (const visitor of visitors.dynamicImport) {
+            const result = visitor(node, options);
+            result && (Array.isArray(result) ? result.forEach(addImportWithNode) : addImportWithNode(result));
+        }
         for (const visitor of visitors.script) {
             const result = visitor(node, options);
             result && (Array.isArray(result) ? result.forEach(addScript) : addScript(result));
         }
         if (ts.isIdentifier(node)) {
             const id = String(node.escapedText);
-            const symbol = sourceFile.locals?.get(id);
+            const { symbol, filePath } = getImport(id, node);
             if (symbol) {
-                const importedSymbolFilePath = importedInternalSymbols.get(symbol);
-                if (importedSymbolFilePath) {
+                if (filePath) {
                     if (!isImportSpecifier(node)) {
-                        const imports = internalImports.get(importedSymbolFilePath);
+                        const imports = internalImports.get(filePath);
                         if (imports) {
                             traceRefs.add(id);
                             if (isAccessExpression(node.parent)) {
@@ -257,38 +250,40 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
                                         const ns = String(symbol.escapedName);
                                         const key = String(node.parent.name.escapedText);
                                         const members = getDestructuredIds(node.parent.parent.name).map(n => `${key}.${n}`);
-                                        maybeAddAccessExpressionAsNsImport(ns, key);
-                                        maybeAddAccessExpressionAsNsImport(ns, members);
+                                        addNsMemberRefs(imports, ns, key);
+                                        addNsMemberRefs(imports, ns, members);
                                     }
                                 }
                                 else {
                                     const members = getAccessMembers(typeChecker, node);
-                                    maybeAddAccessExpressionAsNsImport(id, members);
+                                    addNsMemberRefs(imports, id, members);
                                 }
                             }
                             else if (isDestructuring(node)) {
                                 const members = getDestructuredIds(node.parent.name);
-                                maybeAddAccessExpressionAsNsImport(id, members);
+                                addNsMemberRefs(imports, id, members);
                             }
                             else {
                                 const typeName = getTypeName(node);
                                 if (typeName) {
                                     const [ns, ...right] = [typeName.left.getText(), typeName.right.getText()].join('.').split('.');
                                     const members = right.map((_r, index) => right.slice(0, index + 1).join('.'));
-                                    maybeAddAccessExpressionAsNsImport(ns, members);
+                                    addNsMemberRefs(imports, ns, members);
                                 }
                                 else if (imports.importedNs.has(id) && isConsiderReferencedNS(node)) {
                                     imports.refs.add(id);
                                 }
-                                else {
+                                else if (isObjectEnumerationCallExpressionArgument(node)) {
                                     imports.refs.add(id);
                                 }
                             }
                         }
                     }
                 }
-                if (ignoreExportsUsedInFile && !isTopLevel && isReferencedInExportedType(node)) {
-                    referencedSymbolsInExportedTypes.add(symbol.exportSymbol);
+                if (!isTopLevel && symbol.exportSymbol) {
+                    if (ts.isTypeQueryNode(node.parent) || isReferencedInExportedType(node)) {
+                        referencedSymbolsInExportedTypes.add(symbol.exportSymbol);
+                    }
                 }
             }
         }
@@ -297,8 +292,13 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
             ts.isQualifiedName(node.moduleReference) &&
             ts.isIdentifier(node.moduleReference.left)) {
             const { left, right } = node.moduleReference;
-            if (sourceFile.locals?.get(left.text))
-                maybeAddAccessExpressionAsNsImport(left.text, right.text);
+            const namespace = left.text;
+            const { filePath } = getImport(namespace, node);
+            if (filePath) {
+                const internalImport = internalImports.get(filePath);
+                if (internalImport)
+                    addNsMemberRefs(internalImport, namespace, right.text);
+            }
         }
         ts.forEachChild(node, visit);
     };
@@ -307,9 +307,14 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options) =
     if (pragmaImports)
         for (const node of pragmaImports)
             addImport(node, sourceFile);
-    const isSetRefs = ignoreExportsUsedInFile;
     for (const item of exports.values()) {
-        if (isSetRefs === true || (typeof isSetRefs === 'object' && item.type !== 'unknown' && !!isSetRefs[item.type])) {
+        const isType_ = isType(item);
+        if (item.symbol && referencedSymbolsInExportedTypes.has(item.symbol)) {
+            item.refs = [1, true];
+        }
+        else if (ignoreExportsUsedInFile === true ||
+            (typeof ignoreExportsUsedInFile === 'object' && item.type !== 'unknown' && ignoreExportsUsedInFile[item.type]) ||
+            isType_) {
             item.refs = findInternalReferences(item, sourceFile, typeChecker, referencedSymbolsInExportedTypes);
         }
         for (const member of item.members) {

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

@@ -1,7 +1,7 @@
 import importCall from './importCall.js';
 import importType from './importType.js';
 import jsDocType from './jsDocType.js';
-import propertyAccessCall from './propertyAccessCall.js';
 import requireCall from './requireCall.js';
-const visitors = [importCall, importType, jsDocType, propertyAccessCall, requireCall];
+import resolveCall from './resolveCall.js';
+const visitors = [importCall, importType, jsDocType, resolveCall, requireCall];
 export default (sourceFile) => visitors.map(v => v(sourceFile));

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

@@ -1,10 +1,11 @@
 import ts from 'typescript';
+import { FIX_FLAGS } from '../../../constants.js';
 import { SymbolType } from '../../../types/issues.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(() => true, (node, { isFixExports }) => {
     if (ts.isExportAssignment(node)) {
         const pos = node.getChildAt(1).getStart();
-        const fix = isFixExports ? [node.getStart(), node.getEnd() + 1] : undefined;
+        const fix = isFixExports ? [node.getStart(), node.getEnd() + 1, FIX_FLAGS.NONE] : undefined;
         const symbol = node.getSourceFile().locals?.get(node.expression.escapedText);
         return { node, symbol, identifier: 'default', type: SymbolType.UNKNOWN, pos, fix };
     }

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

@@ -1,10 +1,11 @@
 import ts from 'typescript';
+import { FIX_FLAGS } from '../../../constants.js';
 import { SymbolType } from '../../../types/issues.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(() => true, (node, { isFixExports, isFixTypes }) => {
     if (ts.isExportDeclaration(node)) {
         if (node.exportClause && ts.isNamedExports(node.exportClause)) {
-            const type = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
+            const nodeType = node.isTypeOnly ? SymbolType.TYPE : SymbolType.UNKNOWN;
             const sourceFile = node.getSourceFile();
             const declarations = sourceFile.getNamedDeclarations?.();
             return node.exportClause.elements.map(element => {
@@ -12,7 +13,10 @@ export default visit(() => true, (node, { isFixExports, isFixTypes }) => {
                 const propName = element.propertyName?.text;
                 const symbol = declarations?.get(propName ?? identifier)?.[0]?.symbol;
                 const pos = element.name.pos;
-                const fix = isFixExports || isFixTypes ? [element.getStart(), element.getEnd()] : undefined;
+                const type = element.isTypeOnly ? SymbolType.TYPE : nodeType;
+                const fix = (isFixExports && type !== SymbolType.TYPE) || (isFixTypes && type === SymbolType.TYPE)
+                    ? [element.getStart(), element.getEnd(), FIX_FLAGS.OBJECT_BINDING | FIX_FLAGS.EMPTY_DECLARATION]
+                    : undefined;
                 return { node: element, symbol, identifier, type, pos, fix };
             });
         }

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

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import { FIX_FLAGS } from '../../../constants.js';
 import { SymbolType } from '../../../types/issues.js';
 import { compact } from '../../../util/array.js';
 import { getDefaultKeywordNode, getExportKeywordNode, isGetOrSetAccessorDeclaration, isPrivateMember, stripQuotes, } from '../../ast-helpers.js';
@@ -6,15 +7,16 @@ import { exportVisitor as visit } from '../index.js';
 export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClassMembers }) => {
     const exportKeyword = getExportKeywordNode(node);
     if (exportKeyword) {
-        const getFix = (node, defaultKeyword) => isFixExports ? [node.getStart(), (defaultKeyword ?? node).getEnd() + 1] : undefined;
-        const getElementFix = (node) => (isFixExports ? [node.getStart(), node.getEnd()] : undefined);
-        const getTypeFix = (node) => (isFixTypes ? [node.getStart(), node.getEnd() + 1] : undefined);
+        const getFix = (node, defaultKeyword) => isFixExports ? [node.getStart(), (defaultKeyword ?? node).getEnd() + 1, FIX_FLAGS.NONE] : undefined;
+        const getTypeFix = (node) => isFixTypes ? [node.getStart(), node.getEnd() + 1, FIX_FLAGS.NONE] : undefined;
         if (ts.isVariableStatement(node)) {
             return node.declarationList.declarations.flatMap(declaration => {
                 if (ts.isObjectBindingPattern(declaration.name)) {
                     return compact(declaration.name.elements.map(element => {
                         if (ts.isIdentifier(element.name)) {
-                            const fix = getElementFix(element);
+                            const fix = isFixExports
+                                ? [element.getStart(), element.getEnd(), FIX_FLAGS.OBJECT_BINDING]
+                                : undefined;
                             return {
                                 node: element,
                                 identifier: element.name.escapedText.toString(),
@@ -28,7 +30,7 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
                 if (ts.isArrayBindingPattern(declaration.name)) {
                     return compact(declaration.name.elements.map(element => {
                         if (ts.isBindingElement(element)) {
-                            const fix = getElementFix(element);
+                            const fix = isFixExports ? [element.getStart(), element.getEnd(), FIX_FLAGS.NONE] : undefined;
                             return {
                                 node: element,
                                 identifier: element.getText(),
@@ -67,7 +69,7 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
                     identifier: member.name.getText(),
                     pos: member.name.getStart() + (ts.isComputedPropertyName(member.name) ? 1 : 0),
                     type: SymbolType.MEMBER,
-                    fix: undefined,
+                    fix: isFixTypes ? [member.getStart(), member.getEnd(), FIX_FLAGS.NONE] : undefined,
                 }))
                 : [];
             return { node, identifier, type: SymbolType.CLASS, pos, members, fix };
@@ -93,7 +95,7 @@ export default visit(() => true, (node, { isFixExports, isFixTypes, isReportClas
                 identifier: stripQuotes(member.name.getText()),
                 pos: member.name.getStart(),
                 type: SymbolType.MEMBER,
-                fix: undefined,
+                fix: isFixTypes ? [member.getStart(), member.getEnd(), FIX_FLAGS.OBJECT_BINDING] : undefined,
             }));
             return { node, identifier, type: SymbolType.ENUM, pos, members, fix };
         }

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

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import { FIX_FLAGS } from '../../../constants.js';
 import { SymbolType } from '../../../types/issues.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
@@ -7,7 +8,7 @@ export default visit(isJS, (node, { isFixExports }) => {
         if (ts.isIdentifier(node.left.expression) && node.left.expression.escapedText === 'exports') {
             const identifier = node.left.name.getText();
             const pos = node.left.name.pos;
-            const fix = isFixExports ? [node.getStart(), node.getEnd()] : undefined;
+            const fix = isFixExports ? [node.getStart(), node.getEnd(), FIX_FLAGS.NONE] : undefined;
             return {
                 node: node.left.name,
                 identifier,

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

@@ -1,4 +1,5 @@
 import ts from 'typescript';
+import { FIX_FLAGS } from '../../../constants.js';
 import { SymbolType } from '../../../types/issues.js';
 import { hasRequireCall, isModuleExportsAccess, stripQuotes } from '../../ast-helpers.js';
 import { isJS } from '../helpers.js';
@@ -11,7 +12,7 @@ export default visit(isJS, (node, { isFixExports }) => {
                     isModuleExportsAccess(node.expression.left.expression)) {
                     const identifier = node.expression.left.name.getText();
                     const pos = node.expression.left.name.pos;
-                    const fix = isFixExports ? [node.getStart(), node.getEnd()] : undefined;
+                    const fix = isFixExports ? [node.getStart(), node.getEnd(), FIX_FLAGS.NONE] : undefined;
                     return {
                         node: node.expression.left.name,
                         identifier,
@@ -24,7 +25,7 @@ export default visit(isJS, (node, { isFixExports }) => {
                     const expr = node.expression.right;
                     if (ts.isObjectLiteralExpression(expr) && expr.properties.every(ts.isShorthandPropertyAssignment)) {
                         return expr.properties.map(node => {
-                            const fix = isFixExports ? [node.getStart(), node.getEnd()] : undefined;
+                            const fix = isFixExports ? [node.getStart(), node.getEnd(), FIX_FLAGS.NONE] : undefined;
                             return { node, identifier: node.getText(), type: SymbolType.UNKNOWN, pos: node.getStart(), fix };
                         });
                     }
@@ -40,7 +41,7 @@ export default visit(isJS, (node, { isFixExports }) => {
                 isModuleExportsAccess(node.expression.left.expression)) {
                 const identifier = stripQuotes(node.expression.left.argumentExpression.getText());
                 const pos = node.expression.left.argumentExpression.pos;
-                const fix = isFixExports ? [node.getStart(), node.getEnd()] : undefined;
+                const fix = isFixExports ? [node.getStart(), node.getEnd(), FIX_FLAGS.NONE] : undefined;
                 return {
                     node: node.expression.left.argumentExpression,
                     identifier,

package/dist/typescript/visitors/helpers.js

@@ -10,8 +10,9 @@ export function getImportsFromPragmas(sourceFile) {
                 ? jsxImportSourcePragmas[jsxImportSourcePragmas.length - 1]
                 : jsxImportSourcePragmas;
             const { factory: specifier } = jsxImportSourcePragma?.arguments ?? {};
+            const pos = jsxImportSourcePragma.range?.pos ?? 0;
             if (specifier)
-                importNodes.push({ specifier, isTypeOnly: true, identifier: '__jsx', pos: 0 });
+                importNodes.push({ specifier, isTypeOnly: true, identifier: '__jsx', pos });
         }
         const referencePragma = sourceFile.pragmas.get('reference');
         if (referencePragma) {

package/dist/util/fs.d.ts

@@ -7,5 +7,4 @@ export declare const loadYAML: (filePath: string) => Promise<unknown>;
 export declare const loadTOML: (filePath: string) => Promise<Record<string, import("smol-toml").TomlPrimitive>>;
 export declare const parseJSON: (filePath: string, contents: string) => Promise<any>;
 export declare const parseYAML: (contents: string) => unknown;
-export declare function isTypeModule(path: string): boolean;
 export declare const _loadJSON: (filePath: string) => Promise<any>;

package/dist/util/fs.js

@@ -1,11 +1,11 @@
-import { readFileSync, statSync } from 'node:fs';
+import { statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import yaml from 'js-yaml';
 import { parse as parseTOML } from 'smol-toml';
 import stripJsonComments from 'strip-json-comments';
 import { timerify } from './Performance.js';
 import { LoaderError } from './errors.js';
-import { dirname, join } from './path.js';
+import { join } from './path.js';
 export const isDirectory = (filePath) => {
     try {
         return statSync(filePath).isDirectory();
@@ -58,19 +58,4 @@ export const parseJSON = async (filePath, contents) => {
 export const parseYAML = (contents) => {
     return yaml.load(contents);
 };
-export function isTypeModule(path) {
-    while (path && path !== '.' && path !== '/') {
-        path = dirname(path);
-        try {
-            const pkg = readFileSync(join(path, 'package.json'), 'utf-8');
-            try {
-                return JSON.parse(pkg).type === 'module';
-            }
-            catch { }
-            break;
-        }
-        catch { }
-    }
-    return false;
-}
 export const _loadJSON = timerify(loadJSON);

package/dist/util/glob-core.js

@@ -36,7 +36,7 @@ export const parseAndConvertGitignorePatterns = (patterns, ancestor) => {
         .split(/\r?\n/)
         .filter(line => line.trim() && !line.startsWith('#'))
         .flatMap(line => {
-        const pattern = line.replace(/(?<!\\)#.*/, '').trim();
+        const pattern = line.replace(/^\\(?=#)/, '').trim();
         if (ancestor && matchFrom) {
             if (pattern.match(matchFrom))
                 return [pattern.replace(matchFrom, '$1')];

package/dist/util/jiti.d.ts

@@ -1,2 +1 @@
-export declare const jitiCJS: any;
-export declare const jitiESM: any;
+export declare const jiti: import("jiti").Jiti;

package/dist/util/jiti.js

@@ -1,17 +1,12 @@
 import { fileURLToPath } from 'node:url';
-import createJITI, {} from 'jiti';
-import { DEFAULT_EXTENSIONS } from '../constants.js';
+import { createJiti } from 'jiti';
 import { join } from './path.js';
 const empty = join(fileURLToPath(import.meta.url), '../empty.js');
 const options = {
-    interopDefault: true,
-    extensions: DEFAULT_EXTENSIONS,
-    esmResolve: false,
     alias: {
         '@rushstack/eslint-config/patch/modern-module-resolution': empty,
         '@rushstack/eslint-patch/modern-module-resolution': empty,
     },
 };
-const createLoader = (options) => createJITI(process.cwd(), options);
-export const jitiCJS = createLoader(options);
-export const jitiESM = createLoader({ ...options, esmResolve: true });
+const createLoader = (options) => createJiti(process.cwd(), options);
+export const jiti = createLoader(options);

package/dist/util/loader.js

@@ -1,9 +1,7 @@
-import { pathToFileURL } from 'node:url';
 import { timerify } from './Performance.js';
 import { LoaderError } from './errors.js';
 import { loadFile, loadJSON, loadTOML, loadYAML, parseJSON, parseYAML } from './fs.js';
-import { isTypeModule } from './fs.js';
-import { jitiCJS, jitiESM } from './jiti.js';
+import { jiti } from './jiti.js';
 import { extname, isInternal } from './path.js';
 const load = async (filePath) => {
     try {
@@ -33,15 +31,7 @@ const load = async (filePath) => {
         if (ext === '.toml') {
             return await loadTOML(filePath);
         }
-        if (ext === '.mjs' || (ext === '.js' && isTypeModule(filePath))) {
-            const fileUrl = pathToFileURL(filePath);
-            const imported = await import(fileUrl.href);
-            return imported.default ?? imported;
-        }
-        if (ext === '.mts' || ((ext === '.ts' || ext === '.tsx') && isTypeModule(filePath))) {
-            return await jitiESM(filePath);
-        }
-        return await jitiCJS(filePath);
+        return await jiti.import(filePath, { default: true });
     }
     catch (error) {
         throw new LoaderError(`Error loading ${filePath}`, { cause: error });

package/dist/util/remove-export.d.ts

@@ -0,0 +1,8 @@
+interface FixerOptions {
+    text: string;
+    start: number;
+    end: number;
+    flags: number;
+}
+export declare const removeExport: ({ text, start, end, flags }: FixerOptions) => string;
+export {};

package/dist/util/remove-export.js

@@ -0,0 +1,68 @@
+import { FIX_FLAGS } from '../constants.js';
+const getOpeningBracketIndex = (text) => {
+    let bracketOpenIndex = -1;
+    let j = text.length - 1;
+    while (j >= 0) {
+        const char = text[j];
+        if (char === '{') {
+            bracketOpenIndex = j;
+            break;
+        }
+        if (!/\s/.test(char) && char !== ',') {
+            if (text.substring(j - 3, j + 1) === 'type') {
+                j = j - 4;
+                continue;
+            }
+            break;
+        }
+        j--;
+    }
+    return bracketOpenIndex;
+};
+export const removeExport = ({ text, start, end, flags }) => {
+    const beforeStart = text.substring(0, start);
+    const afterEnd = text.substring(end);
+    if (flags % FIX_FLAGS.NONE)
+        return beforeStart + afterEnd;
+    const subject = text.substring(start, end).trim();
+    if (subject === 'export' || subject === 'export default')
+        return beforeStart + afterEnd;
+    let closingBracketOffset = -1;
+    let commaOffset = -1;
+    if (flags & FIX_FLAGS.OBJECT_BINDING) {
+        let i = 0;
+        while (i <= afterEnd.length) {
+            const char = afterEnd[i];
+            if (char === ',') {
+                commaOffset = i + 1;
+            }
+            else if (char === '}') {
+                closingBracketOffset = i + 1;
+                break;
+            }
+            else if (!/\s/.test(char))
+                break;
+            i++;
+        }
+    }
+    if (flags & FIX_FLAGS.EMPTY_DECLARATION && closingBracketOffset !== -1) {
+        const openingBracketIndex = getOpeningBracketIndex(beforeStart);
+        if (closingBracketOffset !== -1 && openingBracketIndex !== -1) {
+            const beforeBracket = beforeStart.substring(0, openingBracketIndex).trim();
+            const exportLength = beforeBracket.endsWith('export') ? 6 : beforeBracket.endsWith('export type') ? 12 : 0;
+            const exportKeywordOffset = beforeBracket.length - exportLength;
+            if (exportLength) {
+                const fromBracket = afterEnd.substring(closingBracketOffset).trim();
+                if (fromBracket.startsWith('from')) {
+                    const specifierQuoteMatch = afterEnd.match(/['"][^'"]+['"]/);
+                    if (specifierQuoteMatch?.index) {
+                        const fromSpecifierLength = specifierQuoteMatch.index + specifierQuoteMatch[0].length;
+                        return beforeBracket.substring(0, exportKeywordOffset) + afterEnd.substring(fromSpecifierLength);
+                    }
+                }
+                return beforeBracket.substring(0, exportKeywordOffset) + afterEnd.substring(closingBracketOffset);
+            }
+        }
+    }
+    return beforeStart + (commaOffset === -1 ? afterEnd : afterEnd.substring(commaOffset));
+};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.30.6";
+export declare const version = "5.32.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.30.6';
+export const version = '5.32.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knip",
-  "version": "5.30.6",
+  "version": "5.32.0",
   "description": "Find unused files, dependencies and exports in your TypeScript and JavaScript projects",
   "homepage": "https://knip.dev",
   "repository": {
@@ -66,7 +66,7 @@
     "easy-table": "1.2.0",
     "enhanced-resolve": "^5.17.1",
     "fast-glob": "^3.3.2",
-    "jiti": "^1.21.6",
+    "jiti": "^2.3.1",
     "js-yaml": "^4.1.0",
     "minimist": "^1.2.8",
     "picocolors": "^1.0.0",
@@ -90,7 +90,7 @@
     "@types/minimist": "^1.2.5",
     "@types/picomatch": "3.0.1",
     "@types/webpack": "^5.28.5",
-    "@wdio/types": "^9.0.8",
+    "@wdio/types": "^9.1.2",
     "glob": "^10.4.2",
     "release-it": "^17.6.0",
     "type-fest": "^4.20.0",

package/schema.json

@@ -520,6 +520,10 @@
           "title": "tailwind plugin configuration (https://knip.dev/reference/plugins/tailwind)",
           "$ref": "#/definitions/plugin"
         },
+        "travis": {
+          "title": "travis plugin configuration (https://knip.dev/reference/plugins/travis)",
+          "$ref": "#/definitions/plugin"
+        },
         "tsup": {
           "title": "tsup plugin configuration (https://knip.dev/reference/plugins/tsup)",
           "$ref": "#/definitions/plugin"