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

package/dist/cjs/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/cjs/utils/exports.cjs

@@ -17,7 +17,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',
@@ -35,7 +37,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 {
@@ -48,12 +50,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';
   }
@@ -85,22 +90,24 @@ const collectCjsExports = async ast => {
     exportsMap.set(ref.key, entry);
   };
   await (0, _walk.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);
@@ -118,15 +125,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') {
@@ -135,7 +158,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];
@@ -159,7 +182,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;
@@ -190,7 +213,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/cjs/utils/identifiers.cjs

@@ -7,6 +7,34 @@ exports.collectScopeIdentifiers = exports.collectModuleIdentifiers = void 0;
 var _walk = require("#walk");
 var _identifier = require("#helpers/identifier.js");
 var _scopeNodes = require("./scopeNodes.cjs");
+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
@@ -32,20 +60,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.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.
@@ -94,8 +112,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/dist/format.js

@@ -19,6 +19,8 @@ const exportAssignment = (name, expr, live) => {
 };
 const defaultInteropName = '__interopDefault';
 const interopHelper = `const ${defaultInteropName} = mod => (mod && mod.__esModule ? mod.default : mod);\n`;
+const requireInteropName = '__requireDefault';
+const requireInteropHelper = `const ${requireInteropName} = mod => (mod && typeof mod === 'object' && 'default' in mod ? mod.default : mod);\n`;
 const isRequireCallee = (callee, shadowed) => {
   if (callee.type === 'Identifier' && callee.name === 'require' && !shadowed.has('require')) {
     return true;
@@ -33,8 +35,14 @@ const isRequireCall = (node, shadowed) => node.type === 'CallExpression' && isRe
 const lowerCjsRequireToImports = (program, code, shadowed) => {
   const transforms = [];
   const imports = [];
+  const hoisted = [];
   let nsIndex = 0;
   let needsCreateRequire = false;
+  let needsInteropHelper = false;
+  const isJsonSpecifier = value => {
+    const base = value.split(/[?#]/)[0] ?? value;
+    return base.endsWith('.json');
+  };
   for (const stmt of program.body) {
     if (stmt.type === 'VariableDeclaration') {
       const decls = stmt.declarations;
@@ -42,14 +50,21 @@ const lowerCjsRequireToImports = (program, code, shadowed) => {
       if (allStatic) {
         for (const decl of decls) {
           const init = decl.init;
-          const source = code.slice(init.arguments[0].start, init.arguments[0].end);
+          const arg = init.arguments[0];
+          const source = code.slice(arg.start, arg.end);
+          const value = arg.value;
+          const isJson = typeof value === 'string' && isJsonSpecifier(value);
+          const ns = `__cjsImport${nsIndex++}`;
+          const jsonImport = isJson ? `${source} with { type: "json" }` : source;
           if (decl.id.type === 'Identifier') {
-            imports.push(`import * as ${decl.id.name} from ${source};\n`);
-          } else if (decl.id.type === 'ObjectPattern') {
-            const ns = `__cjsImport${nsIndex++}`;
+            imports.push(isJson ? `import ${ns} from ${jsonImport};\n` : `import * as ${ns} from ${jsonImport};\n`);
+            hoisted.push(isJson ? `const ${decl.id.name} = ${ns};\n` : `const ${decl.id.name} = ${requireInteropName}(${ns});\n`);
+            needsInteropHelper ||= !isJson;
+          } else if (decl.id.type === 'ObjectPattern' || decl.id.type === 'ArrayPattern') {
             const pattern = code.slice(decl.id.start, decl.id.end);
-            imports.push(`import * as ${ns} from ${source};\n`);
-            imports.push(`const ${pattern} = ${ns};\n`);
+            imports.push(isJson ? `import ${ns} from ${jsonImport};\n` : `import * as ${ns} from ${jsonImport};\n`);
+            hoisted.push(isJson ? `const ${pattern} = ${ns};\n` : `const ${pattern} = ${requireInteropName}(${ns});\n`);
+            needsInteropHelper ||= !isJson;
           } else {
             needsCreateRequire = true;
           }
@@ -71,8 +86,12 @@ const lowerCjsRequireToImports = (program, code, shadowed) => {
     if (stmt.type === 'ExpressionStatement') {
       const expr = stmt.expression;
       if (expr && isStaticRequire(expr, shadowed)) {
-        const source = code.slice(expr.arguments[0].start, expr.arguments[0].end);
-        imports.push(`import ${source};\n`);
+        const arg = expr.arguments[0];
+        const source = code.slice(arg.start, arg.end);
+        const value = arg.value;
+        const isJson = typeof value === 'string' && isJsonSpecifier(value);
+        const jsonImport = isJson ? `${source} with { type: "json" }` : source;
+        imports.push(`import ${jsonImport};\n`);
         transforms.push({
           start: stmt.start,
           end: stmt.end,
@@ -88,7 +107,9 @@ const lowerCjsRequireToImports = (program, code, shadowed) => {
   return {
     transforms,
     imports,
-    needsCreateRequire
+    hoisted,
+    needsCreateRequire,
+    needsInteropHelper
   };
 };
 const isRequireMainMember = (node, shadowed) => node && node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'require' && !shadowed.has('require') && node.property.type === 'Identifier' && node.property.name === 'main';
@@ -129,6 +150,20 @@ const hasTopLevelAwait = program => {
   walkNode(program, false);
   return found;
 };
+const isAsyncContext = ancestors => {
+  for (let i = ancestors.length - 1; i >= 0; i -= 1) {
+    const node = ancestors[i];
+    if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+      return !!node.async;
+    }
+    if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+      return false;
+    }
+  }
+
+  // Program scope (top-level) supports await in ESM.
+  return true;
+};
 const lowerEsmToCjs = (program, code, opts, containsTopLevelAwait) => {
   const live = opts.liveBindings ?? 'strict';
   const importTransforms = [];
@@ -338,11 +373,17 @@ const format = async (src, ast, opts) => {
   const exportTable = opts.target === 'module' ? await collectCjsExports(ast.program) : null;
   const shouldCheckTopLevelAwait = opts.target === 'commonjs' && opts.transformSyntax;
   const containsTopLevelAwait = shouldCheckTopLevelAwait ? hasTopLevelAwait(ast.program) : false;
+  const requireMainStrategy = opts.requireMainStrategy ?? 'import-meta-main';
+  let requireMainNeedsRealpath = false;
+  let needsRequireResolveHelper = false;
+  const nestedRequireStrategy = opts.nestedRequireStrategy ?? 'create-require';
   const shouldLowerCjs = opts.target === 'commonjs' && opts.transformSyntax;
   const shouldRaiseEsm = opts.target === 'module' && opts.transformSyntax;
   let hoistedImports = [];
+  let hoistedStatements = [];
   let pendingRequireTransforms = [];
   let needsCreateRequire = false;
+  let needsImportInterop = false;
   let pendingCjsTransforms = null;
   if (shouldLowerCjs && opts.topLevelAwait === 'error' && containsTopLevelAwait) {
     throw new Error('Top-level await is not supported when targeting CommonJS (set topLevelAwait to "wrap" or "preserve" to override).');
@@ -351,11 +392,15 @@ const format = async (src, ast, opts) => {
     const {
       transforms,
       imports,
-      needsCreateRequire: reqCreate
+      hoisted,
+      needsCreateRequire: reqCreate,
+      needsInteropHelper: reqInteropHelper
     } = lowerCjsRequireToImports(ast.program, code, shadowedBindings);
     pendingRequireTransforms = transforms;
     hoistedImports = imports;
+    hoistedStatements = hoisted;
     needsCreateRequire = reqCreate;
+    needsImportInterop = reqInteropHelper;
   }
   await ancestorWalk(ast.program, {
     async enter(node, ancestors) {
@@ -370,7 +415,11 @@ const format = async (src, ast, opts) => {
           const rightModule = node.right.type === 'Identifier' && node.right.name === 'module' && !shadowedBindings.has('module');
           if (leftMain && rightModule || rightMain && leftModule) {
             const negate = op === '!==' || op === '!=';
-            code.update(node.start, node.end, negate ? '!import.meta.main' : 'import.meta.main');
+            const mainExpr = requireMainStrategy === 'import-meta-main' ? 'import.meta.main' : 'import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href';
+            if (requireMainStrategy === 'realpath') {
+              requireMainNeedsRealpath = true;
+            }
+            code.update(node.start, node.end, negate ? `!(${mainExpr})` : mainExpr);
             return;
           }
         }
@@ -392,6 +441,18 @@ const format = async (src, ast, opts) => {
         const topLevelVarDecl = parent?.type === 'VariableDeclarator' && grandparent?.type === 'VariableDeclaration' && greatGrandparent?.type === 'Program';
         const hoistableTopLevel = isStatic && (topLevelExprStmt || topLevelVarDecl);
         if (!isStatic || !hoistableTopLevel) {
+          if (nestedRequireStrategy === 'dynamic-import') {
+            const asyncCapable = isAsyncContext(ancestors);
+            if (asyncCapable) {
+              const arg = node.arguments[0];
+              const argSrc = arg ? code.slice(arg.start, arg.end) : 'undefined';
+              const literalVal = arg?.value;
+              const isJson = arg?.type === 'Literal' && typeof literalVal === 'string' && (literalVal.split(/[?#]/)[0] ?? literalVal).endsWith('.json');
+              const importTarget = isJson ? `${argSrc} with { type: "json" }` : argSrc;
+              code.update(node.start, node.end, `(await import(${importTarget}))`);
+              return;
+            }
+          }
           needsCreateRequire = true;
         }
       }
@@ -453,7 +514,23 @@ const format = async (src, ast, opts) => {
         metaProperty(node, parent, code, opts);
       }
       if (node.type === 'MemberExpression') {
-        memberExpression(node, parent, code, opts, shadowedBindings);
+        memberExpression(node, parent, code, opts, shadowedBindings, {
+          onRequireResolve: () => {
+            if (shouldRaiseEsm) needsRequireResolveHelper = true;
+          },
+          requireResolveName: '__requireResolve'
+        });
+      }
+      if (shouldRaiseEsm && node.type === 'ThisExpression') {
+        const bindsThis = ancestor => {
+          return ancestor.type === 'FunctionDeclaration' || ancestor.type === 'FunctionExpression' || ancestor.type === 'ClassDeclaration' || ancestor.type === 'ClassExpression';
+        };
+        const bindingAncestor = ancestors.find(ancestor => bindsThis(ancestor));
+        const isTopLevel = !bindingAncestor;
+        if (isTopLevel) {
+          code.update(node.start, node.end, exportsRename);
+          return;
+        }
       }
       if (isIdentifierName(node)) {
         identifier({
@@ -522,14 +599,36 @@ const format = async (src, ast, opts) => {
   }
   if (shouldRaiseEsm && opts.transformSyntax) {
     const importPrelude = [];
-    if (needsCreateRequire) {
+    if (needsCreateRequire || needsRequireResolveHelper) {
       importPrelude.push('import { createRequire } from "node:module";\n');
     }
+    if (needsRequireResolveHelper) {
+      importPrelude.push('import { fileURLToPath } from "node:url";\n');
+    }
+    if (requireMainNeedsRealpath) {
+      importPrelude.push('import { realpathSync } from "node:fs";\n');
+      importPrelude.push('import { pathToFileURL } from "node:url";\n');
+    }
     if (hoistedImports.length) {
       importPrelude.push(...hoistedImports);
     }
+    const setupPrelude = [];
+    if (needsImportInterop) {
+      setupPrelude.push(requireInteropHelper);
+    }
+    if (hoistedStatements.length) {
+      setupPrelude.push(...hoistedStatements);
+    }
     const requireInit = needsCreateRequire ? 'const require = createRequire(import.meta.url);\n' : '';
-    const prelude = `${importPrelude.join('')}${importPrelude.length ? '\n' : ''}${requireInit}let ${exportsRename} = {};
+    const requireResolveInit = needsRequireResolveHelper ? needsCreateRequire ? `const __requireResolve = (id, parent) => {
+  const resolved = require.resolve(id, parent);
+  return resolved.startsWith("file://") ? fileURLToPath(resolved) : resolved;
+};\n` : `const __requireResolve = (id, parent) => {
+  const req = createRequire(parent ?? import.meta.url);
+  const resolved = req.resolve(id, parent);
+  return resolved.startsWith("file://") ? fileURLToPath(resolved) : resolved;
+};\n` : '';
+    const prelude = `${importPrelude.join('')}${importPrelude.length ? '\n' : ''}${setupPrelude.join('')}${setupPrelude.length ? '\n' : ''}${requireInit}${requireResolveInit}let ${exportsRename} = {};
 void import.meta.filename;
 `;
     code.prepend(prelude);

package/dist/formatters/identifier.js

@@ -19,7 +19,7 @@ export const identifier = ({
     }
     switch (name) {
       case '__filename':
-        code.update(start, end, 'import.meta.url');
+        code.update(start, end, 'import.meta.filename');
         break;
       case '__dirname':
         code.update(start, end, 'import.meta.dirname');

package/dist/formatters/memberExpression.js

@@ -1,5 +1,5 @@
 import { exportsRename } from '#utils/exports.js';
-export const memberExpression = (node, parent, src, options, shadowed) => {
+export const memberExpression = (node, parent, src, options, shadowed, extras) => {
   if (options.target === 'module') {
     if (node.object.type === 'Identifier' && shadowed?.has(node.object.name) || node.property.type === 'Identifier' && shadowed?.has(node.property.name)) {
       return;
@@ -26,7 +26,8 @@ export const memberExpression = (node, parent, src, options, shadowed) => {
           src.update(start, end, 'import.meta.main');
           break;
         case 'resolve':
-          src.update(start, end, 'import.meta.resolve');
+          extras?.onRequireResolve?.();
+          src.update(start, end, extras?.requireResolveName ?? 'import.meta.resolve');
           break;
         case 'cache':
           /**

package/dist/helpers/identifier.js

@@ -24,6 +24,31 @@ const getScopeContext = program => {
   scopeCache.set(program, context);
   return context;
 };
+const isInBindingPattern = (pattern, target) => {
+  if (pattern === target) return true;
+  switch (pattern.type) {
+    case 'Identifier':
+      return pattern === target;
+    case 'AssignmentPattern':
+      return isInBindingPattern(pattern.left, target);
+    case 'RestElement':
+      return isInBindingPattern(pattern.argument, target);
+    case 'ObjectPattern':
+      return (pattern.properties ?? []).some(prop => {
+        if (prop.type === 'Property') {
+          return isInBindingPattern(prop.value, target);
+        }
+        if (prop.type === 'RestElement') {
+          return isInBindingPattern(prop.argument, target);
+        }
+        return false;
+      });
+    case 'ArrayPattern':
+      return (pattern.elements ?? []).some(elem => elem && isInBindingPattern(elem, target));
+    default:
+      return false;
+  }
+};
 
 /**
  * All methods receive the full set of ancestors, which
@@ -42,6 +67,7 @@ const identifier = {
   isModuleScope(ancestors, includeImports = false) {
     const node = ancestors[ancestors.length - 1];
     const parent = ancestors[ancestors.length - 2];
+    const grandParent = ancestors[ancestors.length - 3];
     const program = ancestors[0];
     if (!identifier.isNamed(node) || identifier.isMetaProperty(ancestors) || parent.type === 'LabeledStatement' || parent.type === 'BreakStatement' || parent.type === 'ContinueStatement') {
       return false;
@@ -50,7 +76,9 @@ const identifier = {
       return includeImports && parent.local.name === node.name;
     }
     if (parent.type === 'Property' && parent.key === node && !parent.computed) {
-      return false;
+      if (grandParent?.type !== 'ObjectPattern') {
+        return false;
+      }
     }
     if (parent.type === 'MemberExpression' && parent.property === node && !parent.computed) {
       return false;
@@ -72,8 +100,17 @@ const identifier = {
   },
   isDeclaration(ancestors) {
     const node = ancestors[ancestors.length - 1];
-    const parent = ancestors[ancestors.length - 2];
-    return (parent.type === 'VariableDeclarator' || parent.type === 'FunctionDeclaration' || parent.type === 'ClassDeclaration') && parent.id === node;
+    // Walk outwards to find a declarator that binds the node
+    for (let i = ancestors.length - 2; i >= 0; i--) {
+      const parent = ancestors[i];
+      if (parent.type === 'VariableDeclarator') {
+        return parent.id === node || isInBindingPattern(parent.id, node);
+      }
+      if (parent.type === 'FunctionDeclaration' || parent.type === 'ClassDeclaration') {
+        return parent.id === node;
+      }
+    }
+    return false;
   },
   isClassOrFuncDeclarationId(ancestors) {
     const node = ancestors[ancestors.length - 1];
@@ -82,12 +119,16 @@ const identifier = {
   },
   isVarDeclarationInGlobalScope(ancestors) {
     const node = ancestors[ancestors.length - 1];
-    const parent = ancestors[ancestors.length - 2];
-    const grandParent = ancestors[ancestors.length - 3];
     const varBoundScopes = ['ClassDeclaration', 'ClassExpression', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'];
-    return parent.type === 'VariableDeclarator' && parent.id === node && grandParent.type === 'VariableDeclaration' && grandParent.kind === 'var' && ancestors.every(ancestor => {
-      return !varBoundScopes.includes(ancestor.type);
+    const declaratorIndex = ancestors.findIndex(ancestor => {
+      return ancestor.type === 'VariableDeclarator' && (ancestor === node || isInBindingPattern(ancestor.id, node));
     });
+    if (declaratorIndex === -1) return false;
+    const declarator = ancestors[declaratorIndex];
+    const declaration = ancestors[declaratorIndex - 1];
+    return declaration?.type === 'VariableDeclaration' && declaration.kind === 'var' && ancestors.every(ancestor => {
+      return !varBoundScopes.includes(ancestor.type);
+    }) && (declarator.id === node || isInBindingPattern(declarator.id, node));
   },
   isIife(ancestors) {
     const parent = ancestors[ancestors.length - 2];

package/dist/memberExpression.d.cts

@@ -1,4 +1,9 @@
 import MagicString from 'magic-string';
 import type { MemberExpression, Node } from 'oxc-parser';
 import type { FormatterOptions } from '../types.cjs';
-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/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 {};