knip 5.73.3 → 5.74.0

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { IMPORT_MODIFIERS, IMPORT_STAR } from '../../../constants.js';
+import { IMPORT_FLAGS, IMPORT_STAR } from '../../../constants.js';
 import { findAncestor, findDescendants, isModuleExportsAccess, isRequireCall, isTopLevel } from '../../ast-helpers.js';
 import { isNotJS } from '../helpers.js';
 import { importVisitor as visit } from '../index.js';
@@ -7,7 +7,7 @@ export default visit(() => true, node => {
     if (isRequireCall(node)) {
         if (ts.isStringLiteralLike(node.arguments[0])) {
             const specifier = node.arguments[0].text;
-            const modifiers = isNotJS(node.getSourceFile()) ? IMPORT_MODIFIERS.BRIDGE : IMPORT_MODIFIERS.NONE;
+            const modifiers = isNotJS(node.getSourceFile()) ? IMPORT_FLAGS.BRIDGE : IMPORT_FLAGS.NONE;
             if (specifier) {
                 const propertyAccessExpression = findAncestor(node, _node => {
                     if (ts.isExpressionStatement(_node) || ts.isCallExpression(_node))
@@ -16,7 +16,15 @@ export default visit(() => true, node => {
                 });
                 if (propertyAccessExpression) {
                     const identifier = String(propertyAccessExpression.name.escapedText);
-                    return { identifier, specifier, pos: propertyAccessExpression.name.getStart(), modifiers };
+                    return {
+                        identifier,
+                        specifier,
+                        pos: propertyAccessExpression.name.getStart(),
+                        modifiers,
+                        alias: undefined,
+                        namespace: undefined,
+                        symbol: undefined,
+                    };
                 }
                 const variableDeclaration = node.parent;
                 if (ts.isVariableDeclaration(variableDeclaration) &&
@@ -30,6 +38,7 @@ export default visit(() => true, node => {
                             symbol: isTLA ? variableDeclaration.symbol : undefined,
                             specifier,
                             pos: variableDeclaration.name.getStart(),
+                            namespace: undefined,
                             modifiers,
                         };
                     }
@@ -39,10 +48,26 @@ export default visit(() => true, node => {
                             const identifier = (element.propertyName ?? element.name).getText();
                             const alias = element.propertyName ? element.name.getText() : undefined;
                             const symbol = isTLA ? element.symbol : undefined;
-                            return { identifier, specifier, alias, symbol, pos: element.name.getStart(), modifiers };
+                            return {
+                                identifier,
+                                specifier,
+                                alias,
+                                symbol,
+                                pos: element.name.getStart(),
+                                modifiers,
+                                namespace: undefined,
+                            };
                         });
                     }
-                    return { identifier: 'default', specifier, pos: node.arguments[0].pos, modifiers };
+                    return {
+                        identifier: 'default',
+                        specifier,
+                        pos: node.arguments[0].pos,
+                        modifiers,
+                        alias: undefined,
+                        namespace: undefined,
+                        symbol: undefined,
+                    };
                 }
                 if (ts.isBinaryExpression(node.parent) &&
                     ts.isPropertyAccessExpression(node.parent.left) &&
@@ -51,13 +76,32 @@ export default visit(() => true, node => {
                         identifier: IMPORT_STAR,
                         specifier,
                         pos: node.arguments[0].pos,
-                        modifiers: IMPORT_MODIFIERS.RE_EXPORT,
+                        modifiers: IMPORT_FLAGS.RE_EXPORT,
+                        alias: undefined,
+                        namespace: undefined,
+                        symbol: undefined,
                     };
                 }
                 if (ts.isCallExpression(node.parent)) {
-                    return { identifier: 'default', specifier, pos: node.getEnd(), modifiers };
+                    return {
+                        identifier: 'default',
+                        specifier,
+                        pos: node.getEnd(),
+                        modifiers,
+                        alias: undefined,
+                        namespace: undefined,
+                        symbol: undefined,
+                    };
                 }
-                return { identifier: 'default', specifier, pos: node.getStart(), modifiers };
+                return {
+                    identifier: 'default',
+                    specifier,
+                    pos: node.getStart(),
+                    modifiers,
+                    alias: undefined,
+                    namespace: undefined,
+                    symbol: undefined,
+                };
             }
         }
     }

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { IMPORT_MODIFIERS } from '../../../constants.js';
+import { IMPORT_FLAGS } from '../../../constants.js';
 import { isPropertyAccessCall } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
@@ -11,7 +11,10 @@ export default visit(() => true, node => {
                     specifier,
                     identifier: undefined,
                     pos: node.arguments[0].pos,
-                    modifiers: IMPORT_MODIFIERS.ENTRY,
+                    modifiers: IMPORT_FLAGS.ENTRY,
+                    alias: undefined,
+                    namespace: undefined,
+                    symbol: undefined,
                 };
         }
     }

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { IMPORT_MODIFIERS } from '../../../constants.js';
+import { IMPORT_FLAGS } from '../../../constants.js';
 import { importVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
     if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'URL') {
@@ -17,7 +17,10 @@ export default visit(() => true, node => {
                     specifier,
                     identifier: undefined,
                     pos: node.arguments[0].pos,
-                    modifiers: IMPORT_MODIFIERS.ENTRY | IMPORT_MODIFIERS.OPTIONAL,
+                    modifiers: IMPORT_FLAGS.ENTRY | IMPORT_FLAGS.OPTIONAL,
+                    alias: undefined,
+                    namespace: undefined,
+                    symbol: undefined,
                 };
         }
     }

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

@@ -1,6 +1,6 @@
 import ts from 'typescript';
-import { FIX_FLAGS } from '../../../constants.js';
-import { getClassMember, getEnumMember, getNodeType, isNonPrivatePropertyOrMethodDeclaration, } from '../../ast-helpers.js';
+import { EMPTY_ARRAY, FIX_FLAGS } from '../../../constants.js';
+import { getClassMember, getEnumMember, getNodeType, isNonPrivateDeclaration } from '../../ast-helpers.js';
 import { isModule } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(isModule, (node, { isFixExports, isReportClassMembers, isFixTypes }) => {
@@ -13,17 +13,15 @@ export default visit(isModule, (node, { isFixExports, isReportClassMembers, isFi
             const decl = symbol.valueDeclaration;
             if (ts.isEnumDeclaration(decl)) {
                 const members = decl.members.map(member => getEnumMember(member, isFixExports));
-                return { node, symbol, identifier: 'default', type, pos, fix, members };
+                return { node, symbol, identifier: 'default', type, pos, fix, members, jsDocTags: undefined };
             }
             if (ts.isClassDeclaration(decl)) {
                 const members = isReportClassMembers
-                    ? decl.members
-                        .filter(isNonPrivatePropertyOrMethodDeclaration)
-                        .map(member => getClassMember(member, isFixTypes))
-                    : [];
-                return { node, symbol, identifier: 'default', type, pos, fix, members };
+                    ? decl.members.filter(isNonPrivateDeclaration).map(member => getClassMember(member, isFixTypes))
+                    : EMPTY_ARRAY;
+                return { node, symbol, identifier: 'default', type, pos, fix, members, jsDocTags: undefined };
             }
         }
-        return { node, symbol, identifier: 'default', type, pos, fix };
+        return { node, symbol, identifier: 'default', type, pos, fix, members: EMPTY_ARRAY, jsDocTags: undefined };
     }
 });

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
+import { EMPTY_ARRAY, FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { isModule } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(isModule, (node, { isFixExports, isFixTypes }) => {
@@ -17,7 +17,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes }) => {
                 const fix = (isFixExports && type !== SYMBOL_TYPE.TYPE) || (isFixTypes && type === SYMBOL_TYPE.TYPE)
                     ? [element.getStart(), element.getEnd(), FIX_FLAGS.OBJECT_BINDING | FIX_FLAGS.EMPTY_DECLARATION]
                     : undefined;
-                return { node: element, symbol, identifier, type, pos, fix };
+                return { node: element, symbol, identifier, type, pos, fix, members: EMPTY_ARRAY, jsDocTags: undefined };
             });
         }
     }

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

@@ -1,7 +1,7 @@
 import ts from 'typescript';
-import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
+import { EMPTY_ARRAY, FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { compact } from '../../../util/array.js';
-import { getClassMember, getDefaultKeywordNode, getEnumMember, getExportKeywordNode, isNonPrivatePropertyOrMethodDeclaration, } from '../../ast-helpers.js';
+import { getClassMember, getDefaultKeywordNode, getEnumMember, getExportKeywordNode, isNonPrivateDeclaration, } from '../../ast-helpers.js';
 import { isModule } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassMembers }) => {
@@ -22,6 +22,8 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
                                 type: SYMBOL_TYPE.UNKNOWN,
                                 pos: element.name.getStart(),
                                 fix,
+                                members: EMPTY_ARRAY,
+                                jsDocTags: undefined,
                             };
                         }
                     }));
@@ -37,6 +39,8 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
                                 type: SYMBOL_TYPE.UNKNOWN,
                                 pos: element.getStart(),
                                 fix,
+                                members: EMPTY_ARRAY,
+                                jsDocTags: undefined,
                             };
                         }
                     }));
@@ -44,7 +48,15 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
                 const identifier = declaration.name.getText();
                 const pos = declaration.name.getStart();
                 const fix = getFix(exportKeyword);
-                return { node: declaration, identifier, type: SYMBOL_TYPE.UNKNOWN, pos, fix };
+                return {
+                    node: declaration,
+                    identifier,
+                    type: SYMBOL_TYPE.UNKNOWN,
+                    pos,
+                    fix,
+                    members: EMPTY_ARRAY,
+                    jsDocTags: undefined,
+                };
             });
         }
         const defaultKeyword = getDefaultKeywordNode(node);
@@ -52,35 +64,62 @@ export default visit(isModule, (node, { isFixExports, isFixTypes, isReportClassM
             const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = (node.name ?? node.body ?? node).getStart();
             const fix = getFix(exportKeyword, defaultKeyword);
-            return { node, identifier, pos, type: SYMBOL_TYPE.FUNCTION, fix };
+            return {
+                node,
+                symbol: undefined,
+                identifier,
+                pos,
+                type: SYMBOL_TYPE.FUNCTION,
+                fix,
+                members: EMPTY_ARRAY,
+                jsDocTags: undefined,
+            };
         }
         if (ts.isClassDeclaration(node) && node.name) {
             const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = (node.name ?? node).getStart();
             const fix = getFix(exportKeyword, defaultKeyword);
             const members = isReportClassMembers
-                ? node.members.filter(isNonPrivatePropertyOrMethodDeclaration).map(member => getClassMember(member, isFixTypes))
-                : [];
-            return { node, identifier, type: SYMBOL_TYPE.CLASS, pos, members, fix };
+                ? node.members.filter(isNonPrivateDeclaration).map(member => getClassMember(member, isFixTypes))
+                : EMPTY_ARRAY;
+            return { node, symbol: undefined, identifier, type: SYMBOL_TYPE.CLASS, pos, fix, members, jsDocTags: undefined };
         }
         if (ts.isTypeAliasDeclaration(node)) {
             const identifier = node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
-            return { node, identifier, type: SYMBOL_TYPE.TYPE, pos, fix };
+            return {
+                node,
+                symbol: undefined,
+                identifier,
+                type: SYMBOL_TYPE.TYPE,
+                pos,
+                fix,
+                members: EMPTY_ARRAY,
+                jsDocTags: undefined,
+            };
         }
         if (ts.isInterfaceDeclaration(node)) {
             const identifier = defaultKeyword ? 'default' : node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
-            return { node, identifier, type: SYMBOL_TYPE.INTERFACE, pos, fix };
+            return {
+                node,
+                symbol: undefined,
+                identifier,
+                type: SYMBOL_TYPE.INTERFACE,
+                pos,
+                fix,
+                members: EMPTY_ARRAY,
+                jsDocTags: undefined,
+            };
         }
         if (ts.isEnumDeclaration(node)) {
             const identifier = node.name.getText();
             const pos = node.name.getStart();
             const fix = getTypeFix(exportKeyword);
             const members = node.members.map(member => getEnumMember(member, isFixExports));
-            return { node, identifier, type: SYMBOL_TYPE.ENUM, pos, members, fix };
+            return { node, symbol: undefined, identifier, type: SYMBOL_TYPE.ENUM, pos, members, fix, jsDocTags: undefined };
         }
     }
 });

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
+import { EMPTY_ARRAY, FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
 export default visit(isJS, (node, { isFixExports }) => {
@@ -10,10 +10,13 @@ export default visit(isJS, (node, { isFixExports }) => {
             const fix = isFixExports ? [node.getStart(), node.getEnd(), FIX_FLAGS.NONE] : undefined;
             return {
                 node: node.left.name,
+                symbol: undefined,
                 identifier,
                 type: SYMBOL_TYPE.UNKNOWN,
                 pos,
                 fix,
+                members: EMPTY_ARRAY,
+                jsDocTags: undefined,
             };
         }
     }

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
+import { EMPTY_ARRAY, FIX_FLAGS, SYMBOL_TYPE } from '../../../constants.js';
 import { hasRequireCall, isModuleExportsAccess, stripQuotes } from '../../ast-helpers.js';
 import { isJS } from '../helpers.js';
 import { exportVisitor as visit } from '../index.js';
@@ -14,10 +14,13 @@ export default visit(isJS, (node, { isFixExports }) => {
                     const fix = isFixExports ? [node.getStart(), node.getEnd(), FIX_FLAGS.NONE] : undefined;
                     return {
                         node: node.expression.left.name,
+                        symbol: undefined,
                         identifier,
                         type: SYMBOL_TYPE.UNKNOWN,
                         pos,
                         fix,
+                        members: EMPTY_ARRAY,
+                        jsDocTags: undefined,
                     };
                 }
                 if (isModuleExportsAccess(node.expression.left)) {
@@ -25,13 +28,31 @@ 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(), FIX_FLAGS.NONE] : undefined;
-                            return { node, identifier: node.getText(), type: SYMBOL_TYPE.UNKNOWN, pos: node.getStart(), fix };
+                            return {
+                                node,
+                                symbol: undefined,
+                                identifier: node.getText(),
+                                type: SYMBOL_TYPE.UNKNOWN,
+                                pos: node.getStart(),
+                                fix,
+                                members: EMPTY_ARRAY,
+                                jsDocTags: undefined,
+                            };
                         });
                     }
                     if (ts.isCallExpression(node.expression.right) && hasRequireCall(node.expression.right)) {
                         return;
                     }
-                    return { node, identifier: 'default', type: SYMBOL_TYPE.UNKNOWN, pos: expr.pos + 1, fix: undefined };
+                    return {
+                        node,
+                        symbol: undefined,
+                        identifier: 'default',
+                        type: SYMBOL_TYPE.UNKNOWN,
+                        pos: expr.pos + 1,
+                        fix: undefined,
+                        members: EMPTY_ARRAY,
+                        jsDocTags: undefined,
+                    };
                 }
             }
             else if (ts.isElementAccessExpression(node.expression.left) &&
@@ -43,10 +64,13 @@ export default visit(isJS, (node, { isFixExports }) => {
                 const fix = isFixExports ? [node.getStart(), node.getEnd(), FIX_FLAGS.NONE] : undefined;
                 return {
                     node: node.expression.left.argumentExpression,
+                    symbol: undefined,
                     identifier,
                     type: SYMBOL_TYPE.UNKNOWN,
                     pos,
                     fix,
+                    members: EMPTY_ARRAY,
+                    jsDocTags: undefined,
                 };
             }
         }

package/dist/typescript/visitors/imports/importDeclaration.js

@@ -1,15 +1,23 @@
 import ts from 'typescript';
-import { IMPORT_MODIFIERS, IMPORT_STAR } from '../../../constants.js';
+import { IMPORT_FLAGS, IMPORT_STAR } from '../../../constants.js';
 import { isDefaultImport } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
     if (ts.isImportDeclaration(node) && ts.isStringLiteralLike(node.moduleSpecifier)) {
         const specifier = node.moduleSpecifier.text;
         if (!node.importClause) {
-            return { specifier, identifier: undefined, pos: node.pos, modifiers: IMPORT_MODIFIERS.SIDE_EFFECTS };
+            return {
+                specifier,
+                identifier: undefined,
+                pos: node.pos,
+                modifiers: IMPORT_FLAGS.SIDE_EFFECTS,
+                alias: undefined,
+                namespace: undefined,
+                symbol: undefined,
+            };
         }
         const imports = [];
-        const modifiers = node.importClause.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE;
+        const modifiers = node.importClause.isTypeOnly ? IMPORT_FLAGS.TYPE_ONLY : IMPORT_FLAGS.NONE;
         if (isDefaultImport(node)) {
             imports.push({
                 identifier: 'default',
@@ -18,6 +26,7 @@ export default visit(() => true, node => {
                 symbol: node.importClause.symbol,
                 pos: node.importClause.name?.getStart() ?? node.getStart(),
                 modifiers,
+                namespace: undefined,
             });
         }
         if (node.importClause?.namedBindings) {
@@ -29,6 +38,8 @@ export default visit(() => true, node => {
                     identifier: IMPORT_STAR,
                     pos: node.importClause.namedBindings.name.getStart(),
                     modifiers,
+                    alias: undefined,
+                    namespace: undefined,
                 });
             }
             if (ts.isNamedImports(node.importClause.namedBindings)) {
@@ -40,6 +51,8 @@ export default visit(() => true, node => {
                         symbol: element.symbol,
                         pos: element.name.getStart(),
                         modifiers,
+                        alias: undefined,
+                        namespace: undefined,
                     });
                 }
             }
@@ -49,6 +62,9 @@ export default visit(() => true, node => {
                     identifier: undefined,
                     pos: node.importClause.namedBindings.pos,
                     modifiers,
+                    alias: undefined,
+                    symbol: undefined,
+                    namespace: undefined,
                 });
             }
         }

package/dist/typescript/visitors/imports/importEqualsDeclaration.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { IMPORT_MODIFIERS } from '../../../constants.js';
+import { IMPORT_FLAGS } from '../../../constants.js';
 import { isNotJS } from '../helpers.js';
 import { importVisitor as visit } from '../index.js';
 export default visit(isNotJS, node => {
@@ -14,7 +14,8 @@ export default visit(isNotJS, node => {
             identifier: 'default',
             symbol: node.symbol,
             pos: node.name.getStart(),
-            modifiers: IMPORT_MODIFIERS.NONE,
+            modifiers: IMPORT_FLAGS.NONE,
+            namespace: undefined,
         };
     }
 });

package/dist/typescript/visitors/imports/reExportDeclaration.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { IMPORT_MODIFIERS, IMPORT_STAR } from '../../../constants.js';
+import { IMPORT_FLAGS, IMPORT_STAR } from '../../../constants.js';
 import { importVisitor as visit } from '../index.js';
 export default visit(() => true, node => {
     if (ts.isExportDeclaration(node)) {
@@ -9,7 +9,10 @@ export default visit(() => true, node => {
                     identifier: IMPORT_STAR,
                     specifier: node.moduleSpecifier.text,
                     pos: node.moduleSpecifier.getStart() - 7,
-                    modifiers: IMPORT_MODIFIERS.RE_EXPORT,
+                    modifiers: IMPORT_FLAGS.RE_EXPORT,
+                    alias: undefined,
+                    namespace: undefined,
+                    symbol: undefined,
                 };
             }
             if (node.exportClause.kind === ts.SyntaxKind.NamespaceExport) {
@@ -18,7 +21,9 @@ export default visit(() => true, node => {
                     namespace: String(node.exportClause.name.text),
                     specifier: node.moduleSpecifier.text,
                     pos: node.exportClause.name.getStart(),
-                    modifiers: IMPORT_MODIFIERS.RE_EXPORT,
+                    modifiers: IMPORT_FLAGS.RE_EXPORT,
+                    alias: undefined,
+                    symbol: undefined,
                 };
             }
             const specifier = node.moduleSpecifier;
@@ -29,14 +34,19 @@ export default visit(() => true, node => {
                         alias: String(element.name.text),
                         specifier: specifier.text,
                         pos: element.propertyName.getStart(),
-                        modifiers: IMPORT_MODIFIERS.RE_EXPORT,
+                        modifiers: IMPORT_FLAGS.RE_EXPORT,
+                        namespace: undefined,
+                        symbol: undefined,
                     };
                 }
                 return {
                     identifier: (element.propertyName ?? element.name).getText(),
                     specifier: specifier.text,
                     pos: element.name.getStart(),
-                    modifiers: IMPORT_MODIFIERS.RE_EXPORT,
+                    modifiers: IMPORT_FLAGS.RE_EXPORT,
+                    alias: undefined,
+                    namespace: undefined,
+                    symbol: undefined,
                 };
             });
         }

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

@@ -531,6 +531,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        swc?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         syncpack?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1142,6 +1147,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            swc?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             syncpack?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;

package/dist/util/errors.js

@@ -16,6 +16,8 @@ export const getKnownErrors = (error) => {
                 details.push(`location: ${error.path.join('.')}`);
             if (typeof error.expected === 'string')
                 details.push(`expected: ${error.expected}`);
+            if (Array.isArray(error.keys))
+                details.push(`${error.code}: ${error.keys.join(', ')}`);
             if (details.length > 0)
                 message += ` (${details.join(', ')})`;
             return new Error(message);

package/dist/util/get-referenced-inputs.js

@@ -47,9 +47,9 @@ export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue
                     }
                     return;
                 }
-                const ref = _resolveSync(specifier, dirname(containingFilePath));
-                if (ref && isInternal(ref) && !isGitIgnored(ref))
-                    return ref;
+                const internalPath = _resolveSync(specifier, dirname(containingFilePath));
+                if (internalPath && isInternal(internalPath) && !isGitIgnored(internalPath))
+                    return internalPath;
             }
             if (isHandled)
                 return;

package/dist/util/module-graph.d.ts

@@ -1,5 +1,4 @@
 import type { FileNode, IdToFileMap, IdToNsToFileMap, ImportMap, ImportMaps, ModuleGraph } from '../types/module-graph.js';
-export declare const getOrCreateFileNode: (graph: ModuleGraph, filePath: string) => FileNode;
 export declare const updateImportMap: (file: FileNode, importMap: ImportMap, graph: ModuleGraph) => void;
 export declare const createImports: () => ImportMaps;
 export declare const addValue: (map: IdToFileMap, id: string, value: string) => void;

package/dist/util/module-graph.js

@@ -1,4 +1,3 @@
-export const getOrCreateFileNode = (graph, filePath) => graph.get(filePath) ?? createFileNode();
 const updateImportMaps = (fromImportMaps, toImportMaps) => {
     for (const id of fromImportMaps.refs)
         toImportMaps.refs.add(id);
@@ -22,7 +21,7 @@ export const updateImportMap = (file, importMap, graph) => {
             file.imports.internal.set(importedFilePath, fileImportMaps);
         else
             updateImportMaps(fileImportMaps, importMaps);
-        const importedFile = getOrCreateFileNode(graph, importedFilePath);
+        const importedFile = graph.get(importedFilePath) ?? createFileNode();
         if (!importedFile.imported)
             importedFile.imported = createImports();
         updateImportMaps(fileImportMaps, importedFile.imported);
@@ -41,6 +40,8 @@ const createFileNode = () => ({
     exports: new Map(),
     duplicates: new Set(),
     scripts: new Set(),
+    imported: undefined,
+    internalImportCache: undefined,
 });
 export const createImports = () => ({
     refs: new Set(),

package/dist/util/modules.js

@@ -17,7 +17,13 @@ export const getPackageNameFromFilePath = (value) => {
     return value;
 };
 export const getPackageNameFromSpecifier = (specifier) => isInNodeModules(specifier) ? getPackageNameFromFilePath(specifier) : getPackageNameFromModuleSpecifier(specifier);
-export const isStartsLikePackageName = (specifier) => /^(@[a-z0-9._]|[a-z0-9])/i.test(specifier);
+const matchPackageNameStart = /^(@[a-z0-9._]|[a-z0-9])/i;
+export const isStartsLikePackageName = (specifier) => {
+    const ch = specifier.charCodeAt(0);
+    if (ch === 46 || ch === 47 || ch === 35 || ch === 126 || ch === 36)
+        return false;
+    return matchPackageNameStart.test(specifier);
+};
 export const stripVersionFromSpecifier = (specifier) => specifier.replace(/(\S+)@.*/, '$1');
 const stripNodeModulesFromPath = (command) => command.replace(/(?:\.{0,2}\/)*node_modules\//, '');
 export const extractBinary = (command) => stripVersionFromSpecifier(stripNodeModulesFromPath(command)

package/dist/util/resolve.js

@@ -24,8 +24,8 @@ const createSyncModuleResolver = (extensions) => {
     };
 };
 const resolveModuleSync = createSyncModuleResolver([...DEFAULT_EXTENSIONS, '.json', '.jsonc']);
-export const _resolveModuleSync = timerify(resolveModuleSync);
-export const _createSyncModuleResolver = extensions => timerify(createSyncModuleResolver(extensions));
+export const _resolveModuleSync = timerify(resolveModuleSync, 'resolveModuleSync');
+export const _createSyncModuleResolver = extensions => timerify(createSyncModuleResolver(extensions), 'resolveModuleSync');
 const createSyncResolver = (extensions) => {
     const resolver = new ResolverFactory({
         extensions,
@@ -40,5 +40,5 @@ const createSyncResolver = (extensions) => {
         catch (_error) { }
     };
 };
-const resolveSync = createSyncResolver(DEFAULT_EXTENSIONS);
+const resolveSync = createSyncResolver([...DEFAULT_EXTENSIONS, '.d.ts', '.d.mts', '.d.cts', '.json', '.jsonc']);
 export const _resolveSync = timerify(resolveSync);

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

@@ -1,6 +1,6 @@
 import type { CompilerOptions } from 'typescript';
 import type { ConfigurationChief, Workspace } from '../ConfigurationChief.js';
 export declare const augmentWorkspace: (workspace: Workspace, dir: string, compilerOptions: CompilerOptions) => void;
-export declare const getToSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
+export declare const getModuleSourcePathHandler: (chief: ConfigurationChief) => (filePath: string) => string | undefined;
 export declare const getToSourcePathsHandler: (chief: ConfigurationChief) => (specifiers: Set<string>, dir: string, extensions: string | undefined, label: string) => Promise<string[]>;
-export type ToSourceFilePath = ReturnType<typeof getToSourcePathHandler>;
+export type ToSourceFilePath = ReturnType<typeof getModuleSourcePathHandler>;