knip 5.69.0 → 5.70.0

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

@@ -1,6 +1,6 @@
 import { isBuiltin } from 'node:module';
 import ts from 'typescript';
-import { ALIAS_TAG, ANONYMOUS, IMPORT_MODIFIERS, IMPORT_STAR, PROTOCOL_VIRTUAL } from '../constants.js';
+import { ALIAS_TAG, IMPORT_MODIFIERS, 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';
@@ -8,9 +8,9 @@ import { dirname, isInNodeModules, resolve } from '../util/path.js';
 import { shouldIgnore } from '../util/tag.js';
 import { getAccessMembers, getDestructuredNames, getJSDocTags, getLineAndCharacterOfPosition, getTypeRef, isAccessExpression, isConsiderReferencedNS, isDestructuring, isImportSpecifier, isInForIteration, isObjectEnumerationCallExpressionArgument, isReferencedInExport, } from './ast-helpers.js';
 import { findInternalReferences, isType } from './find-internal-references.js';
+import { getImportsFromPragmas } from './pragmas/index.js';
 import getDynamicImportVisitors from './visitors/dynamic-imports/index.js';
 import getExportVisitors from './visitors/exports/index.js';
-import { getImportsFromPragmas } from './visitors/helpers.js';
 import getImportVisitors from './visitors/imports/index.js';
 import getScriptVisitors from './visitors/scripts/index.js';
 const getVisitors = (sourceFile) => ({
@@ -38,7 +38,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
     const external = new Set();
     const unresolved = new Set();
     const resolved = new Set();
-    const specifiers = new Set();
+    const imports = new Set();
     const exports = new Map();
     const aliasedExports = new Map();
     const scripts = new Set();
@@ -76,36 +76,37 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         }
     };
     const addInternalImport = (options) => {
-        const { identifier, symbol, filePath, namespace, alias, specifier } = options;
+        const { symbol, filePath, namespace, specifier, modifiers } = options;
+        const identifier = options.identifier ?? (modifiers & IMPORT_MODIFIERS.OPAQUE ? OPAQUE : SIDE_EFFECTS);
         const isStar = identifier === IMPORT_STAR;
-        specifiers.add([{ specifier, pos: options.pos, line: options.line, col: options.col }, filePath]);
+        imports.add([{ specifier, identifier, pos: options.pos, line: options.line, col: options.col }, filePath]);
         const file = internal.get(filePath);
-        const imports = file ?? createImports();
+        const importMaps = file ?? createImports();
         if (!file)
-            internal.set(filePath, imports);
-        const nsOrAlias = symbol ? String(symbol.escapedName) : alias;
-        if (options.modifiers & IMPORT_MODIFIERS.RE_EXPORT) {
+            internal.set(filePath, importMaps);
+        const nsOrAlias = symbol ? String(symbol.escapedName) : options.alias;
+        if (modifiers & IMPORT_MODIFIERS.RE_EXPORT) {
             if (isStar && namespace) {
-                addValue(imports.reExportedNs, namespace, sourceFile.fileName);
+                addValue(importMaps.reExportedNs, namespace, sourceFile.fileName);
             }
             else if (nsOrAlias) {
-                addNsValue(imports.reExportedAs, identifier, nsOrAlias, sourceFile.fileName);
+                addNsValue(importMaps.reExportedAs, identifier, nsOrAlias, sourceFile.fileName);
             }
             else {
-                addValue(imports.reExported, identifier, sourceFile.fileName);
+                addValue(importMaps.reExported, identifier, sourceFile.fileName);
             }
         }
         else {
             if (nsOrAlias && nsOrAlias !== identifier) {
                 if (isStar) {
-                    addValue(imports.importedNs, nsOrAlias, sourceFile.fileName);
+                    addValue(importMaps.importedNs, nsOrAlias, sourceFile.fileName);
                 }
                 else {
-                    addNsValue(imports.importedAs, identifier, nsOrAlias, sourceFile.fileName);
+                    addNsValue(importMaps.importedAs, identifier, nsOrAlias, sourceFile.fileName);
                 }
             }
-            else if (identifier !== ANONYMOUS && identifier !== IMPORT_STAR) {
-                addValue(imports.imported, identifier, sourceFile.fileName);
+            else if (identifier !== SIDE_EFFECTS && identifier !== IMPORT_STAR) {
+                addValue(importMaps.imported, identifier, sourceFile.fileName);
             }
             if (symbol)
                 importedInternalSymbols.set(symbol, filePath);
@@ -126,7 +127,6 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                     const { line, character } = node.getSourceFile().getLineAndCharacterOfPosition(opts.pos);
                     addInternalImport({
                         ...opts,
-                        identifier: opts.identifier ?? ANONYMOUS,
                         filePath,
                         line: line + 1,
                         col: character + 1,
@@ -135,18 +135,21 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 if (module.isExternalLibraryImport) {
                     if (options.skipTypeOnly && opts.modifiers & IMPORT_MODIFIERS.TYPE_ONLY)
                         return;
-                    const isInNM = isInNodeModules(opts.specifier);
-                    const sanitizedSpecifier = sanitizeSpecifier(isInNM || isInNodeModules(filePath) ? getPackageNameFromFilePath(opts.specifier) : opts.specifier);
+                    const sanitizedSpecifier = sanitizeSpecifier(isInNodeModules(filePath) || isInNodeModules(opts.specifier)
+                        ? getPackageNameFromFilePath(opts.specifier)
+                        : opts.specifier);
                     if (!isStartsLikePackageName(sanitizedSpecifier)) {
                         return;
                     }
-                    if (isInNM) {
-                        external.add({ specifier: sanitizedSpecifier });
-                    }
-                    else {
-                        const { line, character } = sourceFile.getLineAndCharacterOfPosition(opts.pos);
-                        external.add({ specifier: sanitizedSpecifier, pos: opts.pos, line: line + 1, col: character + 2 });
-                    }
+                    const pos = node.moduleSpecifier?.getStart() ?? opts.pos;
+                    const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
+                    external.add({
+                        specifier: sanitizedSpecifier,
+                        identifier: opts.identifier ?? SIDE_EFFECTS,
+                        pos: opts.pos,
+                        line: line + 1,
+                        col: character + 2,
+                    });
                 }
             }
         }
@@ -157,14 +160,19 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 return;
             if (opts.specifier.startsWith(PROTOCOL_VIRTUAL))
                 return;
-            const r = resolve(dirname(sourceFile.fileName), opts.specifier);
             if (opts.modifiers && opts.modifiers & IMPORT_MODIFIERS.OPTIONAL) {
-                resolved.add(r);
+                resolved.add(resolve(dirname(sourceFile.fileName), opts.specifier));
                 return;
             }
             const pos = 'moduleSpecifier' in node ? node.moduleSpecifier.pos : node.pos;
             const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
-            unresolved.add({ specifier: opts.specifier, pos, line: line + 1, col: character + 2 });
+            unresolved.add({
+                specifier: opts.specifier,
+                identifier: opts.identifier ?? SIDE_EFFECTS,
+                pos,
+                line: line + 1,
+                col: character + 2,
+            });
         }
     };
     const addExport = ({ node, symbol, identifier, type, pos, members = [], fix }) => {
@@ -190,13 +198,12 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         }
         const jsDocTags = getJSDocTags(node);
         const exportMembers = members.map(member => createMember(node, member, member.pos));
-        const isReExport = Boolean(node.parent?.parent && ts.isExportDeclaration(node.parent.parent) && node.parent.parent.moduleSpecifier);
         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;
-            exports.set(identifier, { ...item, members, jsDocTags: tags, fixes, isReExport });
+            exports.set(identifier, { ...item, members, jsDocTags: tags, fixes });
         }
         else {
             const { line, character } = node.getSourceFile().getLineAndCharacterOfPosition(pos);
@@ -211,7 +218,6 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 col: character + 1,
                 fixes: fix ? [fix] : [],
                 refs: [0, false],
-                isReExport,
             });
         }
         if (!jsDocTags.has(ALIAS_TAG)) {
@@ -240,6 +246,18 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 const result = visitor(node, options);
                 result && (Array.isArray(result) ? result.forEach(addExport) : addExport(result));
             }
+            if (ts.isImportEqualsDeclaration(node) &&
+                ts.isQualifiedName(node.moduleReference) &&
+                ts.isIdentifier(node.moduleReference.left)) {
+                const { left, right } = node.moduleReference;
+                const namespace = left.text;
+                const { filePath } = getImport(namespace, node);
+                if (filePath) {
+                    const internalImport = internal.get(filePath);
+                    if (internalImport)
+                        addNsMemberRefs(internalImport, namespace, right.text);
+                }
+            }
         }
         for (const visitor of visitors.dynamicImport) {
             const result = visitor(node, options);
@@ -316,19 +334,6 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                 }
             }
         }
-        if (isTopLevel &&
-            ts.isImportEqualsDeclaration(node) &&
-            ts.isQualifiedName(node.moduleReference) &&
-            ts.isIdentifier(node.moduleReference.left)) {
-            const { left, right } = node.moduleReference;
-            const namespace = left.text;
-            const { filePath } = getImport(namespace, node);
-            if (filePath) {
-                const internalImport = internal.get(filePath);
-                if (internalImport)
-                    addNsMemberRefs(internalImport, namespace, right.text);
-            }
-        }
         ts.forEachChild(node, visit);
     };
     visit(sourceFile);
@@ -357,7 +362,7 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
         item.symbol = undefined;
     }
     return {
-        imports: { internal, external, resolved, specifiers, unresolved },
+        imports: { internal, external, resolved, imports, unresolved },
         exports,
         duplicates: [...aliasedExports.values()],
         scripts,

package/dist/typescript/pragmas/custom.d.ts

@@ -0,0 +1,3 @@
+import type { ImportNode } from '../../types/imports.js';
+import type { BoundSourceFile } from '../SourceFile.js';
+export declare const collectCustomImports: (sourceFile: BoundSourceFile) => ImportNode[];

package/dist/typescript/pragmas/custom.js

@@ -0,0 +1,25 @@
+import { IMPORT_MODIFIERS } from '../../constants.js';
+import { getEnvSpecifier } from '../../plugins/vitest/helpers.js';
+import { isAbsolute, isInternal } from '../../util/path.js';
+import { getLeadingComments, stripQuotes } from '../ast-helpers.js';
+const VITEST_ENV = /@(vitest|jest)-environment\s+(\S+)/g;
+export const collectCustomImports = (sourceFile) => {
+    const comments = getLeadingComments(sourceFile);
+    if (!comments.length)
+        return [];
+    const importNodes = [];
+    for (const comment of comments) {
+        let match;
+        while ((match = VITEST_ENV.exec(comment.text)) !== null) {
+            const id = stripQuotes(match[2].trim());
+            if (!id)
+                continue;
+            const isLocal = isInternal(id) || isAbsolute(id);
+            const modifiers = isLocal ? IMPORT_MODIFIERS.ENTRY : IMPORT_MODIFIERS.NONE;
+            const offset = match[0].length - match[2].length;
+            const specifier = isLocal ? id : getEnvSpecifier(id);
+            importNodes.push({ specifier, identifier: undefined, pos: comment.pos + match.index + offset, modifiers });
+        }
+    }
+    return importNodes;
+};

package/dist/typescript/pragmas/index.d.ts

@@ -0,0 +1,3 @@
+import type { ImportNode } from '../../types/imports.js';
+import type { BoundSourceFile } from '../SourceFile.js';
+export declare const getImportsFromPragmas: (sourceFile: BoundSourceFile) => ImportNode[];

package/dist/typescript/pragmas/index.js

@@ -0,0 +1,3 @@
+import { collectCustomImports } from './custom.js';
+import { collectTypeScriptPragmaImports } from './typescript.js';
+export const getImportsFromPragmas = (sourceFile) => collectTypeScriptPragmaImports(sourceFile).concat(collectCustomImports(sourceFile));

package/dist/typescript/pragmas/typescript.d.ts

@@ -0,0 +1,3 @@
+import type { ImportNode } from '../../types/imports.js';
+import type { BoundSourceFile } from '../SourceFile.js';
+export declare const collectTypeScriptPragmaImports: (sourceFile: BoundSourceFile) => ImportNode[];

package/dist/typescript/pragmas/typescript.js

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

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

@@ -1,6 +1,6 @@
 import ts from 'typescript';
-import { ANONYMOUS, IMPORT_MODIFIERS } from '../../../constants.js';
-import { findAncestor, findDescendants, getAccessedIdentifiers, isAccessExpression, isImportCall, isTopLevel, stripQuotes, } from '../../ast-helpers.js';
+import { IMPORT_MODIFIERS } from '../../../constants.js';
+import { findAncestor, findDescendants, getAccessedIdentifiers, isAccessExpression, isImportCall, isInOpaqueExpression, isTopLevel, stripQuotes, } from '../../ast-helpers.js';
 import { importVisitor as visit } from '../index.js';
 const getSymbol = (node, isTopLevel) => (isTopLevel ? node.symbol : undefined);
 export default visit(() => true, node => {
@@ -58,7 +58,9 @@ export default visit(() => true, node => {
                     accessExpression.name &&
                     accessExpression.name.escapedText === 'catch'
                     ? node.parent.parent.parent.parent
-                    : node.parent.parent;
+                    : ts.isVariableDeclaration(node.parent)
+                        ? node.parent
+                        : node.parent.parent;
                 if (ts.isVariableDeclaration(variableDeclaration) &&
                     ts.isVariableDeclarationList(variableDeclaration.parent)) {
                     const isTLA = isTopLevel(variableDeclaration.parent);
@@ -85,10 +87,15 @@ 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.pos, modifiers };
+                            return { identifier, alias, symbol, specifier, pos: element.name.getStart(), modifiers };
                         });
                     }
-                    return { identifier: ANONYMOUS, specifier, pos: node.arguments[0].pos, modifiers };
+                    return {
+                        identifier: undefined,
+                        specifier,
+                        pos: node.arguments[0].pos,
+                        modifiers: IMPORT_MODIFIERS.SIDE_EFFECTS,
+                    };
                 }
                 const arrayLiteralExpression = node.parent;
                 const variableDeclarationParent = node.parent.parent?.parent?.parent;
@@ -106,18 +113,23 @@ 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.pos, modifiers };
+                                return { identifier, alias, symbol, specifier, pos: element.getStart(), modifiers };
                             });
                         }
                         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.pos, modifiers };
+                            return { identifier: 'default', symbol, alias, specifier, pos: element.getStart(), modifiers };
                         }
-                        return { identifier: 'default', specifier, pos: element.pos, modifiers };
+                        return { identifier: 'default', specifier, pos: element.getStart(), modifiers };
                     }
                 }
-                return { identifier: 'default', specifier, pos: node.arguments[0].pos, modifiers };
+                return {
+                    identifier: undefined,
+                    specifier,
+                    pos: node.arguments[0].pos,
+                    modifiers: isInOpaqueExpression(node) ? IMPORT_MODIFIERS.OPAQUE : IMPORT_MODIFIERS.SIDE_EFFECTS,
+                };
             }
             return { specifier, identifier: 'default', pos: node.arguments[0].pos, modifiers };
         }

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

@@ -7,7 +7,7 @@ export default visit(() => true, node => {
             return {
                 specifier: node.argument.literal.text,
                 identifier: undefined,
-                pos: 0,
+                pos: node.argument.literal.getStart(),
                 modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
             };
         }

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

@@ -12,7 +12,7 @@ export default visit(isModule, (node, { isFixExports, isFixTypes }) => {
                 const identifier = String(element.name.text);
                 const propName = element.propertyName?.text;
                 const symbol = declarations?.get(propName ?? identifier)?.[0]?.symbol;
-                const pos = element.name.pos;
+                const pos = element.name.getStart();
                 const type = element.isTypeOnly ? SYMBOL_TYPE.TYPE : nodeType;
                 const fix = (isFixExports && type !== SYMBOL_TYPE.TYPE) || (isFixTypes && type === SYMBOL_TYPE.TYPE)
                     ? [element.getStart(), element.getEnd(), FIX_FLAGS.OBJECT_BINDING | FIX_FLAGS.EMPTY_DECLARATION]

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

@@ -1,8 +1,6 @@
 import ts from 'typescript';
-import type { ImportNode } from '../../types/imports.js';
 import type { BoundSourceFile } from '../SourceFile.js';
 export declare const isNotJS: (sourceFile: BoundSourceFile) => boolean;
 export declare const isJS: (sourceFile: BoundSourceFile) => boolean;
 export declare const isModule: (sourceFile: BoundSourceFile) => boolean;
-export declare function getImportsFromPragmas(sourceFile: BoundSourceFile): ImportNode[];
 export declare function hasImportSpecifier(node: ts.Statement, name: string, id?: string): boolean;

package/dist/typescript/visitors/helpers.js

@@ -1,45 +1,7 @@
 import ts from 'typescript';
-import { IMPORT_MODIFIERS } from '../../constants.js';
 export const isNotJS = (sourceFile) => !isJS(sourceFile);
 export const isJS = (sourceFile) => sourceFile.scriptKind === ts.ScriptKind.JS || sourceFile.scriptKind === ts.ScriptKind.JSX;
 export const isModule = (sourceFile) => ts.isExternalModule(sourceFile);
-export function getImportsFromPragmas(sourceFile) {
-    const importNodes = [];
-    if (sourceFile.pragmas) {
-        const jsxImportSourcePragmas = sourceFile.pragmas.get('jsximportsource');
-        if (jsxImportSourcePragmas) {
-            const jsxImportSourcePragma = Array.isArray(jsxImportSourcePragmas)
-                ? jsxImportSourcePragmas[jsxImportSourcePragmas.length - 1]
-                : jsxImportSourcePragmas;
-            const { factory: specifier } = jsxImportSourcePragma?.arguments ?? {};
-            const pos = jsxImportSourcePragma.range?.pos ?? 0;
-            if (specifier)
-                importNodes.push({
-                    specifier,
-                    identifier: '__jsx',
-                    pos,
-                    modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
-                });
-        }
-        const referencePragma = sourceFile.pragmas.get('reference');
-        if (referencePragma) {
-            const refs = [referencePragma].flat();
-            for (const ref of refs) {
-                if (ref.arguments?.types) {
-                    const { value: specifier, pos } = ref.arguments.types;
-                    if (specifier)
-                        importNodes.push({
-                            specifier,
-                            identifier: undefined,
-                            pos,
-                            modifiers: IMPORT_MODIFIERS.TYPE_ONLY,
-                        });
-                }
-            }
-        }
-    }
-    return importNodes;
-}
 export function hasImportSpecifier(node, name, id) {
     return (ts.isImportDeclaration(node) &&
         ts.isStringLiteral(node.moduleSpecifier) &&

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

@@ -6,7 +6,7 @@ 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.NONE };
+            return { specifier, identifier: undefined, pos: node.pos, modifiers: IMPORT_MODIFIERS.SIDE_EFFECTS };
         }
         const imports = [];
         if (isDefaultImport(node)) {
@@ -15,7 +15,7 @@ export default visit(() => true, node => {
                 alias: String(node.importClause.name?.escapedText),
                 specifier,
                 symbol: node.importClause.symbol,
-                pos: node.moduleSpecifier.pos,
+                pos: node.importClause.name?.getStart() ?? node.getStart(),
                 modifiers: IMPORT_MODIFIERS.NONE,
             });
         }
@@ -26,7 +26,7 @@ export default visit(() => true, node => {
                     symbol,
                     specifier,
                     identifier: IMPORT_STAR,
-                    pos: symbol?.declarations[0]?.pos ?? node.pos,
+                    pos: node.importClause.namedBindings.name.getStart(),
                     modifiers: node.importClause?.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE,
                 });
             }
@@ -37,7 +37,7 @@ export default visit(() => true, node => {
                         identifier,
                         specifier,
                         symbol: element.symbol,
-                        pos: element.getStart(),
+                        pos: element.name.getStart(),
                         modifiers: node.importClause?.isTypeOnly ? IMPORT_MODIFIERS.TYPE_ONLY : IMPORT_MODIFIERS.NONE,
                     });
                 }

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

@@ -13,7 +13,7 @@ export default visit(isNotJS, node => {
             alias,
             identifier: 'default',
             symbol: node.symbol,
-            pos: node.moduleReference.expression.pos,
+            pos: node.name.getStart(),
             modifiers: IMPORT_MODIFIERS.NONE,
         };
     }

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

@@ -526,6 +526,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
             entry?: string | string[] | undefined;
             project?: string | string[] | undefined;
         } | undefined;
+        taskfile?: string | boolean | string[] | {
+            config?: string | string[] | undefined;
+            entry?: string | string[] | undefined;
+            project?: string | string[] | undefined;
+        } | undefined;
         travis?: string | boolean | string[] | {
             config?: string | string[] | undefined;
             entry?: string | string[] | undefined;
@@ -1117,6 +1122,11 @@ export declare const createOptions: (options: CreateOptions) => Promise<{
                 entry?: string | string[] | undefined;
                 project?: string | string[] | undefined;
             } | undefined;
+            taskfile?: string | boolean | string[] | {
+                config?: string | string[] | undefined;
+                entry?: string | string[] | undefined;
+                project?: string | string[] | undefined;
+            } | undefined;
             travis?: string | boolean | string[] | {
                 config?: string | string[] | undefined;
                 entry?: string | string[] | undefined;

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

@@ -23,6 +23,7 @@ export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue
             workspace: workspace.name,
             symbol: binaryName,
             specifier,
+            fixes: [],
         });
         return;
     }
@@ -41,6 +42,7 @@ export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue
                             workspace: inputWorkspace.name,
                             symbol: packageName ?? specifier,
                             specifier,
+                            fixes: [],
                         });
                     }
                     return;
@@ -71,6 +73,7 @@ export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue
             workspace: workspace.name,
             symbol: packageName ?? specifier,
             specifier,
+            fixes: [],
         });
     }
     else if (!isGitIgnored(filePath)) {
@@ -80,6 +83,7 @@ export const getReferencedInputsHandler = (deputy, chief, isGitIgnored, addIssue
                 filePath: containingFilePath,
                 workspace: workspace.name,
                 symbol: specifier,
+                fixes: [],
             });
         }
         else {

package/dist/util/has-strictly-ns-references.d.ts

@@ -1,4 +1,4 @@
-import type { ImportDetails, ModuleGraph } from '../types/module-graph.js';
-export declare const hasStrictlyEnumReferences: (importsForExport: ImportDetails | undefined, id: string) => boolean;
-export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportDetails | undefined, id: string) => [boolean, string?];
+import type { ImportMaps, ModuleGraph } from '../types/module-graph.js';
+export declare const hasStrictlyEnumReferences: (importsForExport: ImportMaps | undefined, id: string) => boolean;
+export declare const hasStrictlyNsReferences: (graph: ModuleGraph, importsForExport: ImportMaps | undefined, id: string) => [boolean, string?];
 export declare const getType: (hasOnlyNsReference: boolean, isType: boolean) => "exports" | "nsExports" | "types" | "nsTypes";

package/dist/util/is-identifier-referenced.js

@@ -1,4 +1,4 @@
-import { IMPORT_STAR } from '../constants.js';
+import { IMPORT_STAR, OPAQUE } from '../constants.js';
 import { addNodes, createNode } from './trace.js';
 export const getIsIdentifierReferencedHandler = (graph, entryPaths, isTrace) => {
     const isIdentifierReferenced = (filePath, id, isIncludeEntryExports = false, traceNode = createNode(filePath), seen = new Set()) => {
@@ -9,13 +9,14 @@ export const getIsIdentifierReferencedHandler = (graph, entryPaths, isTrace) =>
         if (!isIncludeEntryExports && reExportingEntryFile)
             return { isReferenced, reExportingEntryFile, traceNode };
         seen.add(filePath);
-        const ids = id.split('.');
-        const [identifier, ...rest] = ids;
+        const restIds = id.split('.');
+        const identifier = restIds.shift();
         const file = graph.get(filePath)?.imported;
-        if (!file)
+        if (!identifier || !file)
             return { isReferenced, reExportingEntryFile, traceNode };
-        if (((identifier !== id && file.refs.has(id)) || identifier === id) &&
-            (file.imported.has(identifier) || file.importedAs.has(identifier))) {
+        if (file.imported.get(OPAQUE) ||
+            ((identifier === id || (identifier !== id && file.refs.has(id))) &&
+                (file.imported.has(identifier) || file.importedAs.has(identifier)))) {
             isReferenced = true;
             if (!isTrace)
                 return { isReferenced, reExportingEntryFile, traceNode };
@@ -31,12 +32,11 @@ export const getIsIdentifierReferencedHandler = (graph, entryPaths, isTrace) =>
         for (const [exportId, aliases] of file.importedAs.entries()) {
             if (identifier === exportId) {
                 for (const alias of aliases.keys()) {
-                    const aliasedRef = [alias, ...rest].join('.');
+                    const aliasedRef = [alias, ...restIds].join('.');
                     if (file.refs.has(aliasedRef)) {
                         isReferenced = true;
-                        if (!isTrace) {
+                        if (!isTrace)
                             return { isReferenced, reExportingEntryFile, traceNode };
-                        }
                         addNodes(traceNode, aliasedRef, graph, aliases.get(alias));
                     }
                 }
@@ -93,7 +93,7 @@ export const getIsIdentifierReferencedHandler = (graph, entryPaths, isTrace) =>
                     if (!seen.has(byFilePath)) {
                         const child = createNode(byFilePath);
                         traceNode.children.add(child);
-                        const ref = [alias, ...rest].join('.');
+                        const ref = [alias, ...restIds].join('.');
                         const result = isIdentifierReferenced(byFilePath, ref, isIncludeEntryExports, child, seen);
                         if (result.reExportingEntryFile)
                             reExportingEntryFile = result.reExportingEntryFile;

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

@@ -1,6 +1,6 @@
-import type { FileNode, IdToFileMap, IdToNsToFileMap, ImportDetails, ImportMap, ModuleGraph } from '../types/module-graph.js';
+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: () => ImportDetails;
+export declare const createImports: () => ImportMaps;
 export declare const addValue: (map: IdToFileMap, id: string, value: string) => void;
 export declare const addNsValue: (map: IdToNsToFileMap, id: string, ns: string, value: string) => void;