oxc-parser 0.87.0 → 0.89.0

package/generated/lazy/{types.js → types.mjs}

@@ -1,10 +1,8 @@
 // Auto-generated code, DO NOT EDIT DIRECTLY!
 // To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer_lazy.rs`.
 
-'use strict';
-
 // Mapping from node type name to node type ID
-const NODE_TYPE_IDS_MAP = new Map([
+export const NODE_TYPE_IDS_MAP = new Map([
   // Leaf nodes
   ['IdentifierName', 0],
   ['IdentifierReference', 1],
@@ -188,11 +186,5 @@ const NODE_TYPE_IDS_MAP = new Map([
   ['JSDocNonNullableType', 178],
 ]);
 
-const NODE_TYPES_COUNT = 179,
-  LEAF_NODE_TYPES_COUNT = 38;
-
-module.exports = {
-  NODE_TYPE_IDS_MAP,
-  NODE_TYPES_COUNT,
-  LEAF_NODE_TYPES_COUNT,
-};
+export const NODE_TYPES_COUNT = 179;
+export const LEAF_NODE_TYPES_COUNT = 38;

package/generated/lazy/{walk.js → walk.mjs}

@@ -1,191 +1,189 @@
 // Auto-generated code, DO NOT EDIT DIRECTLY!
 // To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer_lazy.rs`.
 
-'use strict';
-
-const {
-  Program,
-  IdentifierName,
-  IdentifierReference,
-  BindingIdentifier,
-  LabelIdentifier,
-  ThisExpression,
+import {
+  AccessorProperty,
+  ArrayAssignmentTarget,
   ArrayExpression,
-  Elision,
-  ObjectExpression,
-  ObjectProperty,
-  TemplateLiteral,
-  TaggedTemplateExpression,
-  TemplateElement,
-  ComputedMemberExpression,
-  StaticMemberExpression,
-  PrivateFieldExpression,
-  CallExpression,
-  NewExpression,
-  MetaProperty,
-  SpreadElement,
-  UpdateExpression,
-  UnaryExpression,
-  BinaryExpression,
-  PrivateInExpression,
-  LogicalExpression,
-  ConditionalExpression,
+  ArrayPattern,
+  ArrowFunctionExpression,
   AssignmentExpression,
-  ArrayAssignmentTarget,
-  ObjectAssignmentTarget,
-  AssignmentTargetWithDefault,
+  AssignmentPattern,
   AssignmentTargetPropertyIdentifier,
   AssignmentTargetPropertyProperty,
-  SequenceExpression,
-  Super,
+  AssignmentTargetWithDefault,
   AwaitExpression,
-  ChainExpression,
-  ParenthesizedExpression,
-  Hashbang,
+  BigIntLiteral,
+  BinaryExpression,
+  BindingIdentifier,
+  BindingProperty,
   BlockStatement,
-  VariableDeclaration,
-  VariableDeclarator,
+  BooleanLiteral,
+  BreakStatement,
+  CallExpression,
+  CatchClause,
+  ChainExpression,
+  Class,
+  ClassBody,
+  ComputedMemberExpression,
+  ConditionalExpression,
+  ContinueStatement,
+  DebuggerStatement,
+  Decorator,
+  DoWhileStatement,
+  Elision,
   EmptyStatement,
+  ExportAllDeclaration,
+  ExportDefaultDeclaration,
+  ExportNamedDeclaration,
+  ExportSpecifier,
   ExpressionStatement,
-  IfStatement,
-  DoWhileStatement,
-  WhileStatement,
-  ForStatement,
   ForInStatement,
+  FormalParameters,
   ForOfStatement,
-  ContinueStatement,
-  BreakStatement,
-  ReturnStatement,
-  WithStatement,
-  SwitchStatement,
-  SwitchCase,
-  LabeledStatement,
-  ThrowStatement,
-  TryStatement,
-  CatchClause,
-  DebuggerStatement,
-  AssignmentPattern,
-  ObjectPattern,
-  BindingProperty,
-  ArrayPattern,
+  ForStatement,
   Function,
-  FormalParameters,
   FunctionBody,
-  ArrowFunctionExpression,
-  YieldExpression,
-  Class,
-  ClassBody,
-  MethodDefinition,
-  PropertyDefinition,
-  PrivateIdentifier,
-  StaticBlock,
-  AccessorProperty,
-  ImportExpression,
+  Hashbang,
+  IdentifierName,
+  IdentifierReference,
+  IfStatement,
+  ImportAttribute,
   ImportDeclaration,
-  ImportSpecifier,
   ImportDefaultSpecifier,
+  ImportExpression,
   ImportNamespaceSpecifier,
-  ImportAttribute,
-  ExportNamedDeclaration,
-  ExportDefaultDeclaration,
-  ExportAllDeclaration,
-  ExportSpecifier,
-  V8IntrinsicExpression,
-  BooleanLiteral,
-  NullLiteral,
-  NumericLiteral,
-  StringLiteral,
-  BigIntLiteral,
-  RegExpLiteral,
-  JSXElement,
-  JSXOpeningElement,
+  ImportSpecifier,
+  JSDocNonNullableType,
+  JSDocNullableType,
+  JSDocUnknownType,
+  JSXAttribute,
   JSXClosingElement,
-  JSXFragment,
-  JSXOpeningFragment,
   JSXClosingFragment,
-  JSXNamespacedName,
-  JSXMemberExpression,
-  JSXExpressionContainer,
+  JSXElement,
   JSXEmptyExpression,
-  JSXAttribute,
-  JSXSpreadAttribute,
+  JSXExpressionContainer,
+  JSXFragment,
   JSXIdentifier,
+  JSXMemberExpression,
+  JSXNamespacedName,
+  JSXOpeningElement,
+  JSXOpeningFragment,
+  JSXSpreadAttribute,
   JSXSpreadChild,
   JSXText,
-  TSEnumDeclaration,
+  LabeledStatement,
+  LabelIdentifier,
+  LogicalExpression,
+  MetaProperty,
+  MethodDefinition,
+  NewExpression,
+  NullLiteral,
+  NumericLiteral,
+  ObjectAssignmentTarget,
+  ObjectExpression,
+  ObjectPattern,
+  ObjectProperty,
+  ParenthesizedExpression,
+  PrivateFieldExpression,
+  PrivateIdentifier,
+  PrivateInExpression,
+  Program,
+  PropertyDefinition,
+  RegExpLiteral,
+  ReturnStatement,
+  SequenceExpression,
+  SpreadElement,
+  StaticBlock,
+  StaticMemberExpression,
+  StringLiteral,
+  Super,
+  SwitchCase,
+  SwitchStatement,
+  TaggedTemplateExpression,
+  TemplateElement,
+  TemplateLiteral,
+  ThisExpression,
+  ThrowStatement,
+  TryStatement,
+  TSAnyKeyword,
+  TSArrayType,
+  TSAsExpression,
+  TSBigIntKeyword,
+  TSBooleanKeyword,
+  TSCallSignatureDeclaration,
+  TSClassImplements,
+  TSConditionalType,
+  TSConstructorType,
+  TSConstructSignatureDeclaration,
   TSEnumBody,
+  TSEnumDeclaration,
   TSEnumMember,
-  TSTypeAnnotation,
-  TSLiteralType,
-  TSConditionalType,
-  TSUnionType,
-  TSIntersectionType,
-  TSParenthesizedType,
-  TSTypeOperator,
-  TSArrayType,
+  TSExportAssignment,
+  TSExternalModuleReference,
+  TSFunctionType,
+  TSImportEqualsDeclaration,
+  TSImportType,
+  TSImportTypeQualifiedName,
   TSIndexedAccessType,
-  TSTupleType,
+  TSIndexSignature,
+  TSIndexSignatureName,
+  TSInferType,
+  TSInstantiationExpression,
+  TSInterfaceBody,
+  TSInterfaceDeclaration,
+  TSInterfaceHeritage,
+  TSIntersectionType,
+  TSIntrinsicKeyword,
+  TSLiteralType,
+  TSMappedType,
+  TSMethodSignature,
+  TSModuleBlock,
+  TSModuleDeclaration,
   TSNamedTupleMember,
+  TSNamespaceExportDeclaration,
+  TSNeverKeyword,
+  TSNonNullExpression,
+  TSNullKeyword,
+  TSNumberKeyword,
+  TSObjectKeyword,
   TSOptionalType,
+  TSParenthesizedType,
+  TSPropertySignature,
+  TSQualifiedName,
   TSRestType,
-  TSAnyKeyword,
+  TSSatisfiesExpression,
   TSStringKeyword,
-  TSBooleanKeyword,
-  TSNumberKeyword,
-  TSNeverKeyword,
-  TSIntrinsicKeyword,
-  TSUnknownKeyword,
-  TSNullKeyword,
-  TSUndefinedKeyword,
-  TSVoidKeyword,
   TSSymbolKeyword,
+  TSTemplateLiteralType,
   TSThisType,
-  TSObjectKeyword,
-  TSBigIntKeyword,
-  TSTypeReference,
-  TSQualifiedName,
-  TSTypeParameterInstantiation,
+  TSTupleType,
+  TSTypeAliasDeclaration,
+  TSTypeAnnotation,
+  TSTypeAssertion,
+  TSTypeLiteral,
+  TSTypeOperator,
   TSTypeParameter,
   TSTypeParameterDeclaration,
-  TSTypeAliasDeclaration,
-  TSClassImplements,
-  TSInterfaceDeclaration,
-  TSInterfaceBody,
-  TSPropertySignature,
-  TSIndexSignature,
-  TSCallSignatureDeclaration,
-  TSMethodSignature,
-  TSConstructSignatureDeclaration,
-  TSIndexSignatureName,
-  TSInterfaceHeritage,
+  TSTypeParameterInstantiation,
   TSTypePredicate,
-  TSModuleDeclaration,
-  TSModuleBlock,
-  TSTypeLiteral,
-  TSInferType,
   TSTypeQuery,
-  TSImportType,
-  TSImportTypeQualifiedName,
-  TSFunctionType,
-  TSConstructorType,
-  TSMappedType,
-  TSTemplateLiteralType,
-  TSAsExpression,
-  TSSatisfiesExpression,
-  TSTypeAssertion,
-  TSImportEqualsDeclaration,
-  TSExternalModuleReference,
-  TSNonNullExpression,
-  Decorator,
-  TSExportAssignment,
-  TSNamespaceExportDeclaration,
-  TSInstantiationExpression,
-  JSDocNullableType,
-  JSDocNonNullableType,
-  JSDocUnknownType,
-} = require('./constructors.js');
+  TSTypeReference,
+  TSUndefinedKeyword,
+  TSUnionType,
+  TSUnknownKeyword,
+  TSVoidKeyword,
+  UnaryExpression,
+  UpdateExpression,
+  V8IntrinsicExpression,
+  VariableDeclaration,
+  VariableDeclarator,
+  WhileStatement,
+  WithStatement,
+  YieldExpression,
+} from './constructors.mjs';
 
-module.exports = walkProgram;
+export { walkProgram };
 
 function walkProgram(pos, ast, visitors) {
   const enterExit = visitors[38];

package/{index.js → index.mjs}

@@ -1,22 +1,18 @@
-'use strict';
+import { createRequire } from 'node:module';
+import { parseAsync as parseAsyncBinding, parseSync as parseSyncBinding } from './bindings.mjs';
+import { wrap } from './wrap.mjs';
 
-const bindings = require('./bindings.js');
-const { wrap } = require('./wrap.cjs');
-const rawTransferSupported = require('./raw-transfer/supported.js');
+export {
+  ExportExportNameKind,
+  ExportImportNameKind,
+  ExportLocalNameKind,
+  ImportNameKind,
+  ParseResult,
+  Severity,
+} from './bindings.mjs';
+export { rawTransferSupported } from './raw-transfer/supported.mjs';
 
-const { parseSync: parseSyncBinding, parseAsync: parseAsyncBinding } = bindings;
-
-module.exports.ParseResult = bindings.ParseResult;
-module.exports.ExportExportNameKind = bindings.ExportExportNameKind;
-module.exports.ExportImportNameKind = bindings.ExportImportNameKind;
-module.exports.ExportLocalNameKind = bindings.ExportLocalNameKind;
-module.exports.ImportNameKind = bindings.ImportNameKind;
-module.exports.Severity = bindings.Severity;
-
-module.exports.parseSync = parseSync;
-module.exports.parseAsync = parseAsync;
-module.exports.experimentalGetLazyVisitor = experimentalGetLazyVisitor;
-module.exports.rawTransferSupported = rawTransferSupported;
+const require = createRequire(import.meta.url);
 
 // Lazily loaded as needed
 let parseSyncRaw = null,
@@ -31,7 +27,7 @@ let parseSyncRaw = null,
  */
 function loadRawTransfer() {
   if (parseSyncRaw === null) {
-    ({ parseSyncRaw, parseAsyncRaw } = require('./raw-transfer/eager.js'));
+    ({ parseSyncRaw, parseAsyncRaw } = require('./raw-transfer/eager.mjs'));
   }
 }
 
@@ -41,7 +37,7 @@ function loadRawTransfer() {
  */
 function loadRawTransferLazy() {
   if (parseSyncLazy === null) {
-    ({ parseSyncLazy, parseAsyncLazy, Visitor } = require('./raw-transfer/lazy.js'));
+    ({ parseSyncLazy, parseAsyncLazy, Visitor } = require('./raw-transfer/lazy.mjs'));
   }
 }
 
@@ -55,7 +51,7 @@ function loadRawTransferLazy() {
  * @throws {Error} - If `experimentalRawTransfer` or `experimentalLazy` option is enabled,
  *   and raw transfer is not supported on this platform
  */
-function parseSync(filename, sourceText, options) {
+export function parseSync(filename, sourceText, options) {
   if (options?.experimentalRawTransfer) {
     loadRawTransfer();
     return parseSyncRaw(filename, sourceText, options);
@@ -87,7 +83,7 @@ function parseSync(filename, sourceText, options) {
  * @throws {Error} - If `experimentalRawTransfer` or `experimentalLazy` option is enabled,
  *   and raw transfer is not supported on this platform
  */
-async function parseAsync(filename, sourceText, options) {
+export async function parseAsync(filename, sourceText, options) {
   if (options?.experimentalRawTransfer) {
     loadRawTransfer();
     return await parseAsyncRaw(filename, sourceText, options);
@@ -103,7 +99,7 @@ async function parseAsync(filename, sourceText, options) {
  * Get `Visitor` class to construct visitors with.
  * @returns {function} - `Visitor` class
  */
-function experimentalGetLazyVisitor() {
+export function experimentalGetLazyVisitor() {
   loadRawTransferLazy();
   return Visitor;
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "oxc-parser",
-  "version": "0.87.0",
+  "version": "0.89.0",
   "type": "commonjs",
-  "main": "index.js",
+  "main": "index.mjs",
   "browser": "wasm.mjs",
   "engines": {
     "node": ">=20.0.0"
@@ -26,36 +26,35 @@
   },
   "files": [
     "index.d.ts",
-    "index.js",
-    "wrap.cjs",
+    "index.mjs",
     "wrap.mjs",
     "wasm.mjs",
-    "bindings.js",
+    "bindings.mjs",
     "webcontainer-fallback.js",
-    "generated/constants.js",
-    "generated/deserialize/js.js",
-    "generated/deserialize/ts.js",
-    "generated/lazy/constructors.js",
-    "generated/lazy/types.js",
-    "generated/lazy/walk.js",
-    "raw-transfer/common.js",
-    "raw-transfer/eager.js",
-    "raw-transfer/lazy.js",
-    "raw-transfer/lazy-common.js",
-    "raw-transfer/node-array.js",
-    "raw-transfer/supported.js",
-    "raw-transfer/visitor.js"
+    "generated/constants.mjs",
+    "generated/deserialize/js.mjs",
+    "generated/deserialize/ts.mjs",
+    "generated/lazy/constructors.mjs",
+    "generated/lazy/types.mjs",
+    "generated/lazy/walk.mjs",
+    "raw-transfer/common.mjs",
+    "raw-transfer/eager.mjs",
+    "raw-transfer/lazy.mjs",
+    "raw-transfer/lazy-common.mjs",
+    "raw-transfer/node-array.mjs",
+    "raw-transfer/supported.mjs",
+    "raw-transfer/visitor.mjs"
   ],
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "dependencies": {
-    "@oxc-project/types": "^0.87.0"
+    "@oxc-project/types": "^0.89.0"
   },
   "devDependencies": {
     "@codspeed/vitest-plugin": "^4.0.0",
-    "@napi-rs/wasm-runtime": "1.0.3",
+    "@napi-rs/wasm-runtime": "1.0.5",
     "@vitest/browser": "3.2.4",
     "esbuild": "^0.25.0",
     "playwright": "^1.51.0",
@@ -91,24 +90,24 @@
     "dtsHeaderFile": "header.js"
   },
   "optionalDependencies": {
-    "@oxc-parser/binding-win32-x64-msvc": "0.87.0",
-    "@oxc-parser/binding-win32-arm64-msvc": "0.87.0",
-    "@oxc-parser/binding-linux-x64-gnu": "0.87.0",
-    "@oxc-parser/binding-linux-x64-musl": "0.87.0",
-    "@oxc-parser/binding-freebsd-x64": "0.87.0",
-    "@oxc-parser/binding-linux-arm64-gnu": "0.87.0",
-    "@oxc-parser/binding-linux-arm64-musl": "0.87.0",
-    "@oxc-parser/binding-linux-arm-gnueabihf": "0.87.0",
-    "@oxc-parser/binding-linux-arm-musleabihf": "0.87.0",
-    "@oxc-parser/binding-linux-s390x-gnu": "0.87.0",
-    "@oxc-parser/binding-linux-riscv64-gnu": "0.87.0",
-    "@oxc-parser/binding-darwin-x64": "0.87.0",
-    "@oxc-parser/binding-darwin-arm64": "0.87.0",
-    "@oxc-parser/binding-android-arm64": "0.87.0",
-    "@oxc-parser/binding-wasm32-wasi": "0.87.0"
+    "@oxc-parser/binding-win32-x64-msvc": "0.89.0",
+    "@oxc-parser/binding-win32-arm64-msvc": "0.89.0",
+    "@oxc-parser/binding-linux-x64-gnu": "0.89.0",
+    "@oxc-parser/binding-linux-x64-musl": "0.89.0",
+    "@oxc-parser/binding-freebsd-x64": "0.89.0",
+    "@oxc-parser/binding-linux-arm64-gnu": "0.89.0",
+    "@oxc-parser/binding-linux-arm64-musl": "0.89.0",
+    "@oxc-parser/binding-linux-arm-gnueabihf": "0.89.0",
+    "@oxc-parser/binding-linux-arm-musleabihf": "0.89.0",
+    "@oxc-parser/binding-linux-s390x-gnu": "0.89.0",
+    "@oxc-parser/binding-linux-riscv64-gnu": "0.89.0",
+    "@oxc-parser/binding-darwin-x64": "0.89.0",
+    "@oxc-parser/binding-darwin-arm64": "0.89.0",
+    "@oxc-parser/binding-android-arm64": "0.89.0",
+    "@oxc-parser/binding-wasm32-wasi": "0.89.0"
   },
   "scripts": {
-    "build-dev": "napi build --platform --js bindings.js",
+    "build-dev": "napi build --esm --platform --js bindings.mjs",
     "build-test": "pnpm run build-dev --profile coverage",
     "build": "pnpm run build-dev --features allocator --release",
     "postbuild-dev": "node patch.mjs",

package/raw-transfer/{common.js → common.mjs}

@@ -1,21 +1,13 @@
-'use strict';
-
-const os = require('node:os');
-const rawTransferSupported = require('./supported.js');
-const {
-  parseSyncRaw: parseSyncRawBinding,
-  parseAsyncRaw: parseAsyncRawBinding,
+import os from 'node:os';
+import {
   getBufferOffset,
-} = require('../bindings.js');
-const { BUFFER_SIZE, BUFFER_ALIGN, IS_TS_FLAG_POS } = require('../generated/constants.js');
+  parseAsyncRaw as parseAsyncRawBinding,
+  parseSyncRaw as parseSyncRawBinding,
+} from '../bindings.mjs';
+import { BUFFER_ALIGN, BUFFER_SIZE, IS_TS_FLAG_POS } from '../generated/constants.mjs';
+import { rawTransferSupported } from './supported.mjs';
 
-module.exports = {
-  parseSyncRawImpl,
-  parseAsyncRawImpl,
-  prepareRaw,
-  isJsAst,
-  returnBufferToCache,
-};
+export { isJsAst, parseAsyncRawImpl, parseSyncRawImpl, prepareRaw, returnBufferToCache };
 
 // Throw an error if running on a platform which raw transfer doesn't support.
 //

package/raw-transfer/{eager.js → eager.mjs}

@@ -1,8 +1,7 @@
-'use strict';
+import { createRequire } from 'node:module';
+import { isJsAst, parseAsyncRawImpl, parseSyncRawImpl, returnBufferToCache } from './common.mjs';
 
-const { parseSyncRawImpl, parseAsyncRawImpl, isJsAst, returnBufferToCache } = require('./common.js');
-
-module.exports = { parseSyncRaw, parseAsyncRaw };
+const require = createRequire(import.meta.url);
 
 /**
  * Parse JS/TS source synchronously on current thread, using raw transfer to speed up deserialization.
@@ -12,7 +11,7 @@ module.exports = { parseSyncRaw, parseAsyncRaw };
  * @param {Object} options - Parsing options
  * @returns {Object} - Object with property getters for `program`, `module`, `comments`, and `errors`
  */
-function parseSyncRaw(filename, sourceText, options) {
+export function parseSyncRaw(filename, sourceText, options) {
   let _;
   ({ experimentalRawTransfer: _, ...options } = options);
   return parseSyncRawImpl(filename, sourceText, options, deserialize);
@@ -36,7 +35,7 @@ function parseSyncRaw(filename, sourceText, options) {
  * @param {Object} options - Parsing options
  * @returns {Object} - Object with property getters for `program`, `module`, `comments`, and `errors`
  */
-function parseAsyncRaw(filename, sourceText, options) {
+export function parseAsyncRaw(filename, sourceText, options) {
   let _;
   ({ experimentalRawTransfer: _, ...options } = options);
   return parseAsyncRawImpl(filename, sourceText, options, deserialize);
@@ -56,7 +55,7 @@ function deserialize(buffer, sourceText, sourceByteLen) {
   // Lazy load deserializer, and deserialize buffer to JS objects
   let data;
   if (isJsAst(buffer)) {
-    if (deserializeJS === null) deserializeJS = require('../generated/deserialize/js.js');
+    if (deserializeJS === null) deserializeJS = require('../generated/deserialize/js.mjs').deserialize;
     data = deserializeJS(buffer, sourceText, sourceByteLen);
 
     // Add a line comment for hashbang
@@ -65,7 +64,7 @@ function deserialize(buffer, sourceText, sourceByteLen) {
       data.comments.unshift({ type: 'Line', value: hashbang.value, start: hashbang.start, end: hashbang.end });
     }
   } else {
-    if (deserializeTS === null) deserializeTS = require('../generated/deserialize/ts.js');
+    if (deserializeTS === null) deserializeTS = require('../generated/deserialize/ts.mjs').deserialize;
     data = deserializeTS(buffer, sourceText, sourceByteLen);
     // Note: Do not add line comment for hashbang, to match `@typescript-eslint/parser`.
     // See https://github.com/oxc-project/oxc/blob/ea784f5f082e4c53c98afde9bf983afd0b95e44e/napi/parser/src/lib.rs#L106-L130

package/raw-transfer/{lazy-common.js → lazy-common.mjs}

@@ -1,15 +1,11 @@
-'use strict';
-
 // Unique token which is not exposed publicly.
 // Used to prevent user calling class constructors.
-const TOKEN = {};
+export const TOKEN = {};
 
 /**
  * Throw error when restricted class constructor is called by user code.
  * @throws {Error}
  */
-function constructorError() {
+export function constructorError() {
   throw new Error('Constructor is for internal use only');
 }
-
-module.exports = { TOKEN, constructorError };