@swc/core 1.2.212 → 1.2.213

package/CHANGELOG.md

@@ -5,6 +5,47 @@
 
 
 
+- **(css/codegen)** Fix sourcemap of multibyte characters (#5183) ([5b70233](https://github.com/swc-project/swc/commit/5b70233400a5b67cf51650bebbd59dcd0699ba78))
+
+
+- **(css/parser)** Avoid skipping whitespaces if not required (#5181) ([7b28521](https://github.com/swc-project/swc/commit/7b28521d72776a33f5d51c8ac9fdc674268fa418))
+
+
+- **(es/minifier)** Don't merge exported declarations (#5193) ([16ece4d](https://github.com/swc-project/swc/commit/16ece4dce0acdbb0e368b085dc1fcbeec3017789))
+
+
+- **(html/codegen)** Fix source map generation (#5184) ([60ca553](https://github.com/swc-project/swc/commit/60ca5538f9c658a5f9bb7b9dd83d1795ed18bde3))
+
+
+- **(node/types)** Fix AST type definitions (#5175) ([afd5171](https://github.com/swc-project/swc/commit/afd5171240835c6c2dbd5e06584409796ba08501))
+
+### Features
+
+
+
+- **(es/codegen)** Emit comments in `emit_module` (#5132) ([1ef541e](https://github.com/swc-project/swc/commit/1ef541eec4a98dc23bef706f881fac9dddd196ca))
+
+
+- **(html/minifier)** Allow specifying options for other tools (#5125) ([dada2d7](https://github.com/swc-project/swc/commit/dada2d7d554fa0733a3c65c512777f1548d41a35))
+
+
+- **(visit)** Improve API (#5185) ([4744d43](https://github.com/swc-project/swc/commit/4744d438a9cf44d59dc899ea054ae5e65f6490c8))
+
+
+- **(visit)** Implement serde for `AstParentKind` (#5191) ([d1418ee](https://github.com/swc-project/swc/commit/d1418ee977428597b3f9833b8cee6ca434186ae4))
+
+### Testing
+
+
+
+- **(node)** Refactor tests (#5187) ([a4b14c3](https://github.com/swc-project/swc/commit/a4b14c38065cba3a244118c3eaf74e8ebb0d938d))
+
+## [1.2.212] - 2022-07-11
+
+### Bug Fixes
+
+
+
 - **(es/modules)** Add the missing span for `export default` (#5170) ([997240c](https://github.com/swc-project/swc/commit/997240cfe68ff7787d73e93758f2d2304715e249))
 
 

package/Visitor.d.ts

@@ -1,4 +1,4 @@
-import { Accessibility, ArrayExpression, ArrayPattern, ArrowFunctionExpression, Argument, AssignmentExpression, AssignmentPattern, AssignmentPatternProperty, AssignmentProperty, AwaitExpression, BigIntLiteral, BinaryExpression, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CatchClause, Class, ClassDeclaration, ClassExpression, ClassMember, ClassMethod, ClassProperty, ComputedPropName, ConditionalExpression, Constructor, ContinueStatement, DebuggerStatement, Declaration, Decorator, DefaultDecl, DoWhileStatement, EmptyStatement, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultExpression, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, Expression, ExpressionStatement, Fn, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, GetterProperty, Identifier, IfStatement, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, JSXAttribute, JSXAttributeName, JSXAttributeOrSpread, JSXAttrValue, JSXClosingElement, JSXClosingFragment, JSXElement, JSXElementChild, JSXElementName, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXMemberExpression, JSXNamespacedName, JSXObject, JSXOpeningElement, JSXOpeningFragment, JSXSpreadChild, JSXText, KeyValuePatternProperty, KeyValueProperty, LabeledStatement, MemberExpression, MetaProperty, MethodProperty, Module, ModuleDeclaration, ModuleItem, NamedExportSpecifier, NamedImportSpecifier, NewExpression, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ObjectPatternProperty, OptionalChainingExpression, ParenthesisExpression, Pattern, PrivateMethod, PrivateName, PrivateProperty, Program, Property, PropertyName, RegExpLiteral, RestElement, ReturnStatement, Script, SequenceExpression, SetterProperty, SpreadElement, Statement, StringLiteral, Super, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, TsAsExpression, TsEntityName, TsEnumDeclaration, TsEnumMember, TsEnumMemberId, TsExportAssignment, TsExpressionWithTypeArguments, TsExternalModuleReference, TsFnParameter, TsImportEqualsDeclaration, TsIndexSignature, TsInterfaceBody, TsInterfaceDeclaration, TsModuleBlock, TsModuleDeclaration, TsModuleName, TsModuleReference, TsNamespaceBody, TsNamespaceDeclaration, TsNamespaceExportDeclaration, TsNonNullExpression, TsParameterProperty, TsParameterPropertyParameter, TsQualifiedName, TsType, TsTypeAliasDeclaration, TsTypeAnnotation, TsTypeAssertion, TsTypeElement, TsTypeParameter, TsTypeParameterDeclaration, TsTypeParameterInstantiation, UnaryExpression, UpdateExpression, VariableDeclaration, VariableDeclarator, WhileStatement, WithStatement, YieldExpression, Param, ExprOrSpread, TsConstAssertion, Import, SuperPropExpression } from "./types";
+import { Accessibility, ArrayExpression, ArrayPattern, ArrowFunctionExpression, Argument, AssignmentExpression, AssignmentPattern, AssignmentPatternProperty, AssignmentProperty, AwaitExpression, BigIntLiteral, BinaryExpression, BlockStatement, BooleanLiteral, BreakStatement, CallExpression, CatchClause, Class, ClassDeclaration, ClassExpression, ClassMember, ClassMethod, ClassProperty, ComputedPropName, ConditionalExpression, Constructor, ContinueStatement, DebuggerStatement, Declaration, Decorator, DefaultDecl, DoWhileStatement, EmptyStatement, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultExpression, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, Expression, ExpressionStatement, Fn, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, GetterProperty, Identifier, IfStatement, ImportDeclaration, ImportDefaultSpecifier, ImportNamespaceSpecifier, ImportSpecifier, JSXAttribute, JSXAttributeName, JSXAttributeOrSpread, JSXAttrValue, JSXClosingElement, JSXClosingFragment, JSXElement, JSXElementChild, JSXElementName, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXMemberExpression, JSXNamespacedName, JSXObject, JSXOpeningElement, JSXOpeningFragment, JSXSpreadChild, JSXText, KeyValuePatternProperty, KeyValueProperty, LabeledStatement, MemberExpression, MetaProperty, MethodProperty, Module, ModuleDeclaration, ModuleExportName, ModuleItem, NamedExportSpecifier, NamedImportSpecifier, NewExpression, NullLiteral, NumericLiteral, ObjectExpression, ObjectPattern, ObjectPatternProperty, OptionalChainingCall, OptionalChainingExpression, ParenthesisExpression, Pattern, PrivateMethod, PrivateName, PrivateProperty, Program, Property, PropertyName, RegExpLiteral, RestElement, ReturnStatement, Script, SequenceExpression, SetterProperty, SpreadElement, Statement, StaticBlock, StringLiteral, Super, SwitchCase, SwitchStatement, TaggedTemplateExpression, TemplateLiteral, ThisExpression, ThrowStatement, TryStatement, TsAsExpression, TsCallSignatureDeclaration, TsConstructSignatureDeclaration, TsEntityName, TsEnumDeclaration, TsEnumMember, TsEnumMemberId, TsExportAssignment, TsExpressionWithTypeArguments, TsExternalModuleReference, TsFnParameter, TsGetterSignature, TsImportEqualsDeclaration, TsIndexSignature, TsInstantiation, TsInterfaceBody, TsInterfaceDeclaration, TsMethodSignature, TsModuleBlock, TsModuleDeclaration, TsModuleName, TsModuleReference, TsNamespaceBody, TsNamespaceDeclaration, TsNamespaceExportDeclaration, TsNonNullExpression, TsParameterProperty, TsParameterPropertyParameter, TsPropertySignature, TsQualifiedName, TsSetterSignature, TsType, TsTypeAliasDeclaration, TsTypeAnnotation, TsTypeAssertion, TsTypeElement, TsTypeParameter, TsTypeParameterDeclaration, TsTypeParameterInstantiation, UnaryExpression, UpdateExpression, VariableDeclaration, VariableDeclarator, WhileStatement, WithStatement, YieldExpression, Param, ExprOrSpread, TsConstAssertion, Import, SuperPropExpression } from "./types";
 export declare class Visitor {
     visitProgram(n: Program): Program;
     visitModule(m: Module): Module;
@@ -17,6 +17,7 @@ export declare class Visitor {
     visitExportSpecifiers(nodes: ExportSpecifier[]): ExportSpecifier[];
     visitExportSpecifier(n: ExportSpecifier): ExportSpecifier;
     visitNamedExportSpecifier(n: NamedExportSpecifier): ExportSpecifier;
+    visitModuleExportName(n: ModuleExportName): ModuleExportName;
     visitExportNamespaceSpecifier(n: ExportNamespaceSpecifier): ExportSpecifier;
     visitExportDefaultSpecifier(n: ExportDefaultSpecifier): ExportSpecifier;
     visitOptionalStringLiteral(n: StringLiteral | undefined): StringLiteral | undefined;
@@ -28,6 +29,7 @@ export declare class Visitor {
     visitArrayExpression(e: ArrayExpression): Expression;
     visitArrayElement(e: ExprOrSpread | undefined): ExprOrSpread | undefined;
     visitExprOrSpread(e: ExprOrSpread): ExprOrSpread;
+    visitExprOrSpreads(nodes: ExprOrSpread[]): ExprOrSpread[];
     visitSpreadElement(e: SpreadElement): SpreadElement;
     visitOptionalExpression(e: Expression | undefined): Expression | undefined;
     visitArrowFunctionExpression(e: ArrowFunctionExpression): Expression;
@@ -50,7 +52,7 @@ export declare class Visitor {
     visitForStatement(stmt: ForStatement): Statement;
     visitForOfStatement(stmt: ForOfStatement): Statement;
     visitForInStatement(stmt: ForInStatement): Statement;
-    visitEmptyStatement(stmt: EmptyStatement): Statement;
+    visitEmptyStatement(stmt: EmptyStatement): EmptyStatement;
     visitDoWhileStatement(stmt: DoWhileStatement): Statement;
     visitDebuggerStatement(stmt: DebuggerStatement): Statement;
     visitWithStatement(stmt: WithStatement): Statement;
@@ -68,6 +70,12 @@ export declare class Visitor {
     visitTsInterfaceBody(n: TsInterfaceBody): TsInterfaceBody;
     visitTsTypeElements(nodes: TsTypeElement[]): TsTypeElement[];
     visitTsTypeElement(n: TsTypeElement): TsTypeElement;
+    visitTsCallSignatureDeclaration(n: TsCallSignatureDeclaration): TsCallSignatureDeclaration;
+    visitTsConstructSignatureDeclaration(n: TsConstructSignatureDeclaration): TsConstructSignatureDeclaration;
+    visitTsPropertySignature(n: TsPropertySignature): TsPropertySignature;
+    visitTsGetterSignature(n: TsGetterSignature): TsGetterSignature;
+    visitTsSetterSignature(n: TsSetterSignature): TsSetterSignature;
+    visitTsMethodSignature(n: TsMethodSignature): TsMethodSignature;
     visitTsEnumDeclaration(n: TsEnumDeclaration): Declaration;
     visitTsEnumMembers(nodes: TsEnumMember[]): TsEnumMember[];
     visitTsEnumMember(n: TsEnumMember): TsEnumMember;
@@ -76,7 +84,7 @@ export declare class Visitor {
     visitClassDeclaration(decl: ClassDeclaration): Declaration;
     visitClassBody(members: ClassMember[]): ClassMember[];
     visitClassMember(member: ClassMember): ClassMember;
-    visitTsIndexSignature(n: TsIndexSignature): ClassMember;
+    visitTsIndexSignature(n: TsIndexSignature): TsIndexSignature;
     visitTsFnParameters(params: TsFnParameter[]): TsFnParameter[];
     visitTsFnParameter(n: TsFnParameter): TsFnParameter;
     visitPrivateProperty(n: PrivateProperty): ClassMember;
@@ -85,6 +93,7 @@ export declare class Visitor {
     visitConstructor(n: Constructor): ClassMember;
     visitConstructorParameters(nodes: (Param | TsParameterProperty)[]): (Param | TsParameterProperty)[];
     visitConstructorParameter(n: Param | TsParameterProperty): Param | TsParameterProperty;
+    visitStaticBlock(n: StaticBlock): StaticBlock;
     visitTsParameterProperty(n: TsParameterProperty): TsParameterProperty | Param;
     visitTsParameterPropertyParameter(n: TsParameterPropertyParameter): TsParameterPropertyParameter;
     visitPropertyName(key: PropertyName): PropertyName;
@@ -106,6 +115,8 @@ export declare class Visitor {
     visitContinueStatement(stmt: ContinueStatement): Statement;
     visitExpression(n: Expression): Expression;
     visitOptionalChainingExpression(n: OptionalChainingExpression): Expression;
+    visitMemberExpressionOrOptionalChainingCall(n: MemberExpression | OptionalChainingCall): MemberExpression | OptionalChainingCall;
+    visitOptionalChainingCall(n: OptionalChainingCall): OptionalChainingCall;
     visitAssignmentExpression(n: AssignmentExpression): Expression;
     visitPatternOrExpression(n: Pattern | Expression): Pattern | Expression;
     visitYieldExpression(n: YieldExpression): Expression;
@@ -113,6 +124,7 @@ export declare class Visitor {
     visitUnaryExpression(n: UnaryExpression): Expression;
     visitTsTypeAssertion(n: TsTypeAssertion): Expression;
     visitTsConstAssertion(n: TsConstAssertion): Expression;
+    visitTsInstantiation(n: TsInstantiation): TsInstantiation;
     visitTsNonNullExpression(n: TsNonNullExpression): Expression;
     visitTsAsExpression(n: TsAsExpression): Expression;
     visitThisExpression(n: ThisExpression): Expression;
@@ -138,7 +150,7 @@ export declare class Visitor {
     visitArguments(nodes: Argument[]): Argument[];
     visitArgument(n: Argument): Argument;
     visitMetaProperty(n: MetaProperty): Expression;
-    visitMemberExpression(n: MemberExpression): Expression;
+    visitMemberExpression(n: MemberExpression): MemberExpression;
     visitSuperPropExpression(n: SuperPropExpression): Expression;
     visitCallee(n: Expression | Super | Import): Expression | Super | Import;
     visitJSXText(n: JSXText): JSXText;
@@ -159,6 +171,7 @@ export declare class Visitor {
     visitJSXOpeningElement(n: JSXOpeningElement): JSXOpeningElement;
     visitJSXAttributes(attrs: JSXAttributeOrSpread[] | undefined): JSXAttributeOrSpread[] | undefined;
     visitJSXAttributeOrSpread(n: JSXAttributeOrSpread): JSXAttributeOrSpread;
+    visitJSXAttributeOrSpreads(nodes: JSXAttributeOrSpread[]): JSXAttributeOrSpread[];
     visitJSXAttribute(n: JSXAttribute): JSXAttributeOrSpread;
     visitJSXAttributeValue(n: JSXAttrValue | undefined): JSXAttrValue | undefined;
     visitJSXAttributeName(n: JSXAttributeName): JSXAttributeName;

package/Visitor.js

@@ -83,7 +83,7 @@ class Visitor {
         }
     }
     visitTsExternalModuleReference(n) {
-        n.expression = this.visitExpression(n.expression);
+        n.expression = this.visitStringLiteral(n.expression);
         return n;
     }
     visitExportAllDeclaration(n) {
@@ -114,13 +114,21 @@ class Visitor {
     }
     visitNamedExportSpecifier(n) {
         if (n.exported) {
-            n.exported = this.visitBindingIdentifier(n.exported);
+            n.exported = this.visitModuleExportName(n.exported);
         }
-        n.orig = this.visitIdentifierReference(n.orig);
+        n.orig = this.visitModuleExportName(n.orig);
         return n;
     }
+    visitModuleExportName(n) {
+        switch (n.type) {
+            case "Identifier":
+                return this.visitIdentifier(n);
+            case "StringLiteral":
+                return this.visitStringLiteral(n);
+        }
+    }
     visitExportNamespaceSpecifier(n) {
-        n.name = this.visitBindingIdentifier(n.name);
+        n.name = this.visitModuleExportName(n.name);
         return n;
     }
     visitExportDefaultSpecifier(n) {
@@ -178,6 +186,9 @@ class Visitor {
     visitExprOrSpread(e) {
         return Object.assign(Object.assign({}, e), { expression: this.visitExpression(e.expression) });
     }
+    visitExprOrSpreads(nodes) {
+        return nodes.map(this.visitExprOrSpread.bind(this));
+    }
     visitSpreadElement(e) {
         e.arguments = this.visitExpression(e.arguments);
         return e;
@@ -466,10 +477,51 @@ class Visitor {
         return nodes.map(this.visitTsTypeElement.bind(this));
     }
     visitTsTypeElement(n) {
+        switch (n.type) {
+            case "TsCallSignatureDeclaration":
+                return this.visitTsCallSignatureDeclaration(n);
+            case "TsConstructSignatureDeclaration":
+                return this.visitTsConstructSignatureDeclaration(n);
+            case "TsPropertySignature":
+                return this.visitTsPropertySignature(n);
+            case "TsGetterSignature":
+                return this.visitTsGetterSignature(n);
+            case "TsSetterSignature":
+                return this.visitTsSetterSignature(n);
+            case "TsMethodSignature":
+                return this.visitTsMethodSignature(n);
+            case "TsIndexSignature":
+                return this.visitTsIndexSignature(n);
+        }
+    }
+    visitTsCallSignatureDeclaration(n) {
+        n.params = this.visitTsFnParameters(n.params);
+        n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
+        return n;
+    }
+    visitTsConstructSignatureDeclaration(n) {
+        n.params = this.visitTsFnParameters(n.params);
+        n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
+        return n;
+    }
+    visitTsPropertySignature(n) {
         n.params = this.visitTsFnParameters(n.params);
         n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
         return n;
     }
+    visitTsGetterSignature(n) {
+        n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
+        return n;
+    }
+    visitTsSetterSignature(n) {
+        n.param = this.visitTsFnParameter(n.param);
+        return n;
+    }
+    visitTsMethodSignature(n) {
+        n.params = this.visitTsFnParameters(n.params);
+        n.typeAnn = this.visitTsTypeAnnotation(n.typeAnn);
+        return n;
+    }
     visitTsEnumDeclaration(n) {
         n.id = this.visitIdentifier(n.id);
         n.members = this.visitTsEnumMembers(n.members);
@@ -518,11 +570,16 @@ class Visitor {
                 return this.visitPrivateProperty(member);
             case "TsIndexSignature":
                 return this.visitTsIndexSignature(member);
+            case "EmptyStatement":
+                return this.visitEmptyStatement(member);
+            case "StaticBlock":
+                return this.visitStaticBlock(member);
         }
     }
     visitTsIndexSignature(n) {
         n.params = this.visitTsFnParameters(n.params);
-        n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
+        if (n.typeAnnotation)
+            n.typeAnnotation = this.visitTsTypeAnnotation(n.typeAnnotation);
         return n;
     }
     visitTsFnParameters(params) {
@@ -568,6 +625,10 @@ class Visitor {
                 return this.visitParameter(n);
         }
     }
+    visitStaticBlock(n) {
+        n.body = this.visitBlockStatement(n.body);
+        return n;
+    }
     visitTsParameterProperty(n) {
         n.accessibility = this.visitAccessibility(n.accessibility);
         n.decorators = this.visitDecorators(n.decorators);
@@ -637,7 +698,7 @@ class Visitor {
         return nodes.map(this.visitTsExpressionWithTypeArguments.bind(this));
     }
     visitTsExpressionWithTypeArguments(n) {
-        n.expression = this.visitTsEntityName(n.expression);
+        n.expression = this.visitExpression(n.expression);
         n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
         return n;
     }
@@ -692,6 +753,8 @@ class Visitor {
                 return this.visitAssignmentExpression(n);
             case "AwaitExpression":
                 return this.visitAwaitExpression(n);
+            case "BigIntLiteral":
+                return this.visitBigIntLiteral(n);
             case "BinaryExpression":
                 return this.visitBinaryExpression(n);
             case "BooleanLiteral":
@@ -756,6 +819,8 @@ class Visitor {
                 return this.visitTsTypeAssertion(n);
             case "TsConstAssertion":
                 return this.visitTsConstAssertion(n);
+            case "TsInstantiation":
+                return this.visitTsInstantiation(n);
             case "UnaryExpression":
                 return this.visitUnaryExpression(n);
             case "UpdateExpression":
@@ -769,7 +834,22 @@ class Visitor {
         }
     }
     visitOptionalChainingExpression(n) {
-        n.base = this.visitExpression(n.base);
+        n.base = this.visitMemberExpressionOrOptionalChainingCall(n.base);
+        return n;
+    }
+    visitMemberExpressionOrOptionalChainingCall(n) {
+        switch (n.type) {
+            case "MemberExpression":
+                return this.visitMemberExpression(n);
+            case "CallExpression":
+                return this.visitOptionalChainingCall(n);
+        }
+    }
+    visitOptionalChainingCall(n) {
+        n.callee = this.visitExpression(n.callee);
+        n.arguments = this.visitExprOrSpreads(n.arguments);
+        if (n.typeArguments)
+            n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
         return n;
     }
     visitAssignmentExpression(n) {
@@ -810,6 +890,10 @@ class Visitor {
         n.expression = this.visitExpression(n.expression);
         return n;
     }
+    visitTsInstantiation(n) {
+        n.expression = this.visitExpression(n.expression);
+        return n;
+    }
     visitTsNonNullExpression(n) {
         n.expression = this.visitExpression(n.expression);
         return n;
@@ -1072,7 +1156,7 @@ class Visitor {
     visitJSXOpeningElement(n) {
         n.name = this.visitJSXElementName(n.name);
         n.typeArguments = this.visitTsTypeParameterInstantiation(n.typeArguments);
-        n.attributes = this.visitJSXAttributes(n.attributes);
+        n.attributes = this.visitJSXAttributeOrSpreads(n.attributes);
         return n;
     }
     visitJSXAttributes(attrs) {
@@ -1087,6 +1171,9 @@ class Visitor {
                 return this.visitSpreadElement(n);
         }
     }
+    visitJSXAttributeOrSpreads(nodes) {
+        return nodes.map(this.visitJSXAttributeOrSpread.bind(this));
+    }
     visitJSXAttribute(n) {
         n.name = this.visitJSXAttributeName(n.name);
         n.value = this.visitJSXAttributeValue(n.value);
@@ -1201,7 +1288,7 @@ class Visitor {
     visitNamedImportSpecifier(node) {
         node.local = this.visitBindingIdentifier(node.local);
         if (node.imported) {
-            node.imported = this.visitIdentifierReference(node.imported);
+            node.imported = this.visitModuleExportName(node.imported);
         }
         return node;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swc/core",
-  "version": "1.2.212",
+  "version": "1.2.213",
   "description": "Super-fast alternative for babel",
   "homepage": "https://swc.rs",
   "main": "./index.js",
@@ -135,18 +135,18 @@
     "url": "https://opencollective.com/swc"
   },
   "optionalDependencies": {
-    "@swc/core-win32-x64-msvc": "1.2.212",
-    "@swc/core-darwin-x64": "1.2.212",
-    "@swc/core-linux-x64-gnu": "1.2.212",
-    "@swc/core-linux-x64-musl": "1.2.212",
-    "@swc/core-freebsd-x64": "1.2.212",
-    "@swc/core-win32-ia32-msvc": "1.2.212",
-    "@swc/core-linux-arm64-gnu": "1.2.212",
-    "@swc/core-linux-arm-gnueabihf": "1.2.212",
-    "@swc/core-darwin-arm64": "1.2.212",
-    "@swc/core-android-arm64": "1.2.212",
-    "@swc/core-linux-arm64-musl": "1.2.212",
-    "@swc/core-win32-arm64-msvc": "1.2.212",
-    "@swc/core-android-arm-eabi": "1.2.212"
+    "@swc/core-win32-x64-msvc": "1.2.213",
+    "@swc/core-darwin-x64": "1.2.213",
+    "@swc/core-linux-x64-gnu": "1.2.213",
+    "@swc/core-linux-x64-musl": "1.2.213",
+    "@swc/core-freebsd-x64": "1.2.213",
+    "@swc/core-win32-ia32-msvc": "1.2.213",
+    "@swc/core-linux-arm64-gnu": "1.2.213",
+    "@swc/core-linux-arm-gnueabihf": "1.2.213",
+    "@swc/core-darwin-arm64": "1.2.213",
+    "@swc/core-android-arm64": "1.2.213",
+    "@swc/core-linux-arm64-musl": "1.2.213",
+    "@swc/core-win32-arm64-msvc": "1.2.213",
+    "@swc/core-android-arm-eabi": "1.2.213"
   }
 }

package/types.d.ts

@@ -874,29 +874,31 @@ export interface HasDecorator {
 export interface Class extends HasSpan, HasDecorator {
     body: ClassMember[];
     superClass?: Expression;
-    is_abstract: boolean;
-    typeParams: TsTypeParameterDeclaration;
+    isAbstract: boolean;
+    typeParams?: TsTypeParameterDeclaration;
     superTypeParams?: TsTypeParameterInstantiation;
     implements: TsExpressionWithTypeArguments[];
 }
-export declare type ClassMember = Constructor | ClassMethod | PrivateMethod | ClassProperty | PrivateProperty | TsIndexSignature;
+export declare type ClassMember = Constructor | ClassMethod | PrivateMethod | ClassProperty | PrivateProperty | TsIndexSignature | EmptyStatement | StaticBlock;
 export interface ClassPropertyBase extends Node, HasSpan, HasDecorator {
     value?: Expression;
     typeAnnotation?: TsTypeAnnotation;
-    is_static: boolean;
+    isStatic: boolean;
     accessibility?: Accessibility;
-    is_optional: boolean;
+    isOptional: boolean;
+    isOverride: boolean;
     readonly: boolean;
+    definite: boolean;
 }
 export interface ClassProperty extends ClassPropertyBase {
     type: "ClassProperty";
     key: PropertyName;
+    isAbstract: boolean;
+    declare: boolean;
 }
 export interface PrivateProperty extends ClassPropertyBase {
     type: "PrivateProperty";
     key: PrivateName;
-    is_abstract: boolean;
-    definite: boolean;
 }
 export interface Param extends Node, HasSpan, HasDecorator {
     type: "Parameter";
@@ -905,18 +907,19 @@ export interface Param extends Node, HasSpan, HasDecorator {
 export interface Constructor extends Node, HasSpan {
     type: "Constructor";
     key: PropertyName;
-    params: (Param | TsParameterProperty)[];
-    body: BlockStatement;
+    params: (TsParameterProperty | Param)[];
+    body?: BlockStatement;
     accessibility?: Accessibility;
-    is_optional: boolean;
+    isOptional: boolean;
 }
 export interface ClassMethodBase extends Node, HasSpan {
     function: Fn;
     kind: MethodKind;
-    is_static: boolean;
+    isStatic: boolean;
     accessibility?: Accessibility;
-    is_abstract: boolean;
-    is_optional: boolean;
+    isAbstract: boolean;
+    isOptional: boolean;
+    isOverride: boolean;
 }
 export interface ClassMethod extends ClassMethodBase {
     type: "ClassMethod";
@@ -926,11 +929,15 @@ export interface PrivateMethod extends ClassMethodBase {
     type: "PrivateMethod";
     key: PrivateName;
 }
+export interface StaticBlock extends Node, HasSpan {
+    type: "StaticBlock";
+    body: BlockStatement;
+}
 export interface Decorator extends Node, HasSpan {
     type: "Decorator";
     expression: Expression;
 }
-export declare type MethodKind = "method" | "setter" | "getter";
+export declare type MethodKind = "method" | "getter" | "setter";
 export declare type Declaration = ClassDeclaration | FunctionDeclaration | VariableDeclaration | TsInterfaceDeclaration | TsTypeAliasDeclaration | TsEnumDeclaration | TsModuleDeclaration;
 export interface FunctionDeclaration extends Fn {
     type: "FunctionDeclaration";
@@ -955,15 +962,27 @@ export interface VariableDeclarator extends Node, HasSpan {
     init?: Expression;
     definite: boolean;
 }
-export declare type Expression = ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression | UnaryExpression | UpdateExpression | BinaryExpression | AssignmentExpression | MemberExpression | SuperPropExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | Identifier | Literal | TemplateLiteral | TaggedTemplateExpression | ArrowFunctionExpression | ClassExpression | YieldExpression | MetaProperty | AwaitExpression | ParenthesisExpression | JSXMemberExpression | JSXNamespacedName | JSXEmptyExpression | JSXElement | JSXFragment | TsTypeAssertion | TsConstAssertion | TsNonNullExpression | TsAsExpression | PrivateName | OptionalChainingExpression | Invalid;
+export declare type Expression = ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression | UnaryExpression | UpdateExpression | BinaryExpression | AssignmentExpression | MemberExpression | SuperPropExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | Identifier | Literal | TemplateLiteral | TaggedTemplateExpression | ArrowFunctionExpression | ClassExpression | YieldExpression | MetaProperty | AwaitExpression | ParenthesisExpression | JSXMemberExpression | JSXNamespacedName | JSXEmptyExpression | JSXElement | JSXFragment | TsTypeAssertion | TsConstAssertion | TsNonNullExpression | TsAsExpression | TsInstantiation | PrivateName | OptionalChainingExpression | Invalid;
 interface ExpressionBase extends Node, HasSpan {
 }
+export interface Identifier extends ExpressionBase {
+    type: "Identifier";
+    value: string;
+    optional: boolean;
+}
 export interface OptionalChainingExpression extends ExpressionBase {
     type: "OptionalChainingExpression";
+    questionDotToken: Span;
     /**
      * Call expression or member expression.
      */
-    base: Expression;
+    base: MemberExpression | OptionalChainingCall;
+}
+export interface OptionalChainingCall extends ExpressionBase {
+    type: "CallExpression";
+    callee: Expression;
+    arguments: ExprOrSpread[];
+    typeArguments?: TsTypeParameterInstantiation;
 }
 export interface ThisExpression extends ExpressionBase {
     type: "ThisExpression";
@@ -978,13 +997,12 @@ export interface ExprOrSpread {
 }
 export interface ObjectExpression extends ExpressionBase {
     type: "ObjectExpression";
-    properties: (Property | SpreadElement)[];
+    properties: (SpreadElement | Property)[];
 }
 export interface Argument {
     spread?: Span;
     expression: Expression;
 }
-export declare type PropertOrSpread = Property | SpreadElement;
 export interface SpreadElement extends Node {
     type: "SpreadElement";
     spread: Span;
@@ -1009,16 +1027,16 @@ export interface BinaryExpression extends ExpressionBase {
 }
 export interface FunctionExpression extends Fn, ExpressionBase {
     type: "FunctionExpression";
-    identifier: Identifier;
+    identifier?: Identifier;
 }
 export interface ClassExpression extends Class, ExpressionBase {
     type: "ClassExpression";
-    identifier: Identifier;
+    identifier?: Identifier;
 }
 export interface AssignmentExpression extends ExpressionBase {
     type: "AssignmentExpression";
     operator: AssignmentOperator;
-    left: Pattern | Expression;
+    left: Expression | Pattern;
     right: Expression;
 }
 export interface MemberExpression extends ExpressionBase {
@@ -1028,7 +1046,7 @@ export interface MemberExpression extends ExpressionBase {
 }
 export interface SuperPropExpression extends ExpressionBase {
     type: "SuperPropExpression";
-    object: Super;
+    obj: Super;
     property: Identifier | ComputedPropName;
 }
 export interface ConditionalExpression extends ExpressionBase {
@@ -1045,14 +1063,14 @@ export interface Import extends Node, HasSpan {
 }
 export interface CallExpression extends ExpressionBase {
     type: "CallExpression";
-    callee: Expression | Super | Import;
+    callee: Super | Import | Expression;
     arguments: Argument[];
     typeArguments?: TsTypeParameterInstantiation;
 }
 export interface NewExpression extends ExpressionBase {
     type: "NewExpression";
     callee: Expression;
-    arguments: Argument[];
+    arguments?: Argument[];
     typeArguments?: TsTypeParameterInstantiation;
 }
 export interface SequenceExpression extends ExpressionBase {
@@ -1073,9 +1091,9 @@ export interface YieldExpression extends ExpressionBase {
     argument?: Expression;
     delegate: boolean;
 }
-export interface MetaProperty extends Node {
+export interface MetaProperty extends Node, HasSpan {
     type: "MetaProperty";
-    kind: 'ImportMeta' | 'NewTarget';
+    kind: "new.target" | "import.meta";
 }
 export interface AwaitExpression extends ExpressionBase {
     type: "AwaitExpression";
@@ -1089,14 +1107,14 @@ export interface TemplateLiteral extends ExpressionBase {
 export interface TaggedTemplateExpression extends ExpressionBase {
     type: "TaggedTemplateExpression";
     tag: Expression;
+    typeParameters?: TsTypeParameterInstantiation;
     template: TemplateLiteral;
-    typeParameters: TsTypeParameterInstantiation;
 }
 export interface TemplateElement extends ExpressionBase {
     type: "TemplateElement";
     tail: boolean;
-    cooked: StringLiteral;
-    raw: StringLiteral;
+    cooked?: string;
+    raw: string;
 }
 export interface ParenthesisExpression extends ExpressionBase {
     type: "ParenthesisExpression";
@@ -1104,20 +1122,15 @@ export interface ParenthesisExpression extends ExpressionBase {
 }
 export interface Fn extends HasSpan, HasDecorator {
     params: Param[];
-    body: BlockStatement;
+    body?: BlockStatement;
     generator: boolean;
     async: boolean;
     typeParameters?: TsTypeParameterDeclaration;
     returnType?: TsTypeAnnotation;
 }
-interface PatternBase {
+interface PatternBase extends Node, HasSpan {
     typeAnnotation?: TsTypeAnnotation;
 }
-export interface Identifier extends HasSpan, PatternBase {
-    type: "Identifier";
-    value: string;
-    optional: boolean;
-}
 export interface PrivateName extends ExpressionBase {
     type: "PrivateName";
     id: Identifier;
@@ -1139,12 +1152,12 @@ export interface JSXNamespacedName extends Node {
 export interface JSXEmptyExpression extends Node, HasSpan {
     type: "JSXEmptyExpression";
 }
-export interface JSXExpressionContainer extends Node {
+export interface JSXExpressionContainer extends Node, HasSpan {
     type: "JSXExpressionContainer";
     expression: JSXExpression;
 }
 export declare type JSXExpression = JSXEmptyExpression | Expression;
-export interface JSXSpreadChild extends Node {
+export interface JSXSpreadChild extends Node, HasSpan {
     type: "JSXSpreadChild";
     expression: Expression;
 }
@@ -1152,7 +1165,7 @@ export declare type JSXElementName = Identifier | JSXMemberExpression | JSXNames
 export interface JSXOpeningElement extends Node, HasSpan {
     type: "JSXOpeningElement";
     name: JSXElementName;
-    attributes?: JSXAttributeOrSpread[];
+    attributes: JSXAttributeOrSpread[];
     selfClosing: boolean;
     typeArguments?: TsTypeParameterInstantiation;
 }
@@ -1192,11 +1205,11 @@ export interface JSXOpeningFragment extends Node, HasSpan {
 export interface JSXClosingFragment extends Node, HasSpan {
     type: "JSXClosingFragment";
 }
-export declare type Literal = StringLiteral | BooleanLiteral | NullLiteral | NumericLiteral | RegExpLiteral | JSXText;
+export declare type Literal = StringLiteral | BooleanLiteral | NullLiteral | NumericLiteral | BigIntLiteral | RegExpLiteral | JSXText;
 export interface StringLiteral extends Node, HasSpan {
     type: "StringLiteral";
     value: string;
-    hasEscape: boolean;
+    raw?: string;
 }
 export interface BooleanLiteral extends Node, HasSpan {
     type: "BooleanLiteral";
@@ -1213,10 +1226,12 @@ export interface RegExpLiteral extends Node, HasSpan {
 export interface NumericLiteral extends Node, HasSpan {
     type: "NumericLiteral";
     value: number;
+    raw?: string;
 }
 export interface BigIntLiteral extends Node, HasSpan {
     type: "BigIntLiteral";
     value: bigint;
+    raw?: string;
 }
 export declare type ModuleDeclaration = ImportDeclaration | ExportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportDefaultExpression | ExportAllDeclaration | TsImportEqualsDeclaration | TsExportAssignment | TsNamespaceExportDeclaration;
 export interface ExportDefaultExpression extends Node, HasSpan {
@@ -1229,13 +1244,15 @@ export interface ExportDeclaration extends Node, HasSpan {
 }
 export interface ImportDeclaration extends Node, HasSpan {
     type: "ImportDeclaration";
-    typeOnly?: boolean;
     specifiers: ImportSpecifier[];
     source: StringLiteral;
+    typeOnly: boolean;
+    asserts?: ObjectExpression;
 }
 export interface ExportAllDeclaration extends Node, HasSpan {
     type: "ExportAllDeclaration";
     source: StringLiteral;
+    asserts?: ObjectExpression;
 }
 /**
  * - `export { foo } from 'mod'`
@@ -1246,6 +1263,7 @@ export interface ExportNamedDeclaration extends Node, HasSpan {
     specifiers: ExportSpecifier[];
     source?: StringLiteral;
     typeOnly: boolean;
+    asserts?: ObjectExpression;
 }
 export interface ExportDefaultDeclaration extends Node, HasSpan {
     type: "ExportDefaultDeclaration";
@@ -1279,16 +1297,17 @@ export interface ImportNamespaceSpecifier extends Node, HasSpan {
 export interface NamedImportSpecifier extends Node, HasSpan {
     type: "ImportSpecifier";
     local: Identifier;
-    imported: Identifier | null;
-    isTypeOnly?: boolean;
+    imported?: ModuleExportName;
+    isTypeOnly: boolean;
 }
+export declare type ModuleExportName = Identifier | StringLiteral;
 export declare type ExportSpecifier = ExportNamespaceSpecifier | ExportDefaultSpecifier | NamedExportSpecifier;
 /**
  * `export * as foo from 'src';`
  */
 export interface ExportNamespaceSpecifier extends Node, HasSpan {
     type: "ExportNamespaceSpecifier";
-    name: Identifier;
+    name: ModuleExportName;
 }
 export interface ExportDefaultSpecifier extends Node, HasSpan {
     type: "ExportDefaultSpecifier";
@@ -1296,12 +1315,12 @@ export interface ExportDefaultSpecifier extends Node, HasSpan {
 }
 export interface NamedExportSpecifier extends Node, HasSpan {
     type: "ExportSpecifier";
-    orig: Identifier;
+    orig: ModuleExportName;
     /**
      * `Some(bar)` in `export { foo as bar }`
      */
-    exported: Identifier | null;
-    isTypeOnly?: boolean;
+    exported?: ModuleExportName;
+    isTypeOnly: boolean;
 }
 interface HasInterpreter {
     /**
@@ -1319,25 +1338,32 @@ export interface Script extends Node, HasSpan, HasInterpreter {
     body: Statement[];
 }
 export declare type ModuleItem = ModuleDeclaration | Statement;
-export declare type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "||" | "&&" | "in" | "instanceof" | "??";
-export declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=";
+export declare type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "||" | "&&" | "in" | "instanceof" | "**" | "??";
+export declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "&&=" | "||=" | "??=";
 export declare type UpdateOperator = "++" | "--";
 export declare type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-export declare type Pattern = Identifier | ArrayPattern | RestElement | ObjectPattern | AssignmentPattern | Invalid | Expression;
-export interface ArrayPattern extends Node, HasSpan, PatternBase {
+export declare type Pattern = BindingIdentifier | ArrayPattern | RestElement | ObjectPattern | AssignmentPattern | Invalid | Expression;
+export interface BindingIdentifier extends PatternBase {
+    type: "Identifier";
+    value: string;
+    optional: boolean;
+}
+export interface ArrayPattern extends PatternBase {
     type: "ArrayPattern";
     elements: (Pattern | undefined)[];
+    optional: boolean;
 }
-export interface ObjectPattern extends Node, HasSpan, PatternBase {
+export interface ObjectPattern extends PatternBase {
     type: "ObjectPattern";
     properties: ObjectPatternProperty[];
+    optional: boolean;
 }
-export interface AssignmentPattern extends Node, HasSpan, PatternBase {
+export interface AssignmentPattern extends PatternBase {
     type: "AssignmentPattern";
     left: Pattern;
     right: Expression;
 }
-export interface RestElement extends Node, HasSpan, PatternBase {
+export interface RestElement extends PatternBase {
     type: "RestElement";
     rest: Span;
     argument: Pattern;
@@ -1376,17 +1402,17 @@ export interface AssignmentProperty extends Node {
 export interface GetterProperty extends PropBase, HasSpan {
     type: "GetterProperty";
     typeAnnotation?: TsTypeAnnotation;
-    body: BlockStatement;
+    body?: BlockStatement;
 }
 export interface SetterProperty extends PropBase, HasSpan {
     type: "SetterProperty";
     param: Pattern;
-    body: BlockStatement;
+    body?: BlockStatement;
 }
 export interface MethodProperty extends PropBase, Fn {
     type: "MethodProperty";
 }
-export declare type PropertyName = Identifier | StringLiteral | NumericLiteral | BigIntLiteral | ComputedPropName;
+export declare type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropName | BigIntLiteral;
 export interface ComputedPropName extends Node, HasSpan {
     type: "Computed";
     expression: Expression;
@@ -1399,7 +1425,7 @@ export interface ExpressionStatement extends Node, HasSpan {
     type: "ExpressionStatement";
     expression: Expression;
 }
-export declare type Statement = ExpressionStatement | BlockStatement | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+export declare type Statement = BlockStatement | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration | ExpressionStatement;
 export interface EmptyStatement extends Node, HasSpan {
     type: "EmptyStatement";
 }
@@ -1413,7 +1439,7 @@ export interface WithStatement extends Node, HasSpan {
 }
 export interface ReturnStatement extends Node, HasSpan {
     type: "ReturnStatement";
-    argument: Expression;
+    argument?: Expression;
 }
 export interface LabeledStatement extends Node, HasSpan {
     type: "LabeledStatement";
@@ -1422,11 +1448,11 @@ export interface LabeledStatement extends Node, HasSpan {
 }
 export interface BreakStatement extends Node, HasSpan {
     type: "BreakStatement";
-    label: Identifier;
+    label?: Identifier;
 }
 export interface ContinueStatement extends Node, HasSpan {
     type: "ContinueStatement";
-    label: Identifier;
+    label?: Identifier;
 }
 export interface IfStatement extends Node, HasSpan {
     type: "IfStatement";
@@ -1447,7 +1473,7 @@ export interface TryStatement extends Node, HasSpan {
     type: "TryStatement";
     block: BlockStatement;
     handler?: CatchClause;
-    finalizer: BlockStatement;
+    finalizer?: BlockStatement;
 }
 export interface WhileStatement extends Node, HasSpan {
     type: "WhileStatement";
@@ -1479,7 +1505,7 @@ export interface ForOfStatement extends Node, HasSpan {
      *
      *  es2018 for-await-of statements, e.g., `for await (const x of xs) {`
      */
-    await: Span;
+    await?: Span;
     left: VariableDeclaration | Pattern;
     right: Expression;
     body: Statement;
@@ -1497,7 +1523,7 @@ export interface CatchClause extends Node, HasSpan {
     /**
      * The param is `undefined` if the catch binding is omitted. E.g., `try { foo() } catch {}`
      */
-    param: Pattern;
+    param?: Pattern;
     body: BlockStatement;
 }
 export interface TsTypeAnnotation extends Node, HasSpan {
@@ -1511,8 +1537,10 @@ export interface TsTypeParameterDeclaration extends Node, HasSpan {
 export interface TsTypeParameter extends Node, HasSpan {
     type: "TsTypeParameter";
     name: Identifier;
-    constraint: TsType;
-    default: TsType;
+    in: boolean;
+    out: boolean;
+    constraint?: TsType;
+    default?: TsType;
 }
 export interface TsTypeParameterInstantiation extends Node, HasSpan {
     type: "TsTypeParameterInstantiation";
@@ -1521,28 +1549,29 @@ export interface TsTypeParameterInstantiation extends Node, HasSpan {
 export interface TsParameterProperty extends Node, HasSpan, HasDecorator {
     type: "TsParameterProperty";
     accessibility?: Accessibility;
+    override: boolean;
     readonly: boolean;
     param: TsParameterPropertyParameter;
 }
-export declare type TsParameterPropertyParameter = Identifier | AssignmentPattern;
+export declare type TsParameterPropertyParameter = BindingIdentifier | AssignmentPattern;
 export interface TsQualifiedName extends Node {
     type: "TsQualifiedName";
     left: TsEntityName;
     right: Identifier;
 }
 export declare type TsEntityName = TsQualifiedName | Identifier;
-export declare type TsTypeElement = TsCallSignatureDeclaration | TsConstructSignatureDeclaration | TsPropertySignature | TsMethodSignature | TsIndexSignature;
+export declare type TsTypeElement = TsCallSignatureDeclaration | TsConstructSignatureDeclaration | TsPropertySignature | TsGetterSignature | TsSetterSignature | TsMethodSignature | TsIndexSignature;
 export interface TsCallSignatureDeclaration extends Node, HasSpan {
     type: "TsCallSignatureDeclaration";
     params: TsFnParameter[];
-    typeAnnotation: TsTypeAnnotation;
-    typeParams: TsTypeParameterDeclaration;
+    typeAnnotation?: TsTypeAnnotation;
+    typeParams?: TsTypeParameterDeclaration;
 }
 export interface TsConstructSignatureDeclaration extends Node, HasSpan {
     type: "TsConstructSignatureDeclaration";
     params: TsFnParameter[];
-    typeAnnotation: TsTypeAnnotation;
-    typeParams: TsTypeParameterDeclaration;
+    typeAnnotation?: TsTypeAnnotation;
+    typeParams?: TsTypeParameterDeclaration;
 }
 export interface TsPropertySignature extends Node, HasSpan {
     type: "TsPropertySignature";
@@ -1550,10 +1579,26 @@ export interface TsPropertySignature extends Node, HasSpan {
     key: Expression;
     computed: boolean;
     optional: boolean;
-    init: Expression;
+    init?: Expression;
     params: TsFnParameter[];
     typeAnnotation?: TsTypeAnnotation;
-    typeParams: TsTypeParameterDeclaration;
+    typeParams?: TsTypeParameterDeclaration;
+}
+export interface TsGetterSignature extends Node, HasSpan {
+    type: "TsGetterSignature";
+    readonly: boolean;
+    key: Expression;
+    computed: boolean;
+    optional: boolean;
+    typeAnnotation?: TsTypeAnnotation;
+}
+export interface TsSetterSignature extends Node, HasSpan {
+    type: "TsSetterSignature";
+    readonly: boolean;
+    key: Expression;
+    computed: boolean;
+    optional: boolean;
+    param: TsFnParameter;
 }
 export interface TsMethodSignature extends Node, HasSpan {
     type: "TsMethodSignature";
@@ -1562,50 +1607,54 @@ export interface TsMethodSignature extends Node, HasSpan {
     computed: boolean;
     optional: boolean;
     params: TsFnParameter[];
-    typeAnnotation: TsTypeAnnotation;
-    typeParams: TsTypeParameterDeclaration;
+    typeAnn?: TsTypeAnnotation;
+    typeParams?: TsTypeParameterDeclaration;
 }
 export interface TsIndexSignature extends Node, HasSpan {
     type: "TsIndexSignature";
-    readonly: boolean;
     params: TsFnParameter[];
     typeAnnotation?: TsTypeAnnotation;
+    readonly: boolean;
+    static: boolean;
 }
-export declare type TsType = TsKeywordType | TsThisType | TsFnOrConstructorType | TsTypeReference | TsTypeQuery | TsTypeLiteral | TsArrayType | TsTupleType | TsOptionalType | TsRestType | TsUnionOrIntersectionType | TsConditionalType | TsInferType | TsParenthesizedType | TsTypeOperator | TsIndexedAccessType | TsMappedType | TsLiteralType | TsImportType | TsTypePredicate;
+export declare type TsType = TsKeywordType | TsThisType | TsFnOrConstructorType | TsTypeReference | TsTypeQuery | TsTypeLiteral | TsArrayType | TsTupleType | TsOptionalType | TsRestType | TsUnionOrIntersectionType | TsConditionalType | TsInferType | TsParenthesizedType | TsTypeOperator | TsIndexedAccessType | TsMappedType | TsLiteralType | TsTypePredicate | TsImportType;
 export declare type TsFnOrConstructorType = TsFunctionType | TsConstructorType;
 export interface TsKeywordType extends Node, HasSpan {
     type: "TsKeywordType";
     kind: TsKeywordTypeKind;
 }
-export declare type TsKeywordTypeKind = "any" | "unknown" | "number" | "object" | "boolean" | "bigint" | "string" | "symbol" | "void" | "undefined" | "null" | "never";
+export declare type TsKeywordTypeKind = "any" | "unknown" | "number" | "object" | "boolean" | "bigint" | "string" | "symbol" | "void" | "undefined" | "null" | "never" | "intrinsic";
 export interface TsThisType extends Node, HasSpan {
     type: "TsThisType";
 }
-export declare type TsFnParameter = Identifier | RestElement | ObjectPattern;
+export declare type TsFnParameter = BindingIdentifier | ArrayPattern | RestElement | ObjectPattern;
 export interface TsFunctionType extends Node, HasSpan {
     type: "TsFunctionType";
-    typeParams: TsTypeParameterDeclaration;
+    params: TsFnParameter[];
+    typeParams?: TsTypeParameterDeclaration;
     typeAnnotation: TsTypeAnnotation;
 }
 export interface TsConstructorType extends Node, HasSpan {
     type: "TsConstructorType";
     params: TsFnParameter[];
-    typeParams: TsTypeParameterDeclaration;
+    typeParams?: TsTypeParameterDeclaration;
     typeAnnotation: TsTypeAnnotation;
+    isAbstract: boolean;
 }
 export interface TsTypeReference extends Node, HasSpan {
     type: "TsTypeReference";
     typeName: TsEntityName;
-    typeParams: TsTypeParameterInstantiation;
+    typeParams?: TsTypeParameterInstantiation;
 }
 export interface TsTypePredicate extends Node, HasSpan {
     type: "TsTypePredicate";
     asserts: boolean;
     paramName: TsThisTypeOrIdent;
-    typeAnnotation: TsTypeAnnotation;
+    typeAnnotation?: TsTypeAnnotation;
 }
 export declare type TsThisTypeOrIdent = TsThisType | Identifier;
 export interface TsImportType extends Node, HasSpan {
+    type: "TsImportType";
     argument: StringLiteral;
     qualifier?: TsEntityName;
     typeArguments?: TsTypeParameterInstantiation;
@@ -1616,6 +1665,7 @@ export interface TsImportType extends Node, HasSpan {
 export interface TsTypeQuery extends Node, HasSpan {
     type: "TsTypeQuery";
     exprName: TsTypeQueryExpr;
+    typeArguments?: TsTypeParameterInstantiation;
 }
 export declare type TsTypeQueryExpr = TsEntityName | TsImportType;
 export interface TsTypeLiteral extends Node, HasSpan {
@@ -1628,7 +1678,12 @@ export interface TsArrayType extends Node, HasSpan {
 }
 export interface TsTupleType extends Node, HasSpan {
     type: "TsTupleType";
-    elemTypes: TsType[];
+    elemTypes: TsTupleElement[];
+}
+export interface TsTupleElement extends Node, HasSpan {
+    type: "TsTupleElement";
+    label?: Pattern;
+    ty: TsType;
 }
 export interface TsOptionalType extends Node, HasSpan {
     type: "TsOptionalType";
@@ -1667,25 +1722,32 @@ export interface TsTypeOperator extends Node, HasSpan {
     op: TsTypeOperatorOp;
     typeAnnotation: TsType;
 }
-export declare type TsTypeOperatorOp = "keyof" | "unique";
+export declare type TsTypeOperatorOp = "keyof" | "unique" | "readonly";
 export interface TsIndexedAccessType extends Node, HasSpan {
     type: "TsIndexedAccessType";
+    readonly: boolean;
     objectType: TsType;
     indexType: TsType;
 }
 export declare type TruePlusMinus = true | "+" | "-";
 export interface TsMappedType extends Node, HasSpan {
     type: "TsMappedType";
-    readonly: TruePlusMinus;
+    readonly?: TruePlusMinus;
     typeParam: TsTypeParameter;
-    optional: TruePlusMinus;
-    typeAnnotation: TsType;
+    nameType?: TsType;
+    optional?: TruePlusMinus;
+    typeAnnotation?: TsType;
 }
 export interface TsLiteralType extends Node, HasSpan {
     type: "TsLiteralType";
     literal: TsLiteral;
 }
-export declare type TsLiteral = NumericLiteral | StringLiteral | BooleanLiteral | TemplateLiteral;
+export declare type TsLiteral = NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TsTemplateLiteralType;
+export interface TsTemplateLiteralType extends Node, HasSpan {
+    type: "TemplateLiteral";
+    types: TsType[];
+    quasis: TemplateElement[];
+}
 export interface TsInterfaceDeclaration extends Node, HasSpan {
     type: "TsInterfaceDeclaration";
     id: Identifier;
@@ -1700,7 +1762,7 @@ export interface TsInterfaceBody extends Node, HasSpan {
 }
 export interface TsExpressionWithTypeArguments extends Node, HasSpan {
     type: "TsExpressionWithTypeArguments";
-    expression: TsEntityName;
+    expression: Expression;
     typeArguments?: TsTypeParameterInstantiation;
 }
 export interface TsTypeAliasDeclaration extends Node, HasSpan {
@@ -1713,7 +1775,7 @@ export interface TsTypeAliasDeclaration extends Node, HasSpan {
 export interface TsEnumDeclaration extends Node, HasSpan {
     type: "TsEnumDeclaration";
     declare: boolean;
-    is_const: boolean;
+    isConst: boolean;
     id: Identifier;
     members: TsEnumMember[];
 }
@@ -1749,14 +1811,15 @@ export declare type TsModuleName = Identifier | StringLiteral;
 export interface TsImportEqualsDeclaration extends Node, HasSpan {
     type: "TsImportEqualsDeclaration";
     declare: boolean;
-    is_export: boolean;
+    isExport: boolean;
+    isTypeOnly: boolean;
     id: Identifier;
     moduleRef: TsModuleReference;
 }
 export declare type TsModuleReference = TsEntityName | TsExternalModuleReference;
 export interface TsExternalModuleReference extends Node, HasSpan {
     type: "TsExternalModuleReference";
-    expression: Expression;
+    expression: StringLiteral;
 }
 export interface TsExportAssignment extends Node, HasSpan {
     type: "TsExportAssignment";
@@ -1771,6 +1834,11 @@ export interface TsAsExpression extends ExpressionBase {
     expression: Expression;
     typeAnnotation: TsType;
 }
+export interface TsInstantiation extends Node, HasSpan {
+    type: "TsInstantiation";
+    expression: Expression;
+    typeArguments: TsTypeParameterInstantiation;
+}
 export interface TsTypeAssertion extends ExpressionBase {
     type: "TsTypeAssertion";
     expression: Expression;