@oxc-project/types 0.72.1 → 0.72.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxc-project/types",
-  "version": "0.72.1",
+  "version": "0.72.2",
   "description": "Types for Oxc AST nodes",
   "keywords": [
     "AST",

package/types.d.ts

@@ -53,32 +53,32 @@ export type Expression =
 
 export interface IdentifierName extends Span {
   type: 'Identifier';
-  name: string;
   decorators?: [];
+  name: string;
   optional?: false;
   typeAnnotation?: null;
 }
 
 export interface IdentifierReference extends Span {
   type: 'Identifier';
-  name: string;
   decorators?: [];
+  name: string;
   optional?: false;
   typeAnnotation?: null;
 }
 
 export interface BindingIdentifier extends Span {
   type: 'Identifier';
-  name: string;
   decorators?: [];
+  name: string;
   optional?: false;
   typeAnnotation?: null;
 }
 
 export interface LabelIdentifier extends Span {
   type: 'Identifier';
-  name: string;
   decorators?: [];
+  name: string;
   optional?: false;
   typeAnnotation?: null;
 }
@@ -103,12 +103,12 @@ export type ObjectPropertyKind = ObjectProperty | SpreadElement;
 
 export interface ObjectProperty extends Span {
   type: 'Property';
+  kind: PropertyKind;
+  key: PropertyKey;
+  value: Expression;
   method: boolean;
   shorthand: boolean;
   computed: boolean;
-  key: PropertyKey;
-  value: Expression;
-  kind: PropertyKind;
   optional?: false;
 }
 
@@ -118,15 +118,15 @@ export type PropertyKind = 'init' | 'get' | 'set';
 
 export interface TemplateLiteral extends Span {
   type: 'TemplateLiteral';
-  expressions: Array<Expression>;
   quasis: Array<TemplateElement>;
+  expressions: Array<Expression>;
 }
 
 export interface TaggedTemplateExpression extends Span {
   type: 'TaggedTemplateExpression';
   tag: Expression;
-  quasi: TemplateLiteral;
   typeArguments?: TSTypeParameterInstantiation | null;
+  quasi: TemplateLiteral;
 }
 
 export interface TemplateElement extends Span {
@@ -146,39 +146,39 @@ export interface ComputedMemberExpression extends Span {
   type: 'MemberExpression';
   object: Expression;
   property: Expression;
-  computed: true;
   optional: boolean;
+  computed: true;
 }
 
 export interface StaticMemberExpression extends Span {
   type: 'MemberExpression';
   object: Expression;
   property: IdentifierName;
-  computed: false;
   optional: boolean;
+  computed: false;
 }
 
 export interface PrivateFieldExpression extends Span {
   type: 'MemberExpression';
   object: Expression;
   property: PrivateIdentifier;
-  computed: false;
   optional: boolean;
+  computed: false;
 }
 
 export interface CallExpression extends Span {
   type: 'CallExpression';
   callee: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
   arguments: Array<Argument>;
   optional: boolean;
-  typeArguments?: TSTypeParameterInstantiation | null;
 }
 
 export interface NewExpression extends Span {
   type: 'NewExpression';
   callee: Expression;
-  arguments: Array<Argument>;
   typeArguments?: TSTypeParameterInstantiation | null;
+  arguments: Array<Argument>;
 }
 
 export interface MetaProperty extends Span {
@@ -204,8 +204,8 @@ export interface UpdateExpression extends Span {
 export interface UnaryExpression extends Span {
   type: 'UnaryExpression';
   operator: UnaryOperator;
-  prefix: true;
   argument: Expression;
+  prefix: true;
 }
 
 export interface BinaryExpression extends Span {
@@ -257,24 +257,24 @@ export type AssignmentTargetPattern = ArrayAssignmentTarget | ObjectAssignmentTa
 
 export interface ArrayAssignmentTarget extends Span {
   type: 'ArrayPattern';
-  elements: Array<AssignmentTargetMaybeDefault | AssignmentTargetRest | null>;
   decorators?: [];
+  elements: Array<AssignmentTargetMaybeDefault | AssignmentTargetRest | null>;
   optional?: false;
   typeAnnotation?: null;
 }
 
 export interface ObjectAssignmentTarget extends Span {
   type: 'ObjectPattern';
-  properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
   decorators?: [];
+  properties: Array<AssignmentTargetProperty | AssignmentTargetRest>;
   optional?: false;
   typeAnnotation?: null;
 }
 
 export interface AssignmentTargetRest extends Span {
   type: 'RestElement';
-  argument: AssignmentTarget;
   decorators?: [];
+  argument: AssignmentTarget;
   optional?: false;
   typeAnnotation?: null;
   value?: null;
@@ -284,9 +284,9 @@ export type AssignmentTargetMaybeDefault = AssignmentTargetWithDefault | Assignm
 
 export interface AssignmentTargetWithDefault extends Span {
   type: 'AssignmentPattern';
+  decorators?: [];
   left: AssignmentTarget;
   right: Expression;
-  decorators?: [];
   optional?: false;
   typeAnnotation?: null;
 }
@@ -295,23 +295,23 @@ export type AssignmentTargetProperty = AssignmentTargetPropertyIdentifier | Assi
 
 export interface AssignmentTargetPropertyIdentifier extends Span {
   type: 'Property';
+  kind: 'init';
+  key: IdentifierReference;
+  value: IdentifierReference | AssignmentTargetWithDefault;
   method: false;
   shorthand: true;
   computed: false;
-  key: IdentifierReference;
-  value: IdentifierReference | AssignmentTargetWithDefault;
-  kind: 'init';
   optional?: false;
 }
 
 export interface AssignmentTargetPropertyProperty extends Span {
   type: 'Property';
+  kind: 'init';
+  key: PropertyKey;
+  value: AssignmentTargetMaybeDefault;
   method: false;
   shorthand: false;
   computed: boolean;
-  key: PropertyKey;
-  value: AssignmentTargetMaybeDefault;
-  kind: 'init';
   optional?: false;
 }
 
@@ -391,8 +391,8 @@ export type Declaration =
 
 export interface VariableDeclaration extends Span {
   type: 'VariableDeclaration';
-  declarations: Array<VariableDeclarator>;
   kind: VariableDeclarationKind;
+  declarations: Array<VariableDeclarator>;
   declare?: boolean;
 }
 
@@ -490,14 +490,14 @@ export interface SwitchStatement extends Span {
 
 export interface SwitchCase extends Span {
   type: 'SwitchCase';
-  consequent: Array<Statement>;
   test: Expression | null;
+  consequent: Array<Statement>;
 }
 
 export interface LabeledStatement extends Span {
   type: 'LabeledStatement';
-  body: Statement;
   label: LabelIdentifier;
+  body: Statement;
 }
 
 export interface ThrowStatement extends Span {
@@ -533,44 +533,44 @@ export type BindingPatternKind = BindingIdentifier | ObjectPattern | ArrayPatter
 
 export interface AssignmentPattern extends Span {
   type: 'AssignmentPattern';
+  decorators?: [];
   left: BindingPattern;
   right: Expression;
-  decorators?: [];
   optional?: false;
   typeAnnotation?: null;
 }
 
 export interface ObjectPattern extends Span {
   type: 'ObjectPattern';
-  properties: Array<BindingProperty | BindingRestElement>;
   decorators?: [];
+  properties: Array<BindingProperty | BindingRestElement>;
   optional?: false;
   typeAnnotation?: null;
 }
 
 export interface BindingProperty extends Span {
   type: 'Property';
+  kind: 'init';
+  key: PropertyKey;
+  value: BindingPattern;
   method: false;
   shorthand: boolean;
   computed: boolean;
-  key: PropertyKey;
-  value: BindingPattern;
-  kind: 'init';
   optional?: false;
 }
 
 export interface ArrayPattern extends Span {
   type: 'ArrayPattern';
-  elements: Array<BindingPattern | BindingRestElement | null>;
   decorators?: [];
+  elements: Array<BindingPattern | BindingRestElement | null>;
   optional?: false;
   typeAnnotation?: null;
 }
 
 export interface BindingRestElement extends Span {
   type: 'RestElement';
-  argument: BindingPattern;
   decorators?: [];
+  argument: BindingPattern;
   optional?: false;
   typeAnnotation?: null;
   value?: null;
@@ -579,14 +579,14 @@ export interface BindingRestElement extends Span {
 export interface Function extends Span {
   type: FunctionType;
   id: BindingIdentifier | null;
-  expression: false;
   generator: boolean;
   async: boolean;
-  params: ParamPattern[];
-  body: FunctionBody | null;
   declare?: boolean;
   typeParameters?: TSTypeParameterDeclaration | null;
+  params: ParamPattern[];
   returnType?: TSTypeAnnotation | null;
+  body: FunctionBody | null;
+  expression: false;
 }
 
 export type ParamPattern = FormalParameter | TSParameterProperty | FormalParameterRest;
@@ -629,14 +629,14 @@ export interface FunctionBody extends Span {
 
 export interface ArrowFunctionExpression extends Span {
   type: 'ArrowFunctionExpression';
-  id: null;
   expression: boolean;
-  generator: false;
   async: boolean;
-  params: ParamPattern[];
-  body: FunctionBody | Expression;
   typeParameters?: TSTypeParameterDeclaration | null;
+  params: ParamPattern[];
   returnType?: TSTypeAnnotation | null;
+  body: FunctionBody | Expression;
+  id: null;
+  generator: false;
 }
 
 export interface YieldExpression extends Span {
@@ -647,13 +647,13 @@ export interface YieldExpression extends Span {
 
 export interface Class extends Span {
   type: ClassType;
+  decorators: Array<Decorator>;
   id: BindingIdentifier | null;
-  superClass: Expression | null;
-  body: ClassBody;
-  decorators?: Array<Decorator>;
   typeParameters?: TSTypeParameterDeclaration | null;
+  superClass: Expression | null;
   superTypeArguments?: TSTypeParameterInstantiation | null;
   implements?: Array<TSClassImplements>;
+  body: ClassBody;
   abstract?: boolean;
   declare?: boolean;
 }
@@ -669,12 +669,12 @@ export type ClassElement = StaticBlock | MethodDefinition | PropertyDefinition |
 
 export interface MethodDefinition extends Span {
   type: MethodDefinitionType;
-  static: boolean;
-  computed: boolean;
+  decorators: Array<Decorator>;
   key: PropertyKey;
-  kind: MethodDefinitionKind;
   value: Function;
-  decorators?: Array<Decorator>;
+  kind: MethodDefinitionKind;
+  computed: boolean;
+  static: boolean;
   override?: boolean;
   optional?: boolean;
   accessibility?: TSAccessibility | null;
@@ -684,17 +684,17 @@ export type MethodDefinitionType = 'MethodDefinition' | 'TSAbstractMethodDefinit
 
 export interface PropertyDefinition extends Span {
   type: PropertyDefinitionType;
-  static: boolean;
-  computed: boolean;
+  decorators: Array<Decorator>;
   key: PropertyKey;
+  typeAnnotation?: TSTypeAnnotation | null;
   value: Expression | null;
-  decorators?: Array<Decorator>;
+  computed: boolean;
+  static: boolean;
   declare?: boolean;
   override?: boolean;
   optional?: boolean;
   definite?: boolean;
   readonly?: boolean;
-  typeAnnotation?: TSTypeAnnotation | null;
   accessibility?: TSAccessibility | null;
 }
 
@@ -724,18 +724,18 @@ export type AccessorPropertyType = 'AccessorProperty' | 'TSAbstractAccessorPrope
 
 export interface AccessorProperty extends Span {
   type: AccessorPropertyType;
+  decorators: Array<Decorator>;
   key: PropertyKey;
   typeAnnotation?: TSTypeAnnotation | null;
   value: Expression | null;
   computed: boolean;
   static: boolean;
-  decorators?: Array<Decorator>;
+  override?: boolean;
   definite?: boolean;
   accessibility?: TSAccessibility | null;
+  declare?: false;
   optional?: false;
-  override?: boolean;
   readonly?: false;
-  declare?: false;
 }
 
 export interface ImportExpression extends Span {
@@ -749,8 +749,8 @@ export interface ImportDeclaration extends Span {
   type: 'ImportDeclaration';
   specifiers: Array<ImportDeclarationSpecifier>;
   source: StringLiteral;
-  attributes: Array<ImportAttribute>;
   phase: ImportPhase | null;
+  attributes: Array<ImportAttribute>;
   importKind?: ImportOrExportKind;
 }
 
@@ -788,8 +788,8 @@ export interface ExportNamedDeclaration extends Span {
   declaration: Declaration | null;
   specifiers: Array<ExportSpecifier>;
   source: StringLiteral | null;
-  attributes: Array<ImportAttribute>;
   exportKind?: ImportOrExportKind;
+  attributes: Array<ImportAttribute>;
 }
 
 export interface ExportDefaultDeclaration extends Span {
@@ -864,16 +864,16 @@ export interface RegExpLiteral extends Span {
 export interface JSXElement extends Span {
   type: 'JSXElement';
   openingElement: JSXOpeningElement;
-  closingElement: JSXClosingElement | null;
   children: Array<JSXChild>;
+  closingElement: JSXClosingElement | null;
 }
 
 export interface JSXOpeningElement extends Span {
   type: 'JSXOpeningElement';
-  attributes: Array<JSXAttributeItem>;
   name: JSXElementName;
-  selfClosing: boolean;
   typeArguments?: TSTypeParameterInstantiation | null;
+  attributes: Array<JSXAttributeItem>;
+  selfClosing: boolean;
 }
 
 export interface JSXClosingElement extends Span {
@@ -884,8 +884,8 @@ export interface JSXClosingElement extends Span {
 export interface JSXFragment extends Span {
   type: 'JSXFragment';
   openingFragment: JSXOpeningFragment;
-  closingFragment: JSXClosingFragment;
   children: Array<JSXChild>;
+  closingFragment: JSXClosingFragment;
 }
 
 export interface JSXOpeningFragment extends Span {
@@ -962,8 +962,8 @@ export interface JSXText extends Span {
 
 export interface TSThisParameter extends Span {
   type: 'Identifier';
-  name: 'this';
   decorators: [];
+  name: 'this';
   optional: false;
   typeAnnotation: TSTypeAnnotation | null;
 }
@@ -984,8 +984,8 @@ export interface TSEnumBody extends Span {
 export interface TSEnumMember extends Span {
   type: 'TSEnumMember';
   id: TSEnumMemberName;
-  computed: boolean;
   initializer: Expression | null;
+  computed: boolean;
 }
 
 export type TSEnumMemberName = IdentifierName | StringLiteral | TemplateLiteral;
@@ -1292,8 +1292,8 @@ export interface TSConstructSignatureDeclaration extends Span {
 
 export interface TSIndexSignatureName extends Span {
   type: 'Identifier';
-  name: string;
   decorators: [];
+  name: string;
   optional: false;
   typeAnnotation: TSTypeAnnotation;
 }
@@ -1372,12 +1372,12 @@ export interface TSConstructorType extends Span {
 
 export interface TSMappedType extends Span {
   type: 'TSMappedType';
+  key: TSTypeParameter['name'];
+  constraint: TSTypeParameter['constraint'];
   nameType: TSType | null;
   typeAnnotation: TSType | null;
   optional: TSMappedTypeModifierOperator | false;
   readonly: TSMappedTypeModifierOperator | null;
-  key: TSTypeParameter['name'];
-  constraint: TSTypeParameter['constraint'];
 }
 
 export type TSMappedTypeModifierOperator = true | '+' | '-';