knip 5.69.1 → 5.70.0

package/dist/typescript/ast-helpers.js

@@ -115,6 +115,23 @@ export function findDescendants(node, callback) {
     visit(node);
     return results;
 }
+export const getLeadingComments = (sourceFile) => {
+    const text = sourceFile.text;
+    if (!text)
+        return [];
+    const firstStatement = sourceFile.statements[0];
+    const limit = firstStatement ? firstStatement.getStart() : text.length;
+    const ranges = ts.getLeadingCommentRanges(text, 0);
+    if (!ranges?.length)
+        return [];
+    const comments = [];
+    for (const range of ranges) {
+        if (range.end > limit)
+            break;
+        comments.push({ ...range, text: text.slice(range.pos, range.end) });
+    }
+    return comments;
+};
 export const isDeclarationFileExtension = (extension) => extension === '.d.ts' || extension === '.d.mts' || extension === '.d.cts';
 export const getJSDocTags = (node) => {
     const tags = new Set();
@@ -188,6 +205,13 @@ export const isConsiderReferencedNS = (node) => ts.isPropertyAssignment(node.par
     ts.isExportAssignment(node.parent) ||
     (ts.isVariableDeclaration(node.parent) && node.parent.initializer === node) ||
     ts.isTypeQueryNode(node.parent.parent);
+export const isInOpaqueExpression = (node) => ts.isAwaitExpression(node.parent)
+    ? isInOpaqueExpression(node.parent)
+    : ts.isCallExpression(node.parent) ||
+        ts.isReturnStatement(node.parent) ||
+        ts.isArrowFunction(node.parent) ||
+        ts.isPropertyAssignment(node.parent) ||
+        ts.isSpreadAssignment(node.parent.parent);
 const objectEnumerationMethods = new Set(['keys', 'entries', 'values', 'getOwnPropertyNames']);
 export const isObjectEnumerationCallExpressionArgument = (node) => ts.isCallExpression(node.parent) &&
     node.parent.arguments.includes(node) &&
@@ -275,14 +299,19 @@ export const getPropertyValues = (node, propertyName) => {
     }
     return values;
 };
+const isMatchAlias = (expression, identifier) => {
+    while (expression && ts.isAwaitExpression(expression))
+        expression = expression.expression;
+    return expression && ts.isIdentifier(expression) && expression.escapedText === identifier;
+};
 export const getAccessedIdentifiers = (identifier, scope) => {
     const identifiers = [];
     function visit(node) {
-        if (ts.isPropertyAccessExpression(node) && node.expression.getText() === identifier) {
+        if (ts.isPropertyAccessExpression(node) && isMatchAlias(node.expression, identifier)) {
             identifiers.push({ identifier: String(node.name.escapedText), pos: node.name.pos });
         }
         else if (ts.isElementAccessExpression(node) &&
-            node.expression.getText() === identifier &&
+            isMatchAlias(node.expression, identifier) &&
             ts.isStringLiteral(node.argumentExpression)) {
             identifiers.push({
                 identifier: stripQuotes(node.argumentExpression.text),
@@ -290,12 +319,12 @@ export const getAccessedIdentifiers = (identifier, scope) => {
             });
         }
         else if (ts.isVariableDeclaration(node) &&
-            node.initializer?.getText() === identifier &&
+            isMatchAlias(node.initializer, identifier) &&
             ts.isObjectBindingPattern(node.name)) {
             for (const element of node.name.elements) {
                 if (ts.isBindingElement(element)) {
                     const identifier = (element.propertyName ?? element.name).getText();
-                    identifiers.push({ identifier, pos: element.pos });
+                    identifiers.push({ identifier, pos: element.getStart() });
                 }
             }
         }

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,
@@ -143,7 +143,13 @@ const getImportsAndExports = (sourceFile, resolveModule, typeChecker, options, i
                     }
                     const pos = node.moduleSpecifier?.getStart() ?? opts.pos;
                     const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
-                    external.add({ specifier: sanitizedSpecifier, pos: opts.pos, line: line + 1, col: character + 2 });
+                    external.add({
+                        specifier: sanitizedSpecifier,
+                        identifier: opts.identifier ?? SIDE_EFFECTS,
+                        pos: opts.pos,
+                        line: line + 1,
+                        col: character + 2,
+                    });
                 }
             }
         }
@@ -154,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 }) => {
@@ -187,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);
@@ -208,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)) {
@@ -237,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);
@@ -313,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);
@@ -354,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/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)) {

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/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;

package/dist/util/module-graph.js

@@ -1,31 +1,31 @@
 export const getOrCreateFileNode = (graph, filePath) => graph.get(filePath) ?? createFileNode();
-const updateImportDetails = (importedModule, importItems) => {
-    for (const id of importItems.refs)
-        importedModule.refs.add(id);
-    for (const [id, v] of importItems.imported.entries())
-        addValues(importedModule.imported, id, v);
-    for (const [id, v] of importItems.importedAs.entries())
-        addNsValues(importedModule.importedAs, id, v);
-    for (const [id, v] of importItems.importedNs.entries())
-        addValues(importedModule.importedNs, id, v);
-    for (const [id, v] of importItems.reExported.entries())
-        addValues(importedModule.reExported, id, v);
-    for (const [id, v] of importItems.reExportedAs.entries())
-        addNsValues(importedModule.reExportedAs, id, v);
-    for (const [id, v] of importItems.reExportedNs.entries())
-        addValues(importedModule.reExportedNs, id, v);
+const updateImportMaps = (fromImportMaps, toImportMaps) => {
+    for (const id of fromImportMaps.refs)
+        toImportMaps.refs.add(id);
+    for (const [id, v] of fromImportMaps.imported.entries())
+        addValues(toImportMaps.imported, id, v);
+    for (const [id, v] of fromImportMaps.importedAs.entries())
+        addNsValues(toImportMaps.importedAs, id, v);
+    for (const [id, v] of fromImportMaps.importedNs.entries())
+        addValues(toImportMaps.importedNs, id, v);
+    for (const [id, v] of fromImportMaps.reExported.entries())
+        addValues(toImportMaps.reExported, id, v);
+    for (const [id, v] of fromImportMaps.reExportedAs.entries())
+        addNsValues(toImportMaps.reExportedAs, id, v);
+    for (const [id, v] of fromImportMaps.reExportedNs.entries())
+        addValues(toImportMaps.reExportedNs, id, v);
 };
 export const updateImportMap = (file, importMap, graph) => {
-    for (const [importedFilePath, importDetails] of importMap.entries()) {
-        const importedFileImports = file.imports.internal.get(importedFilePath);
-        if (!importedFileImports)
-            file.imports.internal.set(importedFilePath, importDetails);
+    for (const [importedFilePath, fileImportMaps] of importMap.entries()) {
+        const importMaps = file.imports.internal.get(importedFilePath);
+        if (!importMaps)
+            file.imports.internal.set(importedFilePath, fileImportMaps);
         else
-            updateImportDetails(importedFileImports, importDetails);
+            updateImportMaps(fileImportMaps, importMaps);
         const importedFile = getOrCreateFileNode(graph, importedFilePath);
         if (!importedFile.imported)
             importedFile.imported = createImports();
-        updateImportDetails(importedFile.imported, importDetails);
+        updateImportMaps(fileImportMaps, importedFile.imported);
         graph.set(importedFilePath, importedFile);
     }
 };
@@ -35,7 +35,7 @@ const createFileNode = () => ({
         external: new Set(),
         unresolved: new Set(),
         resolved: new Set(),
-        specifiers: new Set(),
+        imports: new Set(),
     },
     exports: new Map(),
     duplicates: new Set(),

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.69.1";
+export declare const version = "5.70.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '5.69.1';
+export const version = '5.70.0';