@knighted/module 1.0.0-beta.0 → 1.0.0-beta.1

package/dist/cjs/exports.d.cts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+import type { CjsExport } from '../types.cjs';
+declare const exportsRename = "__exports";
+declare const requireMainRgx: RegExp;
+declare const collectCjsExports: (ast: Node) => Promise<Map<string, CjsExport>>;
+export { exportsRename, requireMainRgx, collectCjsExports };

package/dist/cjs/format.cjs

@@ -5,17 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.format = void 0;
 var _magicString = _interopRequireDefault(require("magic-string"));
-var _identifier = require("./formatters/identifier.cjs");
-var _metaProperty = require("./formatters/metaProperty.cjs");
-var _memberExpression = require("./formatters/memberExpression.cjs");
-var _assignmentExpression = require("./formatters/assignmentExpression.cjs");
-var _utils = require("./utils.cjs");
-var _identifier2 = require("./helpers/identifier.cjs");
-var _walk = require("./walk.cjs");
+var _identifier = require("#formatters/identifier.js");
+var _metaProperty = require("#formatters/metaProperty.js");
+var _memberExpression = require("#formatters/memberExpression.js");
+var _assignmentExpression = require("#formatters/assignmentExpression.js");
+var _url = require("#utils/url.js");
+var _exports = require("#utils/exports.js");
+var _identifiers = require("#utils/identifiers.js");
+var _identifier2 = require("#helpers/identifier.js");
+var _walk = require("#walk");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
- * Note, there is no specific conversion for `import.meta.main` as it does not exist.
- * @see https://github.com/nodejs/node/issues/49440
+ * Node added support for import.meta.main.
+ * Added in: v24.2.0, v22.18.0
+ * @see https://nodejs.org/api/esm.html#importmetamain
  */
 const format = async (src, ast, opts) => {
   const code = new _magicString.default(src);
@@ -25,14 +28,15 @@ const format = async (src, ast, opts) => {
     hasDefaultExportBeenReassigned: false,
     hasDefaultExportBeenAssigned: false
   };
-  await (0, _utils.collectModuleIdentifiers)(ast.program);
+  const exportTable = opts.target === 'module' ? await (0, _exports.collectCjsExports)(ast.program) : null;
+  await (0, _identifiers.collectModuleIdentifiers)(ast.program);
   if (opts.target === 'module' && opts.transformSyntax) {
     /**
      * Prepare ESM output by renaming `exports` to `__exports` and seeding an
      * `import.meta.filename` touch so import.meta is present even when the
      * original source never referenced it.
      */
-    code.prepend(`let ${_utils.exportsRename} = {};
+    code.prepend(`let ${_exports.exportsRename} = {};
 void import.meta.filename;
 `);
   }
@@ -53,7 +57,7 @@ void import.meta.filename;
        */
       if (node.type === 'AssignmentExpression' && node.left.type === 'MemberExpression' && node.left.object.type === 'MetaProperty' && node.left.property.type === 'Identifier' && node.left.property.name === 'url') {
         if (node.right.type === 'Literal' && typeof node.right.value === 'string') {
-          if (!(0, _utils.isValidUrl)(node.right.value)) {
+          if (!(0, _url.isValidUrl)(node.right.value)) {
             const rhs = code.snip(node.right.start, node.right.end).toString();
             const assignment = code.snip(node.start, node.end).toString();
             code.update(node.start, node.end, `/* Invalid assignment: ${rhs} is not a URL. ${assignment} */`);
@@ -110,6 +114,35 @@ void import.meta.filename;
       }
     }
   });
+  if (opts.target === 'module' && opts.transformSyntax && exportTable) {
+    const isValidExportName = name => /^[$A-Z_a-z][$\w]*$/.test(name);
+    const asExportName = name => isValidExportName(name) ? name : JSON.stringify(name);
+    const accessProp = name => isValidExportName(name) ? `${_exports.exportsRename}.${name}` : `${_exports.exportsRename}[${JSON.stringify(name)}]`;
+    const tempNameFor = name => {
+      const sanitized = name.replace(/[^$\w]/g, '_') || 'value';
+      const safe = /^[0-9]/.test(sanitized) ? `_${sanitized}` : sanitized;
+      return `__export_${safe}`;
+    };
+    const lines = [];
+    const defaultEntry = exportTable.get('default');
+    if (defaultEntry) {
+      const def = defaultEntry.fromIdentifier ?? _exports.exportsRename;
+      lines.push(`export default ${def};`);
+    }
+    for (const [key, entry] of exportTable) {
+      if (key === 'default') continue;
+      if (entry.fromIdentifier) {
+        lines.push(`export { ${entry.fromIdentifier} as ${asExportName(key)} };`);
+      } else {
+        const temp = tempNameFor(key);
+        lines.push(`const ${temp} = ${accessProp(key)};`);
+        lines.push(`export { ${temp} as ${asExportName(key)} };`);
+      }
+    }
+    if (lines.length) {
+      code.append(`\n${lines.join('\n')}\n`);
+    }
+  }
   return code.toString();
 };
 exports.format = format;

package/dist/cjs/format.d.cts

@@ -1,8 +1,9 @@
 import type { ParseResult } from 'oxc-parser';
 import type { FormatterOptions } from './types.cjs';
 /**
- * Note, there is no specific conversion for `import.meta.main` as it does not exist.
- * @see https://github.com/nodejs/node/issues/49440
+ * Node added support for import.meta.main.
+ * Added in: v24.2.0, v22.18.0
+ * @see https://nodejs.org/api/esm.html#importmetamain
  */
 declare const format: (src: string, ast: ParseResult, opts: FormatterOptions) => Promise<string>;
 export { format };

package/dist/cjs/formatters/assignmentExpression.cjs

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.assignmentExpression = void 0;
-var _walk = require("../walk.cjs");
+var _walk = require("#walk");
 const assignmentExpression = async ({
   node,
   parent: _parent,

package/dist/cjs/formatters/identifier.cjs

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.identifier = void 0;
-var _utils = require("../utils.cjs");
-var _identifier = require("../helpers/identifier.cjs");
+var _exports = require("#utils/exports.js");
+var _identifier = require("#helpers/identifier.js");
 const identifier = ({
   node,
   ancestors,
@@ -34,10 +34,10 @@ const identifier = ({
               // The code is reassigning `exports` to something else.
 
               meta.hasExportsBeenReassigned = true;
-              code.update(parent.left.start, parent.left.end, _utils.exportsRename);
+              code.update(parent.left.start, parent.left.end, _exports.exportsRename);
             }
             if (_identifier.identifier.isModuleScope(ancestors) && !_identifier.identifier.isFunctionExpressionId(ancestors) && !_identifier.identifier.isExportSpecifierAlias(ancestors) && !_identifier.identifier.isClassPropertyKey(ancestors) && !_identifier.identifier.isMethodDefinitionKey(ancestors) && !_identifier.identifier.isMemberKey(ancestors) && !_identifier.identifier.isPropertyKey(ancestors) && !_identifier.identifier.isIife(ancestors)) {
-              code.update(start, end, _utils.exportsRename);
+              code.update(start, end, _exports.exportsRename);
             }
           }
         }

package/dist/cjs/formatters/memberExpression.cjs

@@ -4,11 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.memberExpression = void 0;
-var _utils = require("../utils.cjs");
+var _exports = require("#utils/exports.js");
 const memberExpression = (node, parent, src, options) => {
   if (options.target === 'module') {
     if (node.object.type === 'Identifier' && node.property.type === 'Identifier' && node.object.name === 'module' && node.property.name === 'exports') {
-      src.update(node.start, node.end, _utils.exportsRename);
+      src.update(node.start, node.end, _exports.exportsRename);
       return;
     }
     if (node.object.type === 'Identifier' && node.property.type === 'Identifier' && node.object.name === 'require') {

package/dist/cjs/identifiers.d.cts

@@ -0,0 +1,19 @@
+import type { Node } from 'oxc-parser';
+import type { IdentMeta, Scope } from '../types.cjs';
+declare const collectScopeIdentifiers: (node: Node, scopes: Scope[]) => void;
+/**
+ * Collects all module scope identifiers in the AST.
+ *
+ * Ignores identifiers that are in functions or classes.
+ * Ignores new scopes for StaticBlock nodes (can only reference static class members).
+ *
+ * Special case handling for these which create their own scopes,
+ * but are also valid module scope identifiers:
+ * - ClassDeclaration
+ * - FunctionDeclaration
+ *
+ * Special case handling for var inside BlockStatement
+ * which are also valid module scope identifiers.
+ */
+declare const collectModuleIdentifiers: (ast: Node, hoisting?: boolean) => Promise<Map<string, IdentMeta>>;
+export { collectScopeIdentifiers, collectModuleIdentifiers };

package/dist/cjs/lang.d.cts

@@ -0,0 +1,4 @@
+import type { Specifier } from '@knighted/specifier';
+type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
+declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+export { getLangFromExt };

package/dist/cjs/module.cjs

@@ -7,9 +7,9 @@ exports.transform = void 0;
 var _nodePath = require("node:path");
 var _promises = require("node:fs/promises");
 var _specifier = require("@knighted/specifier");
-var _parse = require("./parse.cjs");
-var _format = require("./format.cjs");
-var _utils = require("./utils.cjs");
+var _parse = require("#parse");
+var _format = require("#format");
+var _lang = require("#utils/lang.js");
 const defaultOptions = {
   target: 'commonjs',
   sourceType: 'auto',
@@ -34,7 +34,7 @@ const transform = async (filename, options = defaultOptions) => {
   const ast = (0, _parse.parse)(filename, code);
   let source = await (0, _format.format)(code, ast, opts);
   if (opts.rewriteSpecifier) {
-    const code = await _specifier.specifier.updateSrc(source, (0, _utils.getLangFromExt)(filename), ({
+    const code = await _specifier.specifier.updateSrc(source, (0, _lang.getLangFromExt)(filename), ({
       value
     }) => {
       if (typeof opts.rewriteSpecifier === 'function') {

package/dist/cjs/types.d.cts

@@ -21,6 +21,14 @@ export type ExportsMeta = {
     hasDefaultExportBeenAssigned: boolean;
     defaultExportValue: unknown;
 };
+export type CjsExport = {
+    key: string;
+    writes: SpannedNode[];
+    fromIdentifier?: string;
+    via: Set<'exports' | 'module.exports'>;
+    reassignments: SpannedNode[];
+    hasGetter?: boolean;
+};
 export type IdentMeta = {
     declare: SpannedNode[];
     read: SpannedNode[];

package/dist/cjs/url.d.cts

@@ -0,0 +1,2 @@
+declare const isValidUrl: (url: string) => boolean;
+export { isValidUrl };

package/dist/cjs/utils/exports.cjs

@@ -0,0 +1,227 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requireMainRgx = exports.exportsRename = exports.collectCjsExports = void 0;
+var _walk = require("#walk");
+const exportsRename = exports.exportsRename = '__exports';
+const requireMainRgx = exports.requireMainRgx = /(require\.main\s*===\s*module|module\s*===\s*require\.main)/g;
+const literalPropName = (prop, literals) => {
+  if (prop.type === 'Identifier') return literals?.get(prop.name)?.toString() ?? prop.name;
+  if (prop.type === 'Literal' && (typeof prop.value === 'string' || typeof prop.value === 'number')) {
+    return String(prop.value);
+  }
+  if (prop.type === 'TemplateLiteral' && prop.expressions.length === 0 && prop.quasis.length === 1) {
+    return prop.quasis[0].value.cooked ?? prop.quasis[0].value.raw;
+  }
+  return null;
+};
+const resolveExportTarget = (node, aliases, literals) => {
+  if (node.type === 'Identifier' && node.name === 'exports') {
+    return {
+      key: 'default',
+      via: 'exports'
+    };
+  }
+  if (node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'module' && node.property.type === 'Identifier' && node.property.name === 'exports') {
+    return {
+      key: 'default',
+      via: 'module.exports'
+    };
+  }
+  if (node.type !== 'MemberExpression') return null;
+  const base = node.object;
+  const prop = node.property;
+  const key = literalPropName(prop, literals);
+  if (!key) return null;
+  const baseVia = resolveBase(base, aliases);
+  if (!baseVia) return null;
+  if (baseVia === 'module.exports' && key === 'exports') {
+    return {
+      key: 'default',
+      via: 'module.exports'
+    };
+  }
+  return {
+    key,
+    via: baseVia
+  };
+};
+const resolveBase = (node, aliases) => {
+  if (node.type === 'Identifier') {
+    if (node.name === 'exports') return 'exports';
+    const alias = aliases.get(node.name);
+    if (alias) return alias;
+  }
+  if (node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'module' && node.property.type === 'Identifier' && node.property.name === 'exports') {
+    return 'module.exports';
+  }
+  return null;
+};
+const collectCjsExports = async ast => {
+  const exportsMap = new Map();
+  const localToExport = new Map();
+  const aliases = new Map();
+  const literals = new Map();
+  const addExport = (ref, node, rhs, options) => {
+    const entry = exportsMap.get(ref.key) ?? {
+      key: ref.key,
+      writes: [],
+      via: new Set(),
+      reassignments: []
+    };
+    entry.via.add(ref.via);
+    entry.writes.push(node);
+    if (options?.hasGetter) {
+      entry.hasGetter = true;
+    }
+    if (rhs) {
+      entry.fromIdentifier ??= rhs.name;
+      const set = localToExport.get(rhs.name) ?? new Set();
+      set.add(ref.key);
+      localToExport.set(rhs.name, set);
+    }
+    exportsMap.set(ref.key, entry);
+  };
+  await (0, _walk.ancestorWalk)(ast, {
+    enter(node) {
+      if (node.type === 'VariableDeclarator' && node.id.type === 'Identifier' && node.init) {
+        const via = resolveBase(node.init, aliases);
+        if (via) {
+          aliases.set(node.id.name, via);
+        }
+        if (node.init.type === 'Literal' && (typeof node.init.value === 'string' || typeof node.init.value === 'number')) {
+          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 (node.type === 'AssignmentExpression') {
+        const target = resolveExportTarget(node.left, aliases, literals);
+        if (target) {
+          const rhsIdent = node.right.type === 'Identifier' ? node.right : undefined;
+          addExport(target, node, rhsIdent);
+          return;
+        }
+        if (node.left.type === 'Identifier') {
+          const keys = localToExport.get(node.left.name);
+          if (keys) {
+            keys.forEach(key => {
+              const entry = exportsMap.get(key);
+              if (entry) {
+                entry.reassignments.push(node);
+                exportsMap.set(key, entry);
+              }
+            });
+          }
+        }
+        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.type === 'CallExpression') {
+        const callee = node.callee;
+
+        // 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);
+          if (!ref) return;
+          for (let i = 1; i < node.arguments.length; i++) {
+            const arg = node.arguments[i];
+            if (arg.type === 'ObjectExpression') {
+              for (const prop of arg.properties) {
+                if (prop.type !== 'Property') continue;
+                const keyName = literalPropName(prop.key, literals);
+                if (!keyName) continue;
+                let rhsIdent;
+                if (prop.value.type === 'Identifier') {
+                  rhsIdent = prop.value;
+                }
+                addExport({
+                  key: keyName,
+                  via: ref
+                }, node, rhsIdent);
+              }
+            }
+          }
+        }
+
+        // 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);
+          if (!target) return;
+          const keyName = literalPropName(node.arguments[1], literals);
+          if (!keyName) return;
+          const desc = node.arguments[2];
+          if (desc.type !== 'ObjectExpression') return;
+          let rhsIdent;
+          let hasGetter = false;
+          for (const prop of desc.properties) {
+            if (prop.type !== 'Property') continue;
+            if (prop.key.type !== 'Identifier') continue;
+            if (prop.key.name === 'value' && prop.value.type === 'Identifier') {
+              rhsIdent = prop.value;
+            }
+            if (prop.key.name === 'get' && prop.value.type === 'Identifier') {
+              hasGetter = true;
+            }
+            if (prop.key.name === 'set' && prop.value.type === 'Identifier') {
+              // Setter-only doesn’t create a readable export; ignore beyond marking write
+            }
+          }
+          addExport({
+            key: keyName,
+            via: target
+          }, node, rhsIdent, {
+            hasGetter
+          });
+        }
+
+        // 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);
+          if (!target) return;
+          const descMap = node.arguments[1];
+          if (descMap.type !== 'ObjectExpression') return;
+          for (const prop of descMap.properties) {
+            if (prop.type !== 'Property') continue;
+            const keyName = literalPropName(prop.key, literals);
+            if (!keyName) continue;
+            if (prop.value.type !== 'ObjectExpression') continue;
+            let rhsIdent;
+            let hasGetter = false;
+            for (const descProp of prop.value.properties) {
+              if (descProp.type !== 'Property') continue;
+              if (descProp.key.type !== 'Identifier') continue;
+              if (descProp.key.name === 'value' && descProp.value.type === 'Identifier') {
+                rhsIdent = descProp.value;
+              }
+              if (descProp.key.name === 'get' && descProp.value.type === 'Identifier') {
+                hasGetter = true;
+              }
+            }
+            addExport({
+              key: keyName,
+              via: target
+            }, node, rhsIdent, {
+              hasGetter
+            });
+          }
+        }
+      }
+    }
+  });
+  return exportsMap;
+};
+exports.collectCjsExports = collectCjsExports;

package/dist/cjs/utils/identifiers.cjs

@@ -0,0 +1,190 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collectScopeIdentifiers = exports.collectModuleIdentifiers = void 0;
+var _walk = require("#walk");
+var _scope = require("#helpers/scope.js");
+var _identifier = require("#helpers/identifier.js");
+const collectScopeIdentifiers = (node, scopes) => {
+  const {
+    type
+  } = node;
+  switch (type) {
+    case 'BlockStatement':
+    case 'ClassBody':
+      scopes.push({
+        node,
+        type: 'Block',
+        name: type,
+        idents: new Set()
+      });
+      break;
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'ArrowFunctionExpression':
+      {
+        const name = node.id ? node.id.name : 'anonymous';
+        const scope = {
+          node,
+          name,
+          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);
+        });
+
+        /**
+         * If a FunctionExpression has an id, it is a named function expression.
+         * The function expression name shadows the module scope identifier, so
+         * we don't want to count reads of module identifers that have the same name.
+         * They also do not cause a SyntaxError if the function expression name is
+         * the same as a module scope identifier.
+         *
+         * TODO: Is this necessary for FunctionDeclaration?
+         */
+        if (node.type === 'FunctionExpression' && node.id) {
+          scope.idents.add(node.id.name);
+        }
+
+        // First add the function to any previous scopes
+        if (scopes.length > 0) {
+          scopes[scopes.length - 1].idents.add(name);
+        }
+
+        // Then add the function scope to the scopes stack
+        scopes.push(scope);
+      }
+      break;
+    case 'ClassDeclaration':
+      {
+        const className = node.id ? node.id.name : 'anonymous';
+
+        // First add the class to any previous scopes
+        if (scopes.length > 0) {
+          scopes[scopes.length - 1].idents.add(className);
+        }
+
+        // Then add the class to the scopes stack
+        scopes.push({
+          node,
+          name: className,
+          type: 'Class',
+          idents: new Set()
+        });
+      }
+      break;
+    case 'ClassExpression':
+      {}
+      break;
+    case 'VariableDeclaration':
+      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);
+          }
+        });
+      }
+      break;
+  }
+};
+
+/**
+ * Collects all module scope identifiers in the AST.
+ *
+ * Ignores identifiers that are in functions or classes.
+ * Ignores new scopes for StaticBlock nodes (can only reference static class members).
+ *
+ * Special case handling for these which create their own scopes,
+ * but are also valid module scope identifiers:
+ * - ClassDeclaration
+ * - FunctionDeclaration
+ *
+ * Special case handling for var inside BlockStatement
+ * which are also valid module scope identifiers.
+ */
+exports.collectScopeIdentifiers = collectScopeIdentifiers;
+const collectModuleIdentifiers = async (ast, hoisting = true) => {
+  const identifiers = new Map();
+  const globalReads = new Map();
+  const scopes = [];
+  await (0, _walk.ancestorWalk)(ast, {
+    enter(node, ancestors) {
+      const {
+        type
+      } = node;
+      collectScopeIdentifiers(node, scopes);
+
+      // Add module scope identifiers to the registry map
+
+      if (type === 'Identifier') {
+        const {
+          name
+        } = node;
+        const meta = identifiers.get(name) ?? {
+          declare: [],
+          read: []
+        };
+        const isDeclaration = _identifier.identifier.isDeclaration(ancestors);
+        const inScope = scopes.some(scope => scope.idents.has(name) || scope.name === name);
+        if (hoisting && !_identifier.identifier.isDeclaration(ancestors) && !_identifier.identifier.isFunctionExpressionId(ancestors) && !_identifier.identifier.isExportSpecifierAlias(ancestors) && !_identifier.identifier.isClassPropertyKey(ancestors) && !_identifier.identifier.isMethodDefinitionKey(ancestors) && !_identifier.identifier.isMemberKey(ancestors) && !_identifier.identifier.isPropertyKey(ancestors) && !_identifier.identifier.isIife(ancestors) && !inScope) {
+          if (globalReads.has(name)) {
+            globalReads.get(name)?.push(node);
+          } else {
+            globalReads.set(name, [node]);
+          }
+        }
+        if (isDeclaration) {
+          const isModuleScope = _identifier.identifier.isModuleScope(ancestors);
+          const isClassOrFuncDeclaration = _identifier.identifier.isClassOrFuncDeclarationId(ancestors);
+          const isVarDeclarationInGlobalScope = _identifier.identifier.isVarDeclarationInGlobalScope(ancestors);
+          if (isModuleScope || isClassOrFuncDeclaration || isVarDeclarationInGlobalScope) {
+            meta.declare.push(node);
+
+            // Check for hoisted reads
+            if (hoisting && globalReads.has(name)) {
+              const reads = globalReads.get(name);
+              if (reads) {
+                reads.forEach(read => {
+                  if (!meta.read.includes(read)) {
+                    meta.read.push(read);
+                  }
+                });
+              }
+            }
+            identifiers.set(name, meta);
+          }
+        } else {
+          if (identifiers.has(name) && !inScope && !_identifier.identifier.isIife(ancestors) && !_identifier.identifier.isFunctionExpressionId(ancestors) && !_identifier.identifier.isExportSpecifierAlias(ancestors) && !_identifier.identifier.isClassPropertyKey(ancestors) && !_identifier.identifier.isMethodDefinitionKey(ancestors) && !_identifier.identifier.isMemberKey(ancestors) && !_identifier.identifier.isPropertyKey(ancestors)) {
+            // Closure is referencing module scope identifier
+            meta.read.push(node);
+          }
+        }
+      }
+    },
+    leave(node) {
+      const {
+        type
+      } = node;
+      if (_scope.scopes.includes(type)) {
+        scopes.pop();
+      }
+    }
+  });
+  return identifiers;
+};
+exports.collectModuleIdentifiers = collectModuleIdentifiers;

package/dist/cjs/utils/lang.cjs

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLangFromExt = void 0;
+var _nodePath = require("node:path");
+// Determine language from filename extension for specifier rewrite.
+
+const getLangFromExt = filename => {
+  const ext = (0, _nodePath.extname)(filename);
+  if (ext.endsWith('.js')) {
+    return 'js';
+  }
+  if (ext.endsWith('.ts')) {
+    return 'ts';
+  }
+  if (ext === '.tsx') {
+    return 'tsx';
+  }
+  if (ext === '.jsx') {
+    return 'jsx';
+  }
+};
+exports.getLangFromExt = getLangFromExt;