knip 5.73.3 → 5.74.0

package/dist/typescript/ast-helpers.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { FIX_FLAGS, SYMBOL_TYPE } from '../constants.js';
+import { FIX_FLAGS, MEMBER_FLAGS, SYMBOL_TYPE } from '../constants.js';
 function isGetOrSetAccessorDeclaration(node) {
     return node.kind === ts.SyntaxKind.SetAccessor || node.kind === ts.SyntaxKind.GetAccessor;
 }
@@ -48,7 +48,7 @@ export const getNodeType = (node) => {
         return SYMBOL_TYPE.VARIABLE;
     return SYMBOL_TYPE.UNKNOWN;
 };
-export const isNonPrivatePropertyOrMethodDeclaration = (member) => (ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member) || isGetOrSetAccessorDeclaration(member)) &&
+export const isNonPrivateDeclaration = (member) => (ts.isPropertyDeclaration(member) || ts.isMethodDeclaration(member) || isGetOrSetAccessorDeclaration(member)) &&
     !isPrivateMember(member);
 export const getClassMember = (member, isFixTypes) => ({
     node: member,
@@ -56,6 +56,7 @@ export const getClassMember = (member, isFixTypes) => ({
     pos: member.name.getStart() + (ts.isComputedPropertyName(member.name) ? 1 : 0),
     type: SYMBOL_TYPE.MEMBER,
     fix: isFixTypes ? [member.getStart(), member.getEnd(), FIX_FLAGS.NONE] : undefined,
+    flags: member.kind === ts.SyntaxKind.SetAccessor ? MEMBER_FLAGS.SETTER : MEMBER_FLAGS.NONE,
 });
 export const getEnumMember = (member, isFixTypes) => ({
     node: member,
@@ -65,6 +66,7 @@ export const getEnumMember = (member, isFixTypes) => ({
     fix: isFixTypes
         ? [member.getStart(), member.getEnd(), FIX_FLAGS.OBJECT_BINDING | FIX_FLAGS.WITH_NEWLINE]
         : undefined,
+    flags: MEMBER_FLAGS.NONE,
 });
 export function stripQuotes(name) {
     const length = name.length;
@@ -202,6 +204,7 @@ export const isConsiderReferencedNS = (node) => ts.isPropertyAssignment(node.par
     ts.isSpreadAssignment(node.parent) ||
     ts.isArrayLiteralExpression(node.parent) ||
     ts.isExportAssignment(node.parent) ||
+    (ts.isBindingElement(node.parent) && node.parent.initializer === node) ||
     ts.isTypeQueryNode(node.parent.parent);
 export const isInOpaqueExpression = (node) => ts.isAwaitExpression(node.parent)
     ? isInOpaqueExpression(node.parent)

package/dist/typescript/create-hosts.d.ts

@@ -7,12 +7,11 @@ type CreateHostsOptions = {
     compilerOptions: ts.CompilerOptions;
     entryPaths: Set<string>;
     compilers: [SyncCompilers, AsyncCompilers];
-    isSkipLibs: boolean;
     toSourceFilePath: ToSourceFilePath;
     useResolverCache: boolean;
     fileManager: SourceFileManager;
 };
-export declare const createHosts: ({ cwd, compilerOptions, fileManager, entryPaths, compilers, isSkipLibs, toSourceFilePath, useResolverCache, }: CreateHostsOptions) => {
+export declare const createHosts: ({ cwd, compilerOptions, fileManager, entryPaths, compilers, toSourceFilePath, useResolverCache, }: CreateHostsOptions) => {
     fileManager: SourceFileManager;
     compilerHost: ts.CompilerHost;
     resolveModuleNames: (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModuleFull | undefined>;

package/dist/typescript/create-hosts.js

@@ -4,9 +4,9 @@ import ts from 'typescript';
 import { getCompilerExtensions } from '../compilers/index.js';
 import { createCustomModuleResolver } from './resolve-module-names.js';
 const libLocation = path.dirname(ts.getDefaultLibFilePath({}));
-export const createHosts = ({ cwd, compilerOptions, fileManager, entryPaths, compilers, isSkipLibs, toSourceFilePath, useResolverCache, }) => {
+export const createHosts = ({ cwd, compilerOptions, fileManager, entryPaths, compilers, toSourceFilePath, useResolverCache, }) => {
     const compilerExtensions = getCompilerExtensions(compilers);
-    const resolveModuleNames = createCustomModuleResolver(compilerOptions, compilerExtensions, toSourceFilePath, useResolverCache, isSkipLibs);
+    const resolveModuleNames = createCustomModuleResolver(compilerOptions, compilerExtensions, toSourceFilePath, useResolverCache);
     const languageServiceHost = {
         getCompilationSettings: () => compilerOptions,
         getScriptFileNames: () => Array.from(entryPaths),

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

@@ -1,6 +1,6 @@
 import { isBuiltin } from 'node:module';
 import ts from 'typescript';
-import { ALIAS_TAG, IMPORT_MODIFIERS, IMPORT_STAR, OPAQUE, PROTOCOL_VIRTUAL, SIDE_EFFECTS } from '../constants.js';
+import { ALIAS_TAG, IMPORT_FLAGS, IMPORT_STAR, OPAQUE, PROTOCOL_VIRTUAL, SIDE_EFFECTS } from '../constants.js';
 import { addNsValue, addValue, createImports } from '../util/module-graph.js';
 import { getPackageNameFromFilePath, isStartsLikePackageName, sanitizeSpecifier } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
@@ -31,6 +31,7 @@ const createMember = (node, member, pos) => {
         fix: member.fix,
         self: [0, false],
         jsDocTags: getJSDocTags(member.node),
+        flags: member.flags,
     };
 };
 const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, ignoreExportsUsedInFile, skipExports) => {
@@ -83,7 +84,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
     };
     const addInternalImport = (options) => {
         const { symbol, filePath, namespace, specifier, modifiers } = options;
-        const identifier = options.identifier ?? (modifiers & IMPORT_MODIFIERS.OPAQUE ? OPAQUE : SIDE_EFFECTS);
+        const identifier = options.identifier ?? (modifiers & IMPORT_FLAGS.OPAQUE ? OPAQUE : SIDE_EFFECTS);
         const isStar = identifier === IMPORT_STAR;
         imports.add({
             filePath,
@@ -92,14 +93,14 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
             pos: options.pos,
             line: options.line,
             col: options.col,
-            isTypeOnly: !!(modifiers & IMPORT_MODIFIERS.TYPE_ONLY),
+            isTypeOnly: !!(modifiers & IMPORT_FLAGS.TYPE_ONLY),
         });
         const file = internal.get(filePath);
         const importMaps = file ?? createImports();
         if (!file)
             internal.set(filePath, importMaps);
         const nsOrAlias = symbol ? String(symbol.escapedName) : options.alias;
-        if (modifiers & IMPORT_MODIFIERS.RE_EXPORT) {
+        if (modifiers & IMPORT_FLAGS.RE_EXPORT) {
             if (isStar && namespace) {
                 addValue(importMaps.reExportedNs, namespace, sourceFile.fileName);
             }
@@ -134,9 +135,9 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
             const filePath = module.resolvedFileName;
             if (filePath) {
                 if (!isInNodeModules(filePath)) {
-                    if (opts.modifiers & IMPORT_MODIFIERS.ENTRY)
+                    if (opts.modifiers & IMPORT_FLAGS.ENTRY)
                         entryFiles.add(filePath);
-                    if (opts.modifiers & IMPORT_MODIFIERS.BRIDGE)
+                    if (opts.modifiers & IMPORT_FLAGS.BRIDGE)
                         programFiles.add(filePath);
                 }
                 if (!module.isExternalLibraryImport || !isInNodeModules(filePath)) {
@@ -149,7 +150,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                     });
                 }
                 if (module.isExternalLibraryImport) {
-                    if (options.skipTypeOnly && opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY)
+                    if (options.skipTypeOnly && opts.modifiers & IMPORT_FLAGS.TYPE_ONLY)
                         return;
                     const sanitizedSpecifier = sanitizeSpecifier(isInNodeModules(filePath) || isInNodeModules(opts.specifier)
                         ? getPackageNameFromFilePath(opts.specifier)
@@ -166,19 +167,19 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                         pos: opts.pos,
                         line: line + 1,
                         col: character + 2,
-                        isTypeOnly: !!(opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY),
+                        isTypeOnly: !!(opts.modifiers & IMPORT_FLAGS.TYPE_ONLY),
                     });
                 }
             }
         }
         else {
-            if (options.skipTypeOnly && opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY)
+            if (options.skipTypeOnly && opts.modifiers & IMPORT_FLAGS.TYPE_ONLY)
                 return;
             if (shouldIgnore(getJSDocTags(node), options.tags))
                 return;
             if (opts.specifier.startsWith(PROTOCOL_VIRTUAL))
                 return;
-            if (opts.modifiers && opts.modifiers & IMPORT_MODIFIERS.OPTIONAL) {
+            if (opts.modifiers && opts.modifiers & IMPORT_FLAGS.OPTIONAL) {
                 programFiles.add(resolve(dirname(sourceFile.fileName), opts.specifier));
                 return;
             }
@@ -191,11 +192,11 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 pos,
                 line: line + 1,
                 col: character + 2,
-                isTypeOnly: !!(opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY),
+                isTypeOnly: !!(opts.modifiers & IMPORT_FLAGS.TYPE_ONLY),
             });
         }
     };
-    const addExport = ({ node, symbol, identifier, type, pos, members = [], fix }) => {
+    const addExport = ({ node, symbol, identifier, type, pos, members, fix }) => {
         if (skipExports)
             return;
         let isReExport = Boolean(node.parent?.parent && ts.isExportDeclaration(node.parent.parent) && node.parent.parent.moduleSpecifier);
@@ -222,9 +223,9 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         const exportMembers = members.map(member => createMember(node, member, member.pos));
         const item = exports.get(identifier);
         if (item) {
-            const members = [...(item.members ?? []), ...exportMembers];
-            const tags = new Set([...(item.jsDocTags ?? []), ...jsDocTags]);
-            const fixes = fix ? [...(item.fixes ?? []), fix] : item.fixes;
+            const members = [...item.members, ...exportMembers];
+            const tags = new Set([...item.jsDocTags, ...jsDocTags]);
+            const fixes = fix ? [...item.fixes, fix] : item.fixes;
             exports.set(identifier, { ...item, members, jsDocTags: tags, fixes, isReExport });
         }
         else {
@@ -448,6 +449,8 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         exports,
         duplicates: [...aliasedExports.values()],
         scripts,
+        imported: undefined,
+        internalImportCache: undefined,
     };
 };
 export const _getImportsAndExports = timerify(getImportsAndExports);

package/dist/typescript/pragmas/custom.js

@@ -1,4 +1,4 @@
-import { IMPORT_MODIFIERS } from '../../constants.js';
+import { IMPORT_FLAGS } from '../../constants.js';
 import { getEnvSpecifier } from '../../plugins/vitest/helpers.js';
 import { isAbsolute, isInternal } from '../../util/path.js';
 import { getLeadingComments, stripQuotes } from '../ast-helpers.js';
@@ -15,10 +15,18 @@ export const collectCustomImports = (sourceFile) => {
             if (!id)
                 continue;
             const isLocal = isInternal(id) || isAbsolute(id);
-            const modifiers = isLocal ? IMPORT_MODIFIERS.ENTRY : IMPORT_MODIFIERS.NONE;
+            const modifiers = isLocal ? IMPORT_FLAGS.ENTRY : IMPORT_FLAGS.NONE;
             const offset = match[0].length - match[2].length;
             const specifier = isLocal || id === 'node' ? id : getEnvSpecifier(id);
-            importNodes.push({ specifier, identifier: undefined, pos: comment.pos + match.index + offset, modifiers });
+            importNodes.push({
+                specifier,
+                identifier: undefined,
+                pos: comment.pos + match.index + offset,
+                modifiers,
+                alias: undefined,
+                namespace: undefined,
+                symbol: undefined,
+            });
         }
     }
     return importNodes;

package/dist/typescript/pragmas/typescript.js

@@ -1,9 +1,9 @@
-import { IMPORT_MODIFIERS } from '../../constants.js';
+import { IMPORT_FLAGS } from '../../constants.js';
 export const collectTypeScriptPragmaImports = (sourceFile) => {
     if (!sourceFile.pragmas || sourceFile.pragmas.size === 0)
         return [];
     const importNodes = [];
-    const modifiers = IMPORT_MODIFIERS.TYPE_ONLY;
+    const modifiers = IMPORT_FLAGS.TYPE_ONLY;
     const jsxImportSourcePragmas = sourceFile.pragmas.get('jsximportsource');
     if (jsxImportSourcePragmas) {
         const jsxImportSourcePragma = Array.isArray(jsxImportSourcePragmas)
@@ -12,7 +12,15 @@ export const collectTypeScriptPragmaImports = (sourceFile) => {
         const { factory: specifier } = jsxImportSourcePragma?.arguments ?? {};
         const pos = jsxImportSourcePragma.range?.pos ?? 0;
         if (specifier)
-            importNodes.push({ specifier, identifier: undefined, pos, modifiers });
+            importNodes.push({
+                specifier,
+                identifier: undefined,
+                pos,
+                modifiers,
+                alias: undefined,
+                namespace: undefined,
+                symbol: undefined,
+            });
     }
     const referencePragma = sourceFile.pragmas.get('reference');
     if (referencePragma) {
@@ -21,7 +29,15 @@ export const collectTypeScriptPragmaImports = (sourceFile) => {
             if (ref.arguments?.types) {
                 const { value: specifier, pos } = ref.arguments.types;
                 if (specifier)
-                    importNodes.push({ specifier, identifier: undefined, pos, modifiers });
+                    importNodes.push({
+                        specifier,
+                        identifier: undefined,
+                        pos,
+                        modifiers,
+                        alias: undefined,
+                        namespace: undefined,
+                        symbol: undefined,
+                    });
             }
         }
     }

package/dist/typescript/resolve-module-names.d.ts

@@ -1,4 +1,4 @@
 import ts from 'typescript';
 import type { ToSourceFilePath } from '../util/to-source-path.js';
 export type ResolveModuleNames = ReturnType<typeof createCustomModuleResolver>;
-export declare function createCustomModuleResolver(compilerOptions: ts.CompilerOptions, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, useCache?: boolean, isSkipLibs?: boolean): (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModuleFull | undefined>;
+export declare function createCustomModuleResolver(compilerOptions: ts.CompilerOptions, customCompilerExtensions: string[], toSourceFilePath: ToSourceFilePath, useCache?: boolean): (moduleNames: string[], containingFile: string) => Array<ts.ResolvedModuleFull | undefined>;

package/dist/typescript/resolve-module-names.js

@@ -8,7 +8,7 @@ import { dirname, extname, isAbsolute, isInNodeModules, join } from '../util/pat
 import { _createSyncModuleResolver, _resolveModuleSync } from '../util/resolve.js';
 import { isDeclarationFileExtension } from './ast-helpers.js';
 const resolutionCache = new Map();
-const fileExists = (name, containingFile) => {
+const moduleIfFileExists = (name, containingFile) => {
     const resolvedFileName = isAbsolute(name) ? name : join(dirname(containingFile), name);
     if (existsSync(resolvedFileName)) {
         return {
@@ -20,7 +20,7 @@ const fileExists = (name, containingFile) => {
     }
 };
 const tsResolveModuleName = timerify(ts.resolveModuleName);
-export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, useCache = true, isSkipLibs = true) {
+export function createCustomModuleResolver(compilerOptions, customCompilerExtensions, toSourceFilePath, useCache = true) {
     const customCompilerExtensionsSet = new Set(customCompilerExtensions);
     const extensions = [...DEFAULT_EXTENSIONS, ...customCompilerExtensions];
     const resolveSync = customCompilerExtensionsSet.size === 0 ? _resolveModuleSync : _createSyncModuleResolver(extensions);
@@ -28,9 +28,8 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
     const tsSys = {
         ...ts.sys,
         fileExists(path) {
-            if (ts.sys.fileExists(path)) {
+            if (ts.sys.fileExists(path))
                 return true;
-            }
             const original = originalFromDeclarationPath(path);
             if (original && ts.sys.fileExists(original.path)) {
                 virtualDeclarationFiles.set(path, original);
@@ -58,7 +57,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
         const sanitizedSpecifier = sanitizeSpecifier(name);
         if (isBuiltin(sanitizedSpecifier))
             return undefined;
-        const resolvedFileName = isSkipLibs && resolveSync(sanitizedSpecifier, containingFile);
+        const resolvedFileName = resolveSync(sanitizedSpecifier, containingFile);
         if (resolvedFileName) {
             const ext = extname(resolvedFileName);
             if (!customCompilerExtensionsSet.has(ext)) {
@@ -102,10 +101,7 @@ export function createCustomModuleResolver(compilerOptions, customCompilerExtens
             }
             return tsResolvedModule;
         }
-        const module = fileExists(sanitizedSpecifier, containingFile);
-        if (module)
-            return module;
-        return undefined;
+        return moduleIfFileExists(sanitizedSpecifier, containingFile);
     }
     return timerify(resolveModuleNames);
 }

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { IMPORT_MODIFIERS } from '../../../constants.js';
+import { IMPORT_FLAGS } from '../../../constants.js';
 import { findAncestor, findDescendants, getAccessedIdentifiers, getThenBindings, isAccessExpression, isImportCall, isInOpaqueExpression, isTopLevel, stripQuotes, } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
 const getSymbol = (node, isTopLevel) => (isTopLevel ? node.symbol : undefined);
@@ -7,7 +7,7 @@ export default visit(() => true, node => {
     if (isImportCall(node)) {
         if (node.arguments[0] && ts.isStringLiteralLike(node.arguments[0])) {
             const specifier = node.arguments[0].text;
-            const modifiers = IMPORT_MODIFIERS.NONE;
+            const modifiers = IMPORT_FLAGS.NONE;
             if (specifier) {
                 const accessExpression = findAncestor(node, _node => {
                     if (ts.isExpressionStatement(_node) || ts.isCallExpression(_node))
@@ -23,20 +23,51 @@ export default visit(() => true, node => {
                             if (ts.isCallExpression(callExpression)) {
                                 const accessed = getThenBindings(callExpression);
                                 if (accessed && accessed.length > 0) {
-                                    return accessed.map(acc => ({ ...acc, specifier, modifiers }));
+                                    return accessed.map(acc => ({
+                                        ...acc,
+                                        specifier,
+                                        modifiers,
+                                        alias: undefined,
+                                        namespace: undefined,
+                                        symbol: undefined,
+                                    }));
                                 }
                             }
-                            return { identifier: 'default', specifier, pos, modifiers };
+                            return {
+                                identifier: 'default',
+                                specifier,
+                                pos,
+                                modifiers,
+                                alias: undefined,
+                                namespace: undefined,
+                                symbol: undefined,
+                            };
                         }
                         if (identifier !== 'catch')
-                            return { identifier, specifier, pos, modifiers };
+                            return {
+                                identifier,
+                                specifier,
+                                pos,
+                                modifiers,
+                                alias: undefined,
+                                namespace: undefined,
+                                symbol: undefined,
+                            };
                     }
                     if (ts.isElementAccessExpression(accessExpression) &&
                         ts.isStringLiteral(accessExpression.argumentExpression)) {
                         const name = stripQuotes(accessExpression.argumentExpression.text);
                         const pos = accessExpression.argumentExpression.pos;
                         const identifier = name;
-                        return { identifier, specifier, pos, modifiers };
+                        return {
+                            identifier,
+                            specifier,
+                            pos,
+                            modifiers,
+                            alias: undefined,
+                            namespace: undefined,
+                            symbol: undefined,
+                        };
                     }
                 }
                 const variableDeclaration = accessExpression &&
@@ -63,9 +94,18 @@ export default visit(() => true, node => {
                                 specifier,
                                 pos: acc.pos,
                                 modifiers,
+                                namespace: undefined,
                             }));
                         }
-                        return { identifier: 'default', alias, symbol, specifier, pos: node.arguments[0].pos, modifiers };
+                        return {
+                            identifier: 'default',
+                            alias,
+                            symbol,
+                            specifier,
+                            pos: node.arguments[0].pos,
+                            modifiers,
+                            namespace: undefined,
+                        };
                     }
                     const bindings = findDescendants(variableDeclaration, ts.isBindingElement);
                     if (bindings.length > 0) {
@@ -73,14 +113,25 @@ export default visit(() => true, node => {
                             const identifier = (element.propertyName ?? element.name).getText();
                             const alias = element.propertyName ? element.name.getText() : undefined;
                             const symbol = getSymbol(element, isTLA);
-                            return { identifier, alias, symbol, specifier, pos: element.name.getStart(), modifiers };
+                            return {
+                                identifier,
+                                alias,
+                                symbol,
+                                specifier,
+                                pos: element.name.getStart(),
+                                modifiers,
+                                namespace: undefined,
+                            };
                         });
                     }
                     return {
                         identifier: undefined,
                         specifier,
                         pos: node.arguments[0].pos,
-                        modifiers: IMPORT_MODIFIERS.SIDE_EFFECTS,
+                        modifiers: IMPORT_FLAGS.SIDE_EFFECTS,
+                        alias: undefined,
+                        namespace: undefined,
+                        symbol: undefined,
                     };
                 }
                 const arrayLiteralExpression = node.parent;
@@ -99,25 +150,60 @@ export default visit(() => true, node => {
                                 const identifier = (element.propertyName ?? element.name).getText();
                                 const alias = element.propertyName ? element.name.getText() : undefined;
                                 const symbol = getSymbol(element, isTL);
-                                return { identifier, alias, symbol, specifier, pos: element.getStart(), modifiers };
+                                return {
+                                    identifier,
+                                    alias,
+                                    symbol,
+                                    specifier,
+                                    pos: element.getStart(),
+                                    modifiers,
+                                    namespace: undefined,
+                                };
                             });
                         }
                         if (!ts.isOmittedExpression(element) && ts.isIdentifier(element.name)) {
                             const alias = String(element.name.escapedText);
                             const symbol = getSymbol(element, isTL);
-                            return { identifier: 'default', symbol, alias, specifier, pos: element.getStart(), modifiers };
+                            return {
+                                identifier: 'default',
+                                symbol,
+                                alias,
+                                specifier,
+                                pos: element.getStart(),
+                                modifiers,
+                                namespace: undefined,
+                            };
                         }
-                        return { identifier: 'default', specifier, pos: element.getStart(), modifiers };
+                        return {
+                            identifier: 'default',
+                            specifier,
+                            pos: element.getStart(),
+                            modifiers,
+                            alias: undefined,
+                            namespace: undefined,
+                            symbol: undefined,
+                        };
                     }
                 }
                 return {
                     identifier: undefined,
                     specifier,
                     pos: node.arguments[0].pos,
-                    modifiers: isInOpaqueExpression(node) ? IMPORT_MODIFIERS.OPAQUE : IMPORT_MODIFIERS.SIDE_EFFECTS,
+                    modifiers: isInOpaqueExpression(node) ? IMPORT_FLAGS.OPAQUE : IMPORT_FLAGS.SIDE_EFFECTS,
+                    alias: undefined,
+                    namespace: undefined,
+                    symbol: undefined,
                 };
             }
-            return { specifier, identifier: 'default', pos: node.arguments[0].pos, modifiers };
+            return {
+                specifier,
+                identifier: 'default',
+                pos: node.arguments[0].pos,
+                modifiers,
+                alias: undefined,
+                namespace: undefined,
+                symbol: undefined,
+            };
         }
     }
 });

package/dist/typescript/visitors/dynamic-imports/importType.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.isImportTypeNode(node)) {
@@ -8,7 +8,10 @@ export default visit(() => true, node => {
                 specifier: node.argument.literal.text,
                 identifier: undefined,
                 pos: node.argument.literal.getStart(),
-                modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
+                modifiers: IMPORT_FLAGS.TYPE_ONLY,
+                alias: undefined,
+                namespace: undefined,
+                symbol: undefined,
             };
         }
     }

package/dist/typescript/visitors/dynamic-imports/jsDocType.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';
 const supportsJSDocImportTag = 'isJSDocImportTag' in ts;
 const getImportSpecifiers = (node) => {
@@ -13,7 +13,10 @@ const getImportSpecifiers = (node) => {
                     specifier: importClause.literal.text,
                     identifier,
                     pos: node.qualifier?.getStart() ?? importClause.literal.pos,
-                    modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
+                    modifiers: IMPORT_FLAGS.TYPE_ONLY,
+                    alias: undefined,
+                    namespace: undefined,
+                    symbol: undefined,
                 });
             }
         }
@@ -27,7 +30,10 @@ const getImportSpecifiers = (node) => {
                         specifier: moduleSpecifier.text,
                         identifier: IMPORT_STAR,
                         pos: bindings.name.getStart(),
-                        modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
+                        modifiers: IMPORT_FLAGS.TYPE_ONLY,
+                        alias: undefined,
+                        namespace: undefined,
+                        symbol: undefined,
                     });
                 }
                 else {
@@ -36,7 +42,10 @@ const getImportSpecifiers = (node) => {
                             specifier: moduleSpecifier.text,
                             identifier: String((element.propertyName ?? element.name).escapedText),
                             pos: element.name.getStart(),
-                            modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
+                            modifiers: IMPORT_FLAGS.TYPE_ONLY,
+                            alias: undefined,
+                            namespace: undefined,
+                            symbol: undefined,
                         });
                     }
                 }