@knighted/module 1.0.0-rc.1 → 1.0.0-rc.3

package/dist/module.js

@@ -4,16 +4,158 @@ import { specifier } from './specifier.js';
 import { parse } from '#parse';
 import { format } from '#format';
 import { getLangFromExt } from '#utils/lang.js';
+import { builtinModules } from 'node:module';
+import { resolve as pathResolve, dirname as pathDirname, extname, join } from 'node:path';
+import { readFile as fsReadFile, stat } from 'node:fs/promises';
+import { parse as parseModule } from '#parse';
+import { walk } from '#walk';
+const collapseSpecifier = value => value.replace(/['"`+)\s]|new String\(/g, '');
+const builtinSpecifiers = new Set(builtinModules.map(mod => mod.startsWith('node:') ? mod.slice(5) : mod).flatMap(mod => {
+  const parts = mod.split('/');
+  const base = parts[0];
+  return parts.length > 1 ? [mod, base] : [mod];
+}));
+const appendExtensionIfNeeded = (spec, mode, dirIndex, value = spec.value) => {
+  if (mode === 'off') return;
+  if (spec.type === 'TemplateLiteral') {
+    const node = spec.node;
+    if (node.expressions.length > 0) return;
+  } else if (spec.type !== 'StringLiteral') {
+    return;
+  }
+  const collapsed = collapseSpecifier(value);
+  const isRelative = /^(?:\.\.?)\//.test(collapsed);
+  if (!isRelative) return;
+  const base = collapsed.split(/[?#]/)[0];
+  if (!base) return;
+  if (base.endsWith('/')) {
+    if (!dirIndex) return;
+    return `${value}${dirIndex}`;
+  }
+  const lastSegment = base.split('/').pop() ?? '';
+  if (lastSegment.includes('.')) return;
+  return `${value}.js`;
+};
+const rewriteSpecifierValue = (value, rewriteSpecifier) => {
+  if (!rewriteSpecifier) return;
+  if (typeof rewriteSpecifier === 'function') {
+    return rewriteSpecifier(value) ?? undefined;
+  }
+  const collapsed = collapseSpecifier(value);
+  const relative = /^(?:\.\.?)\//;
+  if (relative.test(collapsed)) {
+    return value.replace(/(.+)\.(?:m|c)?(?:j|t)s([)'"]*)?$/, `$1${rewriteSpecifier}$2`);
+  }
+};
+const normalizeBuiltinSpecifier = value => {
+  const collapsed = collapseSpecifier(value);
+  if (!collapsed) return;
+  const specPart = collapsed.split(/[?#]/)[0] ?? '';
+
+  // Ignore relative and absolute paths.
+  if (/^(?:\.\.?\/|\/)/.test(specPart)) return;
+
+  // Skip other protocols (e.g., http:, data:) but allow node:.
+  if (/^[a-zA-Z][a-zA-Z+.-]*:/.test(specPart) && !specPart.startsWith('node:')) return;
+  const bare = specPart.startsWith('node:') ? specPart.slice(5) : specPart;
+  const base = bare.split('/')[0] ?? '';
+  if (!builtinSpecifiers.has(bare) && !builtinSpecifiers.has(base)) return;
+  if (specPart.startsWith('node:')) return;
+  const quote = /^['"`]/.exec(value)?.[0] ?? '';
+  return quote ? `${quote}node:${value.slice(quote.length)}` : `node:${value}`;
+};
+const fileExists = async candidate => {
+  try {
+    const s = await stat(candidate);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+};
+const resolveRequirePath = async (fromFile, spec, dirIndex) => {
+  if (!spec.startsWith('./') && !spec.startsWith('../')) return null;
+  const base = pathResolve(pathDirname(fromFile), spec);
+  const ext = extname(base);
+  const candidates = [];
+  if (ext) {
+    candidates.push(base);
+  } else {
+    candidates.push(`${base}.js`, `${base}.cjs`, `${base}.mjs`);
+    candidates.push(join(base, dirIndex));
+  }
+  for (const candidate of candidates) {
+    if (await fileExists(candidate)) return candidate;
+  }
+  return null;
+};
+const collectStaticRequires = async (filePath, dirIndex) => {
+  const src = await fsReadFile(filePath, 'utf8');
+  const ast = parseModule(filePath, src);
+  const specs = [];
+  await walk(ast.program, {
+    enter(node) {
+      if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === 'require' && node.arguments.length === 1 && node.arguments[0].type === 'Literal' && typeof node.arguments[0].value === 'string') {
+        const spec = node.arguments[0].value;
+        if (spec.startsWith('./') || spec.startsWith('../')) {
+          specs.push(spec);
+        }
+      }
+    }
+  });
+  const resolved = [];
+  for (const spec of specs) {
+    const target = await resolveRequirePath(filePath, spec, dirIndex);
+    if (target) resolved.push(target);
+  }
+  return resolved;
+};
+const detectCircularRequireGraph = async (entryFile, mode, dirIndex) => {
+  const cache = new Map();
+  const visiting = new Set();
+  const visited = new Set();
+  const dfs = async (file, stack) => {
+    if (visiting.has(file)) {
+      const cycle = [...stack, file];
+      const msg = `Circular require detected: ${cycle.join(' -> ')}`;
+      if (mode === 'error') {
+        throw new Error(msg);
+      }
+      // eslint-disable-next-line no-console -- surfaced when cycle detection is warn-only
+      console.warn(msg);
+      return;
+    }
+    if (visited.has(file)) return;
+    visiting.add(file);
+    stack.push(file);
+    let deps = cache.get(file);
+    if (!deps) {
+      deps = await collectStaticRequires(file, dirIndex);
+      cache.set(file, deps);
+    }
+    for (const dep of deps) {
+      await dfs(dep, stack);
+    }
+    stack.pop();
+    visiting.delete(file);
+    visited.add(file);
+  };
+  await dfs(entryFile, []);
+};
 const defaultOptions = {
   target: 'commonjs',
   sourceType: 'auto',
   transformSyntax: true,
   liveBindings: 'strict',
   rewriteSpecifier: undefined,
+  appendJsExtension: undefined,
+  appendDirectoryIndex: 'index.js',
   dirFilename: 'inject',
   importMeta: 'shim',
   importMetaMain: 'shim',
+  requireMainStrategy: 'import-meta-main',
+  detectCircularRequires: 'off',
   requireSource: 'builtin',
+  nestedRequireStrategy: 'create-require',
   cjsDefault: 'auto',
   topLevelAwait: 'error',
   out: undefined,
@@ -24,28 +166,26 @@ const transform = async (filename, options = defaultOptions) => {
     ...defaultOptions,
     ...options
   };
+  const appendMode = options?.appendJsExtension ?? (opts.target === 'module' ? 'relative-only' : 'off');
+  const dirIndex = opts.appendDirectoryIndex === undefined ? 'index.js' : opts.appendDirectoryIndex;
+  const detectCycles = opts.detectCircularRequires ?? 'off';
   const file = resolve(filename);
   const code = (await readFile(file)).toString();
   const ast = parse(filename, code);
   let source = await format(code, ast, opts);
-  if (opts.rewriteSpecifier) {
-    const code = await specifier.updateSrc(source, getLangFromExt(filename), ({
-      value
-    }) => {
-      if (typeof opts.rewriteSpecifier === 'function') {
-        return opts.rewriteSpecifier(value) ?? undefined;
-      }
-
-      // Collapse any BinaryExpression or NewExpression to test for a relative specifier
-      const collapsed = value.replace(/['"`+)\s]|new String\(/g, '');
-      const relative = /^(?:\.|\.\.)\//;
-      if (relative.test(collapsed)) {
-        // $2 is for any closing quotation/parens around BE or NE
-        return value.replace(/(.+)\.(?:m|c)?(?:j|t)s([)'"]*)?$/, `$1${opts.rewriteSpecifier}$2`);
-      }
+  if (opts.rewriteSpecifier || appendMode !== 'off' || dirIndex) {
+    const code = await specifier.updateSrc(source, getLangFromExt(filename), spec => {
+      const normalized = normalizeBuiltinSpecifier(spec.value);
+      const rewritten = rewriteSpecifierValue(normalized ?? spec.value, opts.rewriteSpecifier);
+      const baseValue = rewritten ?? normalized ?? spec.value;
+      const appended = appendExtensionIfNeeded(spec, appendMode, dirIndex, baseValue);
+      return appended ?? rewritten ?? normalized ?? undefined;
     });
     source = code;
   }
+  if (detectCycles !== 'off' && opts.target === 'module' && opts.transformSyntax) {
+    await detectCircularRequireGraph(file, detectCycles, dirIndex || 'index.js');
+  }
   const outputPath = opts.inPlace ? file : opts.out ? resolve(opts.out) : undefined;
   if (outputPath) {
     await writeFile(outputPath, source);

package/dist/specifier.js

@@ -121,7 +121,7 @@ const formatSpecifiers = async (src, ast, cb) => {
       }
       if (node.type === 'CallExpression') {
         // Handle require(), require.resolve(), import.meta.resolve()
-        if (node.callee.type === 'Identifier' && node.callee.name === 'require' || node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && node.callee.object.name === 'require' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'resolve' || node.callee.type === 'MemberExpression' && node.callee.object.type === 'MetaProperty' && node.callee.object.meta.name === 'import' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'resolve') {
+        if (node.callee.type === 'Identifier' && node.callee.name === 'require' || node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && node.callee.object.name === 'require' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'resolve' || node.callee.type === 'Identifier' && node.callee.name === '__requireResolve' || node.callee.type === 'MemberExpression' && node.callee.object.type === 'MetaProperty' && node.callee.object.meta.name === 'import' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'resolve') {
           formatExpression(node);
         }
       }

package/dist/src/formatters/memberExpression.d.ts

@@ -1,4 +1,9 @@
 import MagicString from 'magic-string';
 import type { MemberExpression, Node } from 'oxc-parser';
 import type { FormatterOptions } from '../types.js';
-export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions, shadowed?: Set<string>) => void;
+type MemberExpressionExtras = {
+    onRequireResolve?: () => void;
+    requireResolveName?: string;
+};
+export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions, shadowed?: Set<string>, extras?: MemberExpressionExtras) => void;
+export {};

package/dist/src/types.d.ts

@@ -1,18 +1,42 @@
 import type { Node, Span, IdentifierName, IdentifierReference, BindingIdentifier, LabelIdentifier, TSIndexSignatureName } from 'oxc-parser';
 export type RewriteSpecifier = '.js' | '.mjs' | '.cjs' | '.ts' | '.mts' | '.cts' | ((value: string) => string | null | undefined);
+/** Options that control how modules are parsed, transformed, and emitted. */
 export type ModuleOptions = {
+    /** Output format to emit. */
     target: 'module' | 'commonjs';
+    /** Explicit source type; auto infers from file extension. */
     sourceType?: 'auto' | 'module' | 'commonjs';
+    /** Enable syntax transforms beyond parsing. */
     transformSyntax?: boolean;
+    /** How to emit live bindings for ESM exports. */
     liveBindings?: 'strict' | 'loose' | 'off';
+    /** Rewrite import specifiers (e.g. add extensions). */
     rewriteSpecifier?: RewriteSpecifier;
+    /** Whether to append .js to relative imports. */
+    appendJsExtension?: 'off' | 'relative-only' | 'all';
+    /** Add directory index (e.g. /index.js) or disable. */
+    appendDirectoryIndex?: string | false;
+    /** Control __dirname and __filename handling. */
     dirFilename?: 'inject' | 'preserve' | 'error';
+    /** How to treat import.meta. */
     importMeta?: 'preserve' | 'shim' | 'error';
+    /** Strategy for import.meta.main emulation. */
     importMetaMain?: 'shim' | 'warn' | 'error';
+    /** Resolution strategy for detecting the main module. */
+    requireMainStrategy?: 'import-meta-main' | 'realpath';
+    /** Detect circular require usage level. */
+    detectCircularRequires?: 'off' | 'warn' | 'error';
+    /** Source used to provide require in ESM output. */
     requireSource?: 'builtin' | 'create-require';
+    /** How to rewrite nested or non-hoistable require calls. */
+    nestedRequireStrategy?: 'create-require' | 'dynamic-import';
+    /** Default interop style for CommonJS default imports. */
     cjsDefault?: 'module-exports' | 'auto' | 'none';
+    /** Handling for top-level await constructs. */
     topLevelAwait?: 'error' | 'wrap' | 'preserve';
+    /** Output directory or file path when writing. */
     out?: string;
+    /** Overwrite input files instead of writing to out. */
     inPlace?: boolean;
 };
 export type SpannedNode = Node & Span;

package/dist/types.d.cts

@@ -1,18 +1,42 @@
 import type { Node, Span, IdentifierName, IdentifierReference, BindingIdentifier, LabelIdentifier, TSIndexSignatureName } from 'oxc-parser';
 export type RewriteSpecifier = '.js' | '.mjs' | '.cjs' | '.ts' | '.mts' | '.cts' | ((value: string) => string | null | undefined);
+/** Options that control how modules are parsed, transformed, and emitted. */
 export type ModuleOptions = {
+    /** Output format to emit. */
     target: 'module' | 'commonjs';
+    /** Explicit source type; auto infers from file extension. */
     sourceType?: 'auto' | 'module' | 'commonjs';
+    /** Enable syntax transforms beyond parsing. */
     transformSyntax?: boolean;
+    /** How to emit live bindings for ESM exports. */
     liveBindings?: 'strict' | 'loose' | 'off';
+    /** Rewrite import specifiers (e.g. add extensions). */
     rewriteSpecifier?: RewriteSpecifier;
+    /** Whether to append .js to relative imports. */
+    appendJsExtension?: 'off' | 'relative-only' | 'all';
+    /** Add directory index (e.g. /index.js) or disable. */
+    appendDirectoryIndex?: string | false;
+    /** Control __dirname and __filename handling. */
     dirFilename?: 'inject' | 'preserve' | 'error';
+    /** How to treat import.meta. */
     importMeta?: 'preserve' | 'shim' | 'error';
+    /** Strategy for import.meta.main emulation. */
     importMetaMain?: 'shim' | 'warn' | 'error';
+    /** Resolution strategy for detecting the main module. */
+    requireMainStrategy?: 'import-meta-main' | 'realpath';
+    /** Detect circular require usage level. */
+    detectCircularRequires?: 'off' | 'warn' | 'error';
+    /** Source used to provide require in ESM output. */
     requireSource?: 'builtin' | 'create-require';
+    /** How to rewrite nested or non-hoistable require calls. */
+    nestedRequireStrategy?: 'create-require' | 'dynamic-import';
+    /** Default interop style for CommonJS default imports. */
     cjsDefault?: 'module-exports' | 'auto' | 'none';
+    /** Handling for top-level await constructs. */
     topLevelAwait?: 'error' | 'wrap' | 'preserve';
+    /** Output directory or file path when writing. */
     out?: string;
+    /** Overwrite input files instead of writing to out. */
     inPlace?: boolean;
 };
 export type SpannedNode = Node & Span;

package/dist/types.d.ts

@@ -1,18 +1,42 @@
 import type { Node, Span, IdentifierName, IdentifierReference, BindingIdentifier, LabelIdentifier, TSIndexSignatureName } from 'oxc-parser';
 export type RewriteSpecifier = '.js' | '.mjs' | '.cjs' | '.ts' | '.mts' | '.cts' | ((value: string) => string | null | undefined);
+/** Options that control how modules are parsed, transformed, and emitted. */
 export type ModuleOptions = {
+    /** Output format to emit. */
     target: 'module' | 'commonjs';
+    /** Explicit source type; auto infers from file extension. */
     sourceType?: 'auto' | 'module' | 'commonjs';
+    /** Enable syntax transforms beyond parsing. */
     transformSyntax?: boolean;
+    /** How to emit live bindings for ESM exports. */
     liveBindings?: 'strict' | 'loose' | 'off';
+    /** Rewrite import specifiers (e.g. add extensions). */
     rewriteSpecifier?: RewriteSpecifier;
+    /** Whether to append .js to relative imports. */
+    appendJsExtension?: 'off' | 'relative-only' | 'all';
+    /** Add directory index (e.g. /index.js) or disable. */
+    appendDirectoryIndex?: string | false;
+    /** Control __dirname and __filename handling. */
     dirFilename?: 'inject' | 'preserve' | 'error';
+    /** How to treat import.meta. */
     importMeta?: 'preserve' | 'shim' | 'error';
+    /** Strategy for import.meta.main emulation. */
     importMetaMain?: 'shim' | 'warn' | 'error';
+    /** Resolution strategy for detecting the main module. */
+    requireMainStrategy?: 'import-meta-main' | 'realpath';
+    /** Detect circular require usage level. */
+    detectCircularRequires?: 'off' | 'warn' | 'error';
+    /** Source used to provide require in ESM output. */
     requireSource?: 'builtin' | 'create-require';
+    /** How to rewrite nested or non-hoistable require calls. */
+    nestedRequireStrategy?: 'create-require' | 'dynamic-import';
+    /** Default interop style for CommonJS default imports. */
     cjsDefault?: 'module-exports' | 'auto' | 'none';
+    /** Handling for top-level await constructs. */
     topLevelAwait?: 'error' | 'wrap' | 'preserve';
+    /** Output directory or file path when writing. */
     out?: string;
+    /** Overwrite input files instead of writing to out. */
     inPlace?: boolean;
 };
 export type SpannedNode = Node & Span;

package/dist/utils/exports.js

@@ -11,7 +11,9 @@ const literalPropName = (prop, literals) => {
   }
   return null;
 };
-const resolveExportTarget = (node, aliases, literals) => {
+const bindsThis = ancestor => ancestor.type === 'FunctionDeclaration' || ancestor.type === 'FunctionExpression' || ancestor.type === 'ClassDeclaration' || ancestor.type === 'ClassExpression';
+const isTopLevelThis = ancestors => !ancestors?.some(node => bindsThis(node));
+const resolveExportTarget = (node, aliases, literals, ancestors) => {
   if (node.type === 'Identifier' && node.name === 'exports') {
     return {
       key: 'default',
@@ -29,7 +31,7 @@ const resolveExportTarget = (node, aliases, literals) => {
   const prop = node.property;
   const key = literalPropName(prop, literals);
   if (!key) return null;
-  const baseVia = resolveBase(base, aliases);
+  const baseVia = resolveBase(base, aliases, ancestors);
   if (!baseVia) return null;
   if (baseVia === 'module.exports' && key === 'exports') {
     return {
@@ -42,12 +44,15 @@ const resolveExportTarget = (node, aliases, literals) => {
     via: baseVia
   };
 };
-const resolveBase = (node, aliases) => {
+const resolveBase = (node, aliases, ancestors) => {
   if (node.type === 'Identifier') {
     if (node.name === 'exports') return 'exports';
     const alias = aliases.get(node.name);
     if (alias) return alias;
   }
+  if (node.type === 'ThisExpression' && isTopLevelThis(ancestors)) {
+    return 'exports';
+  }
   if (node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'module' && node.property.type === 'Identifier' && node.property.name === 'exports') {
     return 'module.exports';
   }
@@ -79,22 +84,24 @@ const collectCjsExports = async ast => {
     exportsMap.set(ref.key, entry);
   };
   await ancestorWalk(ast, {
-    enter(node) {
+    enter(node, ancestors) {
       if (node.type === 'VariableDeclarator' && node.id.type === 'Identifier' && node.init) {
-        const via = resolveBase(node.init, aliases);
+        const via = resolveBase(node.init, aliases, ancestors);
         if (via) {
           aliases.set(node.id.name, via);
         }
+        const parentDecl = ancestors?.[ancestors.length - 2];
+        const isConstDecl = parentDecl?.type === 'VariableDeclaration' && parentDecl.kind === 'const';
         if (node.init.type === 'Literal' && (typeof node.init.value === 'string' || typeof node.init.value === 'number')) {
-          literals.set(node.id.name, node.init.value);
+          if (isConstDecl) literals.set(node.id.name, node.init.value);
         }
         if (node.init.type === 'TemplateLiteral' && node.init.expressions.length === 0 && node.init.quasis.length === 1) {
           const cooked = node.init.quasis[0].value.cooked ?? node.init.quasis[0].value.raw;
-          literals.set(node.id.name, cooked);
+          if (isConstDecl) literals.set(node.id.name, cooked);
         }
       }
       if (node.type === 'AssignmentExpression') {
-        const target = resolveExportTarget(node.left, aliases, literals);
+        const target = resolveExportTarget(node.left, aliases, literals, ancestors);
         if (target) {
           const rhsIdent = node.right.type === 'Identifier' ? node.right : undefined;
           addExport(target, node, rhsIdent);
@@ -112,15 +119,31 @@ const collectCjsExports = async ast => {
             });
           }
         }
-        if (node.left.type === 'ObjectPattern') {
-          for (const prop of node.left.properties) {
-            if (prop.type === 'Property' && prop.value.type === 'MemberExpression') {
-              const ref = resolveExportTarget(prop.value, aliases, literals);
-              if (ref) {
-                addExport(ref, node);
+        if (node.left.type === 'ObjectPattern' || node.left.type === 'ArrayPattern') {
+          const findExportRefs = pattern => {
+            if (pattern.type === 'MemberExpression') {
+              const ref = resolveExportTarget(pattern, aliases, literals, ancestors);
+              if (ref) addExport(ref, node);
+              return;
+            }
+            if (pattern.type === 'ObjectPattern') {
+              for (const prop of pattern.properties) {
+                const target = prop.type === 'Property' ? prop.value : prop.argument;
+                if (target) findExportRefs(target);
               }
+              return;
             }
-          }
+            if (pattern.type === 'ArrayPattern') {
+              for (const el of pattern.elements) {
+                if (el) findExportRefs(el);
+              }
+              return;
+            }
+            if (pattern.type === 'RestElement') {
+              findExportRefs(pattern.argument);
+            }
+          };
+          findExportRefs(node.left);
         }
       }
       if (node.type === 'CallExpression') {
@@ -129,7 +152,7 @@ const collectCjsExports = async ast => {
         // Object.assign(exports, { foo: bar })
         if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'Object' && callee.property.type === 'Identifier' && callee.property.name === 'assign' && node.arguments.length >= 2) {
           const targetArg = node.arguments[0];
-          const ref = resolveBase(targetArg, aliases);
+          const ref = resolveBase(targetArg, aliases, ancestors);
           if (!ref) return;
           for (let i = 1; i < node.arguments.length; i++) {
             const arg = node.arguments[i];
@@ -153,7 +176,7 @@ const collectCjsExports = async ast => {
 
         // Object.defineProperty(exports, 'foo', { value, get, set })
         if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'Object' && callee.property.type === 'Identifier' && callee.property.name === 'defineProperty' && node.arguments.length >= 3) {
-          const target = resolveBase(node.arguments[0], aliases);
+          const target = resolveBase(node.arguments[0], aliases, ancestors);
           if (!target) return;
           const keyName = literalPropName(node.arguments[1], literals);
           if (!keyName) return;
@@ -184,7 +207,7 @@ const collectCjsExports = async ast => {
 
         // Object.defineProperties(exports, { foo: { value: ... }, bar: { get: ... } })
         if (callee.type === 'MemberExpression' && callee.object.type === 'Identifier' && callee.object.name === 'Object' && callee.property.type === 'Identifier' && callee.property.name === 'defineProperties' && node.arguments.length >= 2) {
-          const target = resolveBase(node.arguments[0], aliases);
+          const target = resolveBase(node.arguments[0], aliases, ancestors);
           if (!target) return;
           const descMap = node.arguments[1];
           if (descMap.type !== 'ObjectExpression') return;

package/dist/utils/identifiers.js

@@ -1,6 +1,34 @@
 import { ancestorWalk } from '#walk';
 import { identifier } from '#helpers/identifier.js';
 import { scopeNodes } from './scopeNodes.js';
+const addBindingNames = (pattern, into) => {
+  if (!pattern) return;
+  switch (pattern.type) {
+    case 'Identifier':
+      into.add(pattern.name);
+      return;
+    case 'AssignmentPattern':
+      addBindingNames(pattern.left, into);
+      return;
+    case 'RestElement':
+      addBindingNames(pattern.argument, into);
+      return;
+    case 'ObjectPattern':
+      for (const prop of pattern.properties ?? []) {
+        if (prop.type === 'Property') {
+          addBindingNames(prop.value, into);
+        } else if (prop.type === 'RestElement') {
+          addBindingNames(prop.argument, into);
+        }
+      }
+      return;
+    case 'ArrayPattern':
+      for (const elem of pattern.elements ?? []) {
+        if (elem) addBindingNames(elem, into);
+      }
+      return;
+  }
+};
 const collectScopeIdentifiers = (node, scopes) => {
   const {
     type
@@ -26,20 +54,10 @@ const collectScopeIdentifiers = (node, scopes) => {
           type: 'Function',
           idents: new Set()
         };
-        node.params.map(param => {
-          if (param.type === 'TSParameterProperty') {
-            return param.parameter;
-          }
-          if (param.type === 'RestElement') {
-            return param.argument;
-          }
-          if (param.type === 'AssignmentPattern') {
-            return param.left;
-          }
-          return param;
-        }).filter(identifier.isNamed).forEach(param => {
-          scope.idents.add(param.name);
-        });
+        for (const param of node.params) {
+          const normalized = param.type === 'TSParameterProperty' ? param.parameter : param;
+          addBindingNames(normalized, scope.idents);
+        }
 
         /**
          * If a FunctionExpression has an id, it is a named function expression.
@@ -88,8 +106,8 @@ const collectScopeIdentifiers = (node, scopes) => {
       if (scopes.length > 0) {
         const scope = scopes[scopes.length - 1];
         node.declarations.forEach(decl => {
-          if (decl.type === 'VariableDeclarator' && decl.id.type === 'Identifier') {
-            scope.idents.add(decl.id.name);
+          if (decl.type === 'VariableDeclarator') {
+            addBindingNames(decl.id, scope.idents);
           }
         });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knighted/module",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.3",
   "description": "Transforms differences between ES modules and CommonJS.",
   "type": "module",
   "main": "dist/module.js",
@@ -19,15 +19,15 @@
     "./package.json": "./package.json"
   },
   "imports": {
-    "#parse": "./src/parse.js",
-    "#format": "./src/format.js",
-    "#utils/*.js": "./src/utils/*.js",
-    "#walk": "./src/walk.js",
-    "#helpers/*.js": "./src/helpers/*.js",
-    "#formatters/*.js": "./src/formatters/*.js"
+    "#parse": "./dist/parse.js",
+    "#format": "./dist/format.js",
+    "#utils/*.js": "./dist/utils/*.js",
+    "#walk": "./dist/walk.js",
+    "#helpers/*.js": "./dist/helpers/*.js",
+    "#formatters/*.js": "./dist/formatters/*.js"
   },
   "engines": {
-    "node": ">=22.21.1"
+    "node": ">=22.21.1 <23 || >=24 <25"
   },
   "engineStrict": true,
   "scripts": {
@@ -40,7 +40,8 @@
     "build:types": "tsc --emitDeclarationOnly",
     "build:dual": "babel-dual-package src --extensions .ts",
     "build": "npm run build:types && npm run build:dual",
-    "prepack": "npm run build"
+    "prepack": "npm run build && node scripts/setImportsToDist.js",
+    "postpack": "node scripts/restoreImportsToSrc.js"
   },
   "keywords": [
     "transform",