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

package/dist/format.js

@@ -1,15 +1,251 @@
 import MagicString from 'magic-string';
-import { identifier } from './formatters/identifier.js';
-import { metaProperty } from './formatters/metaProperty.js';
-import { memberExpression } from './formatters/memberExpression.js';
-import { assignmentExpression } from './formatters/assignmentExpression.js';
-import { isValidUrl, exportsRename, collectModuleIdentifiers } from './utils.js';
-import { isIdentifierName } from './helpers/identifier.js';
-import { ancestorWalk } from './walk.js';
+import { identifier } from '#formatters/identifier.js';
+import { metaProperty } from '#formatters/metaProperty.js';
+import { memberExpression } from '#formatters/memberExpression.js';
+import { assignmentExpression } from '#formatters/assignmentExpression.js';
+import { isValidUrl } from '#utils/url.js';
+import { exportsRename, collectCjsExports } from '#utils/exports.js';
+import { collectModuleIdentifiers } from '#utils/identifiers.js';
+import { isIdentifierName } from '#helpers/identifier.js';
+import { ancestorWalk } from '#walk';
+const isValidIdent = name => /^[$A-Z_a-z][$\w]*$/.test(name);
+const exportAssignment = (name, expr, live) => {
+  const prop = isValidIdent(name) ? `.${name}` : `[${JSON.stringify(name)}]`;
+  if (live === 'strict') {
+    const key = JSON.stringify(name);
+    return `Object.defineProperty(exports, ${key}, { enumerable: true, get: () => ${expr} });`;
+  }
+  return `exports${prop} = ${expr};`;
+};
+const defaultInteropName = '__interopDefault';
+const interopHelper = `const ${defaultInteropName} = mod => (mod && mod.__esModule ? mod.default : mod);\n`;
+const hasTopLevelAwait = program => {
+  let found = false;
+  const walkNode = (node, inFunction) => {
+    if (found) return;
+    switch (node.type) {
+      case 'FunctionDeclaration':
+      case 'FunctionExpression':
+      case 'ArrowFunctionExpression':
+      case 'ClassDeclaration':
+      case 'ClassExpression':
+        inFunction = true;
+        break;
+    }
+    if (!inFunction && node.type === 'AwaitExpression') {
+      found = true;
+      return;
+    }
+    const keys = Object.keys(node);
+    for (const key of keys) {
+      const value = node[key];
+      if (!value) continue;
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item && typeof item === 'object') {
+            walkNode(item, inFunction);
+            if (found) return;
+          }
+        }
+      } else if (value && typeof value === 'object') {
+        walkNode(value, inFunction);
+        if (found) return;
+      }
+    }
+  };
+  walkNode(program, false);
+  return found;
+};
+const lowerEsmToCjs = (program, code, opts, containsTopLevelAwait) => {
+  const live = opts.liveBindings ?? 'strict';
+  const importTransforms = [];
+  const exportTransforms = [];
+  let needsInterop = false;
+  let importIndex = 0;
+  for (const node of program.body) {
+    if (node.type === 'ImportDeclaration') {
+      const srcLiteral = code.slice(node.source.start, node.source.end);
+      const specifiers = node.specifiers ?? [];
+      const defaultSpec = specifiers.find(s => s.type === 'ImportDefaultSpecifier');
+      const namespaceSpec = specifiers.find(s => s.type === 'ImportNamespaceSpecifier');
+      const namedSpecs = specifiers.filter(s => s.type === 'ImportSpecifier');
+
+      // Side-effect import
+      if (!specifiers.length) {
+        importTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `require(${srcLiteral});\n`,
+          needsInterop: false
+        });
+        continue;
+      }
+      const modIdent = `__mod${importIndex++}`;
+      const lines = [];
+      lines.push(`const ${modIdent} = require(${srcLiteral});`);
+      if (namespaceSpec) {
+        lines.push(`const ${namespaceSpec.local.name} = ${modIdent};`);
+      }
+      if (defaultSpec) {
+        let init = modIdent;
+        switch (opts.cjsDefault) {
+          case 'module-exports':
+            init = modIdent;
+            break;
+          case 'none':
+            init = `${modIdent}.default`;
+            break;
+          case 'auto':
+          default:
+            init = `${defaultInteropName}(${modIdent})`;
+            needsInterop = true;
+            break;
+        }
+        lines.push(`const ${defaultSpec.local.name} = ${init};`);
+      }
+      if (namedSpecs.length) {
+        const pairs = namedSpecs.map(s => {
+          const imported = s.imported.name;
+          const local = s.local.name;
+          return imported === local ? imported : `${imported}: ${local}`;
+        });
+        lines.push(`const { ${pairs.join(', ')} } = ${modIdent};`);
+      }
+      importTransforms.push({
+        start: node.start,
+        end: node.end,
+        code: `${lines.join('\n')}\n`,
+        needsInterop
+      });
+    }
+    if (node.type === 'ExportNamedDeclaration') {
+      // Handle declaration exports
+      if (node.declaration) {
+        const decl = node.declaration;
+        const declSrc = code.slice(decl.start, decl.end);
+        const exportedNames = [];
+        if (decl.type === 'VariableDeclaration') {
+          for (const d of decl.declarations) {
+            if (d.id.type === 'Identifier') {
+              exportedNames.push(d.id.name);
+            }
+          }
+        } else if (decl.id?.type === 'Identifier') {
+          exportedNames.push(decl.id.name);
+        }
+        const exportLines = exportedNames.map(name => exportAssignment(name, name, live));
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${declSrc}\n${exportLines.join('\n')}\n`
+        });
+        continue;
+      }
 
+      // Handle re-export or local specifiers
+      if (node.specifiers?.length) {
+        if (node.source) {
+          const srcLiteral = code.slice(node.source.start, node.source.end);
+          const modIdent = `__mod${importIndex++}`;
+          const lines = [`const ${modIdent} = require(${srcLiteral});`];
+          for (const spec of node.specifiers) {
+            if (spec.type !== 'ExportSpecifier') continue;
+            const exported = spec.exported.name;
+            const imported = spec.local.name;
+            let rhs = `${modIdent}.${imported}`;
+            if (imported === 'default') {
+              rhs = `${defaultInteropName}(${modIdent})`;
+              needsInterop = true;
+            }
+            lines.push(exportAssignment(exported, rhs, live));
+          }
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${lines.join('\n')}\n`,
+            needsInterop
+          });
+        } else {
+          const lines = [];
+          for (const spec of node.specifiers) {
+            if (spec.type !== 'ExportSpecifier') continue;
+            const exported = spec.exported.name;
+            const local = spec.local.name;
+            lines.push(exportAssignment(exported, local, live));
+          }
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${lines.join('\n')}\n`
+          });
+        }
+      }
+    }
+    if (node.type === 'ExportDefaultDeclaration') {
+      const decl = node.declaration;
+      const useExportsObject = containsTopLevelAwait && opts.topLevelAwait !== 'error';
+      if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration') {
+        if (decl.id?.name) {
+          const declSrc = code.slice(decl.start, decl.end);
+          const assign = useExportsObject ? `exports.default = ${decl.id.name};` : `module.exports = ${decl.id.name};`;
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${declSrc}\n${assign}\n`
+          });
+        } else {
+          const declSrc = code.slice(decl.start, decl.end);
+          const assign = useExportsObject ? `exports.default = ${declSrc};` : `module.exports = ${declSrc};`;
+          exportTransforms.push({
+            start: node.start,
+            end: node.end,
+            code: `${assign}\n`
+          });
+        }
+      } else {
+        const exprSrc = code.slice(decl.start, decl.end);
+        const assign = useExportsObject ? `exports.default = ${exprSrc};` : `module.exports = ${exprSrc};`;
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${assign}\n`
+        });
+      }
+    }
+    if (node.type === 'ExportAllDeclaration') {
+      const srcLiteral = code.slice(node.source.start, node.source.end);
+      if (node.exported) {
+        const exported = node.exported.name;
+        const modIdent = `__mod${importIndex++}`;
+        const lines = [`const ${modIdent} = require(${srcLiteral});`, exportAssignment(exported, modIdent, live)];
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${lines.join('\n')}\n`
+        });
+      } else {
+        const modIdent = `__mod${importIndex++}`;
+        const lines = [`const ${modIdent} = require(${srcLiteral});`];
+        const loop = `for (const k in ${modIdent}) {\n  if (k === 'default') continue;\n  if (!Object.prototype.hasOwnProperty.call(${modIdent}, k)) continue;\n  Object.defineProperty(exports, k, { enumerable: true, get: () => ${modIdent}[k] });\n}`;
+        lines.push(loop);
+        exportTransforms.push({
+          start: node.start,
+          end: node.end,
+          code: `${lines.join('\n')}\n`
+        });
+      }
+    }
+  }
+  return {
+    importTransforms,
+    exportTransforms,
+    needsInterop
+  };
+};
 /**
- * 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(src);
@@ -19,7 +255,15 @@ const format = async (src, ast, opts) => {
     hasDefaultExportBeenReassigned: false,
     hasDefaultExportBeenAssigned: false
   };
+  const exportTable = opts.target === 'module' ? await collectCjsExports(ast.program) : null;
   await collectModuleIdentifiers(ast.program);
+  const shouldCheckTopLevelAwait = opts.target === 'commonjs' && opts.transformSyntax;
+  const containsTopLevelAwait = shouldCheckTopLevelAwait ? hasTopLevelAwait(ast.program) : false;
+  const shouldLowerCjs = opts.target === 'commonjs' && opts.transformSyntax;
+  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).');
+  }
   if (opts.target === 'module' && opts.transformSyntax) {
     /**
      * Prepare ESM output by renaming `exports` to `__exports` and seeding an
@@ -104,6 +348,64 @@ void import.meta.filename;
       }
     }
   });
+  if (shouldLowerCjs) {
+    const {
+      importTransforms,
+      exportTransforms,
+      needsInterop
+    } = lowerEsmToCjs(ast.program, code, opts, containsTopLevelAwait);
+    pendingCjsTransforms = {
+      transforms: [...importTransforms, ...exportTransforms].sort((a, b) => a.start - b.start),
+      needsInterop
+    };
+  }
+  if (pendingCjsTransforms) {
+    for (const t of pendingCjsTransforms.transforms) {
+      code.overwrite(t.start, t.end, t.code);
+    }
+    if (pendingCjsTransforms.needsInterop) {
+      code.prepend(`${interopHelper}exports.__esModule = true;\n`);
+    }
+  }
+  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) ? `${exportsRename}.${name}` : `${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 ?? 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`);
+    }
+  }
+  if (opts.target === 'commonjs' && opts.transformSyntax && containsTopLevelAwait) {
+    const body = code.toString();
+    if (opts.topLevelAwait === 'wrap') {
+      const tlaPromise = `const __tla = (async () => {\n${body}\nreturn module.exports;\n})();\n`;
+      const setPromise = `const __setTla = target => {\n  if (!target) return;\n  const type = typeof target;\n  if (type !== 'object' && type !== 'function') return;\n  target.__tla = __tla;\n};\n`;
+      const attach = `__setTla(module.exports);\n__tla.then(resolved => __setTla(resolved), err => { throw err; });\n`;
+      return `${tlaPromise}${setPromise}${attach}`;
+    }
+    return `;(async () => {\n${body}\n})();\n`;
+  }
   return code.toString();
 };
 export { format };

package/dist/formatters/assignmentExpression.js

@@ -1,4 +1,4 @@
-import { walk } from '../walk.js';
+import { walk } from '#walk';
 export const assignmentExpression = async ({
   node,
   parent: _parent,

package/dist/formatters/identifier.js

@@ -1,5 +1,5 @@
-import { exportsRename } from '../utils.js';
-import { identifier as ident } from '../helpers/identifier.js';
+import { exportsRename } from '#utils/exports.js';
+import { identifier as ident } from '#helpers/identifier.js';
 export const identifier = ({
   node,
   ancestors,

package/dist/formatters/memberExpression.js

@@ -1,4 +1,4 @@
-import { exportsRename } from '../utils.js';
+import { exportsRename } from '#utils/exports.js';
 export 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') {

package/dist/formatters/metaProperty.js

@@ -1,3 +1,16 @@
+const importMetaMainSupport = '(() => { const [__nmaj, __nmin] = process.versions.node.split(".").map(n => parseInt(n, 10) || 0); return (__nmaj > 24 || (__nmaj === 24 && __nmin >= 2) || (__nmaj === 22 && __nmin >= 18)); })()';
+const importMetaMainShim = 'process.argv[1] === __filename';
+const importMetaMainExpr = mode => {
+  switch (mode) {
+    case 'warn':
+      return `(${importMetaMainSupport} ? ${importMetaMainShim} : (console.warn("import.meta.main is not supported before Node 22.18/24.2; falling back to shim."), ${importMetaMainShim}))`;
+    case 'error':
+      return `(${importMetaMainSupport} ? ${importMetaMainShim} : (() => { throw new Error("import.meta.main is not supported before Node 22.18/24.2"); })())`;
+    case 'shim':
+    default:
+      return importMetaMainShim;
+  }
+};
 export const metaProperty = (node, parent, src, options) => {
   if (options.target === 'commonjs') {
     if (parent?.type !== 'MemberExpression') {
@@ -21,10 +34,15 @@ export const metaProperty = (node, parent, src, options) => {
           break;
         case 'resolve':
           /**
-           * Should this be `require('node:url').pathToFileURL(require.resolve(<parsed specifier>)).href`?
+           * Map to require.resolve intentionally: matches CJS resolution semantics.
+           * Wrapping in pathToFileURL(...) would change the return shape (URL string)
+           * without truly emulating ESM import.meta.resolve rules.
            */
           src.update(parent.start, parent.end, 'require.resolve');
           break;
+        case 'main':
+          src.update(parent.start, parent.end, importMetaMainExpr(options.importMetaMain));
+          break;
       }
     }
   }

package/dist/identifiers.d.ts

@@ -0,0 +1,19 @@
+import type { Node } from 'oxc-parser';
+import type { IdentMeta, Scope } from '../types.js';
+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/lang.d.ts

@@ -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/module.js

@@ -1,9 +1,9 @@
 import { resolve } from 'node:path';
 import { readFile, writeFile } from 'node:fs/promises';
 import { specifier } from '@knighted/specifier';
-import { parse } from './parse.js';
-import { format } from './format.js';
-import { getLangFromExt } from './utils.js';
+import { parse } from '#parse';
+import { format } from '#format';
+import { getLangFromExt } from '#utils/lang.js';
 const defaultOptions = {
   target: 'commonjs',
   sourceType: 'auto',
@@ -12,6 +12,7 @@ const defaultOptions = {
   rewriteSpecifier: undefined,
   dirFilename: 'inject',
   importMeta: 'shim',
+  importMetaMain: 'shim',
   requireSource: 'builtin',
   cjsDefault: 'auto',
   topLevelAwait: 'error',

package/dist/src/format.d.ts

@@ -0,0 +1,9 @@
+import type { ParseResult } from 'oxc-parser';
+import type { FormatterOptions } from './types.js';
+/**
+ * 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/src/module.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleOptions } from './types.js';
+declare const transform: (filename: string, options?: ModuleOptions) => Promise<string>;
+export { transform };

package/dist/src/parse.d.ts

@@ -0,0 +1,2 @@
+declare const parse: (filename: string, code: string) => import("oxc-parser").ParseResult;
+export { parse };

package/dist/src/types.d.ts

@@ -0,0 +1,44 @@
+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);
+export type ModuleOptions = {
+    target: 'module' | 'commonjs';
+    sourceType?: 'auto' | 'module' | 'commonjs';
+    transformSyntax?: boolean;
+    liveBindings?: 'strict' | 'loose' | 'off';
+    rewriteSpecifier?: RewriteSpecifier;
+    dirFilename?: 'inject' | 'preserve' | 'error';
+    importMeta?: 'preserve' | 'shim' | 'error';
+    importMetaMain?: 'shim' | 'warn' | 'error';
+    requireSource?: 'builtin' | 'create-require';
+    cjsDefault?: 'module-exports' | 'auto' | 'none';
+    topLevelAwait?: 'error' | 'wrap' | 'preserve';
+    out?: string;
+    inPlace?: boolean;
+};
+export type SpannedNode = Node & Span;
+export type ExportsMeta = {
+    hasExportsBeenReassigned: boolean;
+    hasDefaultExportBeenReassigned: boolean;
+    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[];
+};
+export type Scope = {
+    type: string;
+    name: string;
+    node: Node;
+    idents: Set<string>;
+};
+export type FormatterOptions = Omit<ModuleOptions, 'out' | 'inPlace'>;
+export type Identifier = IdentifierName | IdentifierReference | BindingIdentifier | LabelIdentifier | TSIndexSignatureName;

package/dist/src/utils/exports.d.ts

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

package/dist/src/utils/identifiers.d.ts

@@ -0,0 +1,19 @@
+import type { Node } from 'oxc-parser';
+import type { IdentMeta, Scope } from '../types.js';
+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/src/utils/lang.d.ts

@@ -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/src/utils/url.d.ts

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

package/dist/src/utils.d.ts

@@ -0,0 +1,26 @@
+import type { Node } from 'oxc-parser';
+import type { Specifier } from '@knighted/specifier';
+import type { IdentMeta, Scope, CjsExport } from './types.js';
+type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
+declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+declare const isValidUrl: (url: string) => boolean;
+declare const exportsRename = "__exports";
+declare const requireMainRgx: RegExp;
+declare const collectCjsExports: (ast: Node) => Promise<Map<string, CjsExport>>;
+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 { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, collectCjsExports, exportsRename, requireMainRgx, };

package/dist/src/walk.d.ts

@@ -0,0 +1,20 @@
+import type { Node } from 'oxc-parser';
+/**
+ * Using visitorKeys instead of oxc Visitor to keep
+ * an ancestor-aware enter/leave API with this.skip()
+ * without per-node method boilerplate.
+ */
+type AncestorContext = {
+    skip: () => void;
+};
+type AncestorVisitor = {
+    enter?: (this: AncestorContext, node: Node, ancestors: Node[]) => void | Promise<void>;
+    leave?: (this: AncestorContext, node: Node, ancestors: Node[]) => void | Promise<void>;
+};
+type WalkVisitor = {
+    enter?: (this: AncestorContext, node: Node, parent: Node | null) => void | Promise<void>;
+    leave?: (this: AncestorContext, node: Node, parent: Node | null) => void | Promise<void>;
+};
+declare const ancestorWalk: (node: Node, visitors: AncestorVisitor) => Promise<void>;
+declare const walk: (node: Node, visitors: WalkVisitor) => Promise<void>;
+export { ancestorWalk, walk };

package/dist/types.d.ts

@@ -8,6 +8,7 @@ export type ModuleOptions = {
     rewriteSpecifier?: RewriteSpecifier;
     dirFilename?: 'inject' | 'preserve' | 'error';
     importMeta?: 'preserve' | 'shim' | 'error';
+    importMetaMain?: 'shim' | 'warn' | 'error';
     requireSource?: 'builtin' | 'create-require';
     cjsDefault?: 'module-exports' | 'auto' | 'none';
     topLevelAwait?: 'error' | 'wrap' | 'preserve';
@@ -21,6 +22,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/url.d.ts

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