diff --git a/Cargo.lock b/Cargo.lock
index 74b20a859b933..334df3c005503 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1356,8 +1356,10 @@ dependencies = [
 name = "oxc_ast_macros"
 version = "0.23.0"
 dependencies = [
+ "lazy_static",
  "proc-macro2",
  "quote",
+ "rustc-hash",
  "syn",
 ]
 
diff --git a/crates/oxc_ast/src/generated/assert_layouts.rs b/crates/oxc_ast/src/generated/assert_layouts.rs
index 93ad4d00329e1..3c07087d74e3a 100644
--- a/crates/oxc_ast/src/generated/assert_layouts.rs
+++ b/crates/oxc_ast/src/generated/assert_layouts.rs
@@ -14,20 +14,20 @@ const _: () = {
     assert!(std::mem::offset_of!(NullLiteral, span) == 0usize);
     assert!(size_of::<NumericLiteral>() == 40usize);
     assert!(align_of::<NumericLiteral>() == 8usize);
-    assert!(std::mem::offset_of!(NumericLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(NumericLiteral, value) == 8usize);
-    assert!(std::mem::offset_of!(NumericLiteral, raw) == 16usize);
+    assert!(std::mem::offset_of!(NumericLiteral, span) == 16usize);
+    assert!(std::mem::offset_of!(NumericLiteral, value) == 24usize);
+    assert!(std::mem::offset_of!(NumericLiteral, raw) == 0usize);
     assert!(std::mem::offset_of!(NumericLiteral, base) == 32usize);
     assert!(size_of::<BigIntLiteral>() == 32usize);
     assert!(align_of::<BigIntLiteral>() == 8usize);
-    assert!(std::mem::offset_of!(BigIntLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(BigIntLiteral, raw) == 8usize);
+    assert!(std::mem::offset_of!(BigIntLiteral, span) == 16usize);
+    assert!(std::mem::offset_of!(BigIntLiteral, raw) == 0usize);
     assert!(std::mem::offset_of!(BigIntLiteral, base) == 24usize);
     assert!(size_of::<RegExpLiteral>() == 32usize);
     assert!(align_of::<RegExpLiteral>() == 8usize);
-    assert!(std::mem::offset_of!(RegExpLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(RegExpLiteral, value) == 8usize);
-    assert!(std::mem::offset_of!(RegExpLiteral, regex) == 8usize);
+    assert!(std::mem::offset_of!(RegExpLiteral, span) == 24usize);
+    assert!(std::mem::offset_of!(RegExpLiteral, value) == 32usize);
+    assert!(std::mem::offset_of!(RegExpLiteral, regex) == 0usize);
     assert!(size_of::<RegExp>() == 24usize);
     assert!(align_of::<RegExp>() == 8usize);
     assert!(std::mem::offset_of!(RegExp, pattern) == 0usize);
@@ -36,45 +36,45 @@ const _: () = {
     assert!(align_of::<EmptyObject>() == 1usize);
     assert!(size_of::<StringLiteral>() == 24usize);
     assert!(align_of::<StringLiteral>() == 8usize);
-    assert!(std::mem::offset_of!(StringLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(StringLiteral, value) == 8usize);
-    assert!(size_of::<Program>() == 112usize);
+    assert!(std::mem::offset_of!(StringLiteral, span) == 16usize);
+    assert!(std::mem::offset_of!(StringLiteral, value) == 0usize);
+    assert!(size_of::<Program>() == 104usize);
     assert!(align_of::<Program>() == 8usize);
-    assert!(std::mem::offset_of!(Program, span) == 0usize);
-    assert!(std::mem::offset_of!(Program, source_type) == 8usize);
-    assert!(std::mem::offset_of!(Program, hashbang) == 16usize);
-    assert!(std::mem::offset_of!(Program, directives) == 40usize);
-    assert!(std::mem::offset_of!(Program, body) == 72usize);
-    assert!(std::mem::offset_of!(Program, scope_id) == 104usize);
+    assert!(std::mem::offset_of!(Program, span) == 88usize);
+    assert!(std::mem::offset_of!(Program, source_type) == 96usize);
+    assert!(std::mem::offset_of!(Program, hashbang) == 64usize);
+    assert!(std::mem::offset_of!(Program, directives) == 0usize);
+    assert!(std::mem::offset_of!(Program, body) == 32usize);
+    assert!(std::mem::offset_of!(Program, scope_id) == 100usize);
     assert!(size_of::<Expression>() == 16usize);
     assert!(align_of::<Expression>() == 8usize);
     assert!(size_of::<IdentifierName>() == 24usize);
     assert!(align_of::<IdentifierName>() == 8usize);
-    assert!(std::mem::offset_of!(IdentifierName, span) == 0usize);
-    assert!(std::mem::offset_of!(IdentifierName, name) == 8usize);
+    assert!(std::mem::offset_of!(IdentifierName, span) == 16usize);
+    assert!(std::mem::offset_of!(IdentifierName, name) == 0usize);
     assert!(size_of::<IdentifierReference>() == 32usize);
     assert!(align_of::<IdentifierReference>() == 8usize);
-    assert!(std::mem::offset_of!(IdentifierReference, span) == 0usize);
-    assert!(std::mem::offset_of!(IdentifierReference, name) == 8usize);
+    assert!(std::mem::offset_of!(IdentifierReference, span) == 16usize);
+    assert!(std::mem::offset_of!(IdentifierReference, name) == 0usize);
     assert!(std::mem::offset_of!(IdentifierReference, reference_id) == 24usize);
     assert!(std::mem::offset_of!(IdentifierReference, reference_flag) == 28usize);
     assert!(size_of::<BindingIdentifier>() == 32usize);
     assert!(align_of::<BindingIdentifier>() == 8usize);
-    assert!(std::mem::offset_of!(BindingIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(BindingIdentifier, name) == 8usize);
+    assert!(std::mem::offset_of!(BindingIdentifier, span) == 16usize);
+    assert!(std::mem::offset_of!(BindingIdentifier, name) == 0usize);
     assert!(std::mem::offset_of!(BindingIdentifier, symbol_id) == 24usize);
     assert!(size_of::<LabelIdentifier>() == 24usize);
     assert!(align_of::<LabelIdentifier>() == 8usize);
-    assert!(std::mem::offset_of!(LabelIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(LabelIdentifier, name) == 8usize);
+    assert!(std::mem::offset_of!(LabelIdentifier, span) == 16usize);
+    assert!(std::mem::offset_of!(LabelIdentifier, name) == 0usize);
     assert!(size_of::<ThisExpression>() == 8usize);
     assert!(align_of::<ThisExpression>() == 4usize);
     assert!(std::mem::offset_of!(ThisExpression, span) == 0usize);
     assert!(size_of::<ArrayExpression>() == 56usize);
     assert!(align_of::<ArrayExpression>() == 8usize);
-    assert!(std::mem::offset_of!(ArrayExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ArrayExpression, elements) == 8usize);
-    assert!(std::mem::offset_of!(ArrayExpression, trailing_comma) == 40usize);
+    assert!(std::mem::offset_of!(ArrayExpression, span) == 44usize);
+    assert!(std::mem::offset_of!(ArrayExpression, elements) == 0usize);
+    assert!(std::mem::offset_of!(ArrayExpression, trailing_comma) == 32usize);
     assert!(size_of::<ArrayExpressionElement>() == 16usize);
     assert!(align_of::<ArrayExpressionElement>() == 8usize);
     assert!(size_of::<Elision>() == 8usize);
@@ -82,41 +82,41 @@ const _: () = {
     assert!(std::mem::offset_of!(Elision, span) == 0usize);
     assert!(size_of::<ObjectExpression>() == 56usize);
     assert!(align_of::<ObjectExpression>() == 8usize);
-    assert!(std::mem::offset_of!(ObjectExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ObjectExpression, properties) == 8usize);
-    assert!(std::mem::offset_of!(ObjectExpression, trailing_comma) == 40usize);
+    assert!(std::mem::offset_of!(ObjectExpression, span) == 44usize);
+    assert!(std::mem::offset_of!(ObjectExpression, properties) == 0usize);
+    assert!(std::mem::offset_of!(ObjectExpression, trailing_comma) == 32usize);
     assert!(size_of::<ObjectPropertyKind>() == 16usize);
     assert!(align_of::<ObjectPropertyKind>() == 8usize);
-    assert!(size_of::<ObjectProperty>() == 72usize);
+    assert!(size_of::<ObjectProperty>() == 64usize);
     assert!(align_of::<ObjectProperty>() == 8usize);
-    assert!(std::mem::offset_of!(ObjectProperty, span) == 0usize);
-    assert!(std::mem::offset_of!(ObjectProperty, kind) == 8usize);
-    assert!(std::mem::offset_of!(ObjectProperty, key) == 16usize);
-    assert!(std::mem::offset_of!(ObjectProperty, value) == 32usize);
-    assert!(std::mem::offset_of!(ObjectProperty, init) == 48usize);
-    assert!(std::mem::offset_of!(ObjectProperty, method) == 64usize);
-    assert!(std::mem::offset_of!(ObjectProperty, shorthand) == 65usize);
-    assert!(std::mem::offset_of!(ObjectProperty, computed) == 66usize);
+    assert!(std::mem::offset_of!(ObjectProperty, span) == 48usize);
+    assert!(std::mem::offset_of!(ObjectProperty, kind) == 56usize);
+    assert!(std::mem::offset_of!(ObjectProperty, key) == 0usize);
+    assert!(std::mem::offset_of!(ObjectProperty, value) == 16usize);
+    assert!(std::mem::offset_of!(ObjectProperty, init) == 32usize);
+    assert!(std::mem::offset_of!(ObjectProperty, method) == 57usize);
+    assert!(std::mem::offset_of!(ObjectProperty, shorthand) == 58usize);
+    assert!(std::mem::offset_of!(ObjectProperty, computed) == 59usize);
     assert!(size_of::<PropertyKey>() == 16usize);
     assert!(align_of::<PropertyKey>() == 8usize);
     assert!(size_of::<PropertyKind>() == 1usize);
     assert!(align_of::<PropertyKind>() == 1usize);
     assert!(size_of::<TemplateLiteral>() == 72usize);
     assert!(align_of::<TemplateLiteral>() == 8usize);
-    assert!(std::mem::offset_of!(TemplateLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(TemplateLiteral, quasis) == 8usize);
-    assert!(std::mem::offset_of!(TemplateLiteral, expressions) == 40usize);
+    assert!(std::mem::offset_of!(TemplateLiteral, span) == 64usize);
+    assert!(std::mem::offset_of!(TemplateLiteral, quasis) == 0usize);
+    assert!(std::mem::offset_of!(TemplateLiteral, expressions) == 32usize);
     assert!(size_of::<TaggedTemplateExpression>() == 104usize);
     assert!(align_of::<TaggedTemplateExpression>() == 8usize);
-    assert!(std::mem::offset_of!(TaggedTemplateExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TaggedTemplateExpression, tag) == 8usize);
-    assert!(std::mem::offset_of!(TaggedTemplateExpression, quasi) == 24usize);
+    assert!(std::mem::offset_of!(TaggedTemplateExpression, span) == 88usize);
+    assert!(std::mem::offset_of!(TaggedTemplateExpression, tag) == 72usize);
+    assert!(std::mem::offset_of!(TaggedTemplateExpression, quasi) == 0usize);
     assert!(std::mem::offset_of!(TaggedTemplateExpression, type_parameters) == 96usize);
     assert!(size_of::<TemplateElement>() == 48usize);
     assert!(align_of::<TemplateElement>() == 8usize);
-    assert!(std::mem::offset_of!(TemplateElement, span) == 0usize);
-    assert!(std::mem::offset_of!(TemplateElement, tail) == 8usize);
-    assert!(std::mem::offset_of!(TemplateElement, value) == 16usize);
+    assert!(std::mem::offset_of!(TemplateElement, span) == 32usize);
+    assert!(std::mem::offset_of!(TemplateElement, tail) == 40usize);
+    assert!(std::mem::offset_of!(TemplateElement, value) == 0usize);
     assert!(size_of::<TemplateElementValue>() == 32usize);
     assert!(align_of::<TemplateElementValue>() == 8usize);
     assert!(std::mem::offset_of!(TemplateElementValue, raw) == 0usize);
@@ -125,87 +125,87 @@ const _: () = {
     assert!(align_of::<MemberExpression>() == 8usize);
     assert!(size_of::<ComputedMemberExpression>() == 48usize);
     assert!(align_of::<ComputedMemberExpression>() == 8usize);
-    assert!(std::mem::offset_of!(ComputedMemberExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ComputedMemberExpression, object) == 8usize);
-    assert!(std::mem::offset_of!(ComputedMemberExpression, expression) == 24usize);
+    assert!(std::mem::offset_of!(ComputedMemberExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(ComputedMemberExpression, object) == 0usize);
+    assert!(std::mem::offset_of!(ComputedMemberExpression, expression) == 16usize);
     assert!(std::mem::offset_of!(ComputedMemberExpression, optional) == 40usize);
     assert!(size_of::<StaticMemberExpression>() == 56usize);
     assert!(align_of::<StaticMemberExpression>() == 8usize);
-    assert!(std::mem::offset_of!(StaticMemberExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(StaticMemberExpression, object) == 8usize);
-    assert!(std::mem::offset_of!(StaticMemberExpression, property) == 24usize);
+    assert!(std::mem::offset_of!(StaticMemberExpression, span) == 40usize);
+    assert!(std::mem::offset_of!(StaticMemberExpression, object) == 24usize);
+    assert!(std::mem::offset_of!(StaticMemberExpression, property) == 0usize);
     assert!(std::mem::offset_of!(StaticMemberExpression, optional) == 48usize);
     assert!(size_of::<PrivateFieldExpression>() == 56usize);
     assert!(align_of::<PrivateFieldExpression>() == 8usize);
-    assert!(std::mem::offset_of!(PrivateFieldExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(PrivateFieldExpression, object) == 8usize);
-    assert!(std::mem::offset_of!(PrivateFieldExpression, field) == 24usize);
+    assert!(std::mem::offset_of!(PrivateFieldExpression, span) == 40usize);
+    assert!(std::mem::offset_of!(PrivateFieldExpression, object) == 24usize);
+    assert!(std::mem::offset_of!(PrivateFieldExpression, field) == 0usize);
     assert!(std::mem::offset_of!(PrivateFieldExpression, optional) == 48usize);
     assert!(size_of::<CallExpression>() == 72usize);
     assert!(align_of::<CallExpression>() == 8usize);
-    assert!(std::mem::offset_of!(CallExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(CallExpression, arguments) == 8usize);
-    assert!(std::mem::offset_of!(CallExpression, callee) == 40usize);
+    assert!(std::mem::offset_of!(CallExpression, span) == 48usize);
+    assert!(std::mem::offset_of!(CallExpression, arguments) == 0usize);
+    assert!(std::mem::offset_of!(CallExpression, callee) == 32usize);
     assert!(std::mem::offset_of!(CallExpression, type_parameters) == 56usize);
     assert!(std::mem::offset_of!(CallExpression, optional) == 64usize);
     assert!(size_of::<NewExpression>() == 64usize);
     assert!(align_of::<NewExpression>() == 8usize);
-    assert!(std::mem::offset_of!(NewExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(NewExpression, callee) == 8usize);
-    assert!(std::mem::offset_of!(NewExpression, arguments) == 24usize);
+    assert!(std::mem::offset_of!(NewExpression, span) == 48usize);
+    assert!(std::mem::offset_of!(NewExpression, callee) == 32usize);
+    assert!(std::mem::offset_of!(NewExpression, arguments) == 0usize);
     assert!(std::mem::offset_of!(NewExpression, type_parameters) == 56usize);
     assert!(size_of::<MetaProperty>() == 56usize);
     assert!(align_of::<MetaProperty>() == 8usize);
-    assert!(std::mem::offset_of!(MetaProperty, span) == 0usize);
-    assert!(std::mem::offset_of!(MetaProperty, meta) == 8usize);
-    assert!(std::mem::offset_of!(MetaProperty, property) == 32usize);
+    assert!(std::mem::offset_of!(MetaProperty, span) == 48usize);
+    assert!(std::mem::offset_of!(MetaProperty, meta) == 0usize);
+    assert!(std::mem::offset_of!(MetaProperty, property) == 24usize);
     assert!(size_of::<SpreadElement>() == 24usize);
     assert!(align_of::<SpreadElement>() == 8usize);
-    assert!(std::mem::offset_of!(SpreadElement, span) == 0usize);
-    assert!(std::mem::offset_of!(SpreadElement, argument) == 8usize);
+    assert!(std::mem::offset_of!(SpreadElement, span) == 16usize);
+    assert!(std::mem::offset_of!(SpreadElement, argument) == 0usize);
     assert!(size_of::<Argument>() == 16usize);
     assert!(align_of::<Argument>() == 8usize);
     assert!(size_of::<UpdateExpression>() == 32usize);
     assert!(align_of::<UpdateExpression>() == 8usize);
-    assert!(std::mem::offset_of!(UpdateExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(UpdateExpression, operator) == 8usize);
-    assert!(std::mem::offset_of!(UpdateExpression, prefix) == 9usize);
-    assert!(std::mem::offset_of!(UpdateExpression, argument) == 16usize);
+    assert!(std::mem::offset_of!(UpdateExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(UpdateExpression, operator) == 24usize);
+    assert!(std::mem::offset_of!(UpdateExpression, prefix) == 25usize);
+    assert!(std::mem::offset_of!(UpdateExpression, argument) == 0usize);
     assert!(size_of::<UnaryExpression>() == 32usize);
     assert!(align_of::<UnaryExpression>() == 8usize);
-    assert!(std::mem::offset_of!(UnaryExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(UnaryExpression, operator) == 8usize);
-    assert!(std::mem::offset_of!(UnaryExpression, argument) == 16usize);
+    assert!(std::mem::offset_of!(UnaryExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(UnaryExpression, operator) == 24usize);
+    assert!(std::mem::offset_of!(UnaryExpression, argument) == 0usize);
     assert!(size_of::<BinaryExpression>() == 48usize);
     assert!(align_of::<BinaryExpression>() == 8usize);
-    assert!(std::mem::offset_of!(BinaryExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(BinaryExpression, left) == 8usize);
-    assert!(std::mem::offset_of!(BinaryExpression, operator) == 24usize);
-    assert!(std::mem::offset_of!(BinaryExpression, right) == 32usize);
+    assert!(std::mem::offset_of!(BinaryExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(BinaryExpression, left) == 0usize);
+    assert!(std::mem::offset_of!(BinaryExpression, operator) == 40usize);
+    assert!(std::mem::offset_of!(BinaryExpression, right) == 16usize);
     assert!(size_of::<PrivateInExpression>() == 56usize);
     assert!(align_of::<PrivateInExpression>() == 8usize);
-    assert!(std::mem::offset_of!(PrivateInExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(PrivateInExpression, left) == 8usize);
-    assert!(std::mem::offset_of!(PrivateInExpression, operator) == 32usize);
-    assert!(std::mem::offset_of!(PrivateInExpression, right) == 40usize);
+    assert!(std::mem::offset_of!(PrivateInExpression, span) == 40usize);
+    assert!(std::mem::offset_of!(PrivateInExpression, left) == 0usize);
+    assert!(std::mem::offset_of!(PrivateInExpression, operator) == 48usize);
+    assert!(std::mem::offset_of!(PrivateInExpression, right) == 24usize);
     assert!(size_of::<LogicalExpression>() == 48usize);
     assert!(align_of::<LogicalExpression>() == 8usize);
-    assert!(std::mem::offset_of!(LogicalExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(LogicalExpression, left) == 8usize);
-    assert!(std::mem::offset_of!(LogicalExpression, operator) == 24usize);
-    assert!(std::mem::offset_of!(LogicalExpression, right) == 32usize);
+    assert!(std::mem::offset_of!(LogicalExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(LogicalExpression, left) == 0usize);
+    assert!(std::mem::offset_of!(LogicalExpression, operator) == 40usize);
+    assert!(std::mem::offset_of!(LogicalExpression, right) == 16usize);
     assert!(size_of::<ConditionalExpression>() == 56usize);
     assert!(align_of::<ConditionalExpression>() == 8usize);
-    assert!(std::mem::offset_of!(ConditionalExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ConditionalExpression, test) == 8usize);
-    assert!(std::mem::offset_of!(ConditionalExpression, consequent) == 24usize);
-    assert!(std::mem::offset_of!(ConditionalExpression, alternate) == 40usize);
+    assert!(std::mem::offset_of!(ConditionalExpression, span) == 48usize);
+    assert!(std::mem::offset_of!(ConditionalExpression, test) == 0usize);
+    assert!(std::mem::offset_of!(ConditionalExpression, consequent) == 16usize);
+    assert!(std::mem::offset_of!(ConditionalExpression, alternate) == 32usize);
     assert!(size_of::<AssignmentExpression>() == 48usize);
     assert!(align_of::<AssignmentExpression>() == 8usize);
-    assert!(std::mem::offset_of!(AssignmentExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentExpression, operator) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentExpression, left) == 16usize);
-    assert!(std::mem::offset_of!(AssignmentExpression, right) == 32usize);
+    assert!(std::mem::offset_of!(AssignmentExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(AssignmentExpression, operator) == 40usize);
+    assert!(std::mem::offset_of!(AssignmentExpression, left) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentExpression, right) == 16usize);
     assert!(size_of::<AssignmentTarget>() == 16usize);
     assert!(align_of::<AssignmentTarget>() == 8usize);
     assert!(size_of::<SimpleAssignmentTarget>() == 16usize);
@@ -214,184 +214,184 @@ const _: () = {
     assert!(align_of::<AssignmentTargetPattern>() == 8usize);
     assert!(size_of::<ArrayAssignmentTarget>() == 80usize);
     assert!(align_of::<ArrayAssignmentTarget>() == 8usize);
-    assert!(std::mem::offset_of!(ArrayAssignmentTarget, span) == 0usize);
-    assert!(std::mem::offset_of!(ArrayAssignmentTarget, elements) == 8usize);
-    assert!(std::mem::offset_of!(ArrayAssignmentTarget, rest) == 40usize);
-    assert!(std::mem::offset_of!(ArrayAssignmentTarget, trailing_comma) == 64usize);
+    assert!(std::mem::offset_of!(ArrayAssignmentTarget, span) == 68usize);
+    assert!(std::mem::offset_of!(ArrayAssignmentTarget, elements) == 0usize);
+    assert!(std::mem::offset_of!(ArrayAssignmentTarget, rest) == 32usize);
+    assert!(std::mem::offset_of!(ArrayAssignmentTarget, trailing_comma) == 56usize);
     assert!(size_of::<ObjectAssignmentTarget>() == 64usize);
     assert!(align_of::<ObjectAssignmentTarget>() == 8usize);
-    assert!(std::mem::offset_of!(ObjectAssignmentTarget, span) == 0usize);
-    assert!(std::mem::offset_of!(ObjectAssignmentTarget, properties) == 8usize);
-    assert!(std::mem::offset_of!(ObjectAssignmentTarget, rest) == 40usize);
+    assert!(std::mem::offset_of!(ObjectAssignmentTarget, span) == 56usize);
+    assert!(std::mem::offset_of!(ObjectAssignmentTarget, properties) == 0usize);
+    assert!(std::mem::offset_of!(ObjectAssignmentTarget, rest) == 32usize);
     assert!(size_of::<AssignmentTargetRest>() == 24usize);
     assert!(align_of::<AssignmentTargetRest>() == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetRest, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentTargetRest, target) == 8usize);
+    assert!(std::mem::offset_of!(AssignmentTargetRest, span) == 16usize);
+    assert!(std::mem::offset_of!(AssignmentTargetRest, target) == 0usize);
     assert!(size_of::<AssignmentTargetMaybeDefault>() == 16usize);
     assert!(align_of::<AssignmentTargetMaybeDefault>() == 8usize);
     assert!(size_of::<AssignmentTargetWithDefault>() == 40usize);
     assert!(align_of::<AssignmentTargetWithDefault>() == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, binding) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, init) == 24usize);
+    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, span) == 32usize);
+    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, binding) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, init) == 16usize);
     assert!(size_of::<AssignmentTargetProperty>() == 16usize);
     assert!(align_of::<AssignmentTargetProperty>() == 8usize);
     assert!(size_of::<AssignmentTargetPropertyIdentifier>() == 56usize);
     assert!(align_of::<AssignmentTargetPropertyIdentifier>() == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, binding) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, init) == 40usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, span) == 48usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, binding) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, init) == 32usize);
     assert!(size_of::<AssignmentTargetPropertyProperty>() == 40usize);
     assert!(align_of::<AssignmentTargetPropertyProperty>() == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, name) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, binding) == 24usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, span) == 32usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, name) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, binding) == 16usize);
     assert!(size_of::<SequenceExpression>() == 40usize);
     assert!(align_of::<SequenceExpression>() == 8usize);
-    assert!(std::mem::offset_of!(SequenceExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(SequenceExpression, expressions) == 8usize);
+    assert!(std::mem::offset_of!(SequenceExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(SequenceExpression, expressions) == 0usize);
     assert!(size_of::<Super>() == 8usize);
     assert!(align_of::<Super>() == 4usize);
     assert!(std::mem::offset_of!(Super, span) == 0usize);
     assert!(size_of::<AwaitExpression>() == 24usize);
     assert!(align_of::<AwaitExpression>() == 8usize);
-    assert!(std::mem::offset_of!(AwaitExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(AwaitExpression, argument) == 8usize);
+    assert!(std::mem::offset_of!(AwaitExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(AwaitExpression, argument) == 0usize);
     assert!(size_of::<ChainExpression>() == 24usize);
     assert!(align_of::<ChainExpression>() == 8usize);
-    assert!(std::mem::offset_of!(ChainExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ChainExpression, expression) == 8usize);
+    assert!(std::mem::offset_of!(ChainExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(ChainExpression, expression) == 0usize);
     assert!(size_of::<ChainElement>() == 16usize);
     assert!(align_of::<ChainElement>() == 8usize);
     assert!(size_of::<ParenthesizedExpression>() == 24usize);
     assert!(align_of::<ParenthesizedExpression>() == 8usize);
-    assert!(std::mem::offset_of!(ParenthesizedExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ParenthesizedExpression, expression) == 8usize);
+    assert!(std::mem::offset_of!(ParenthesizedExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(ParenthesizedExpression, expression) == 0usize);
     assert!(size_of::<Statement>() == 16usize);
     assert!(align_of::<Statement>() == 8usize);
     assert!(size_of::<Directive>() == 48usize);
     assert!(align_of::<Directive>() == 8usize);
-    assert!(std::mem::offset_of!(Directive, span) == 0usize);
-    assert!(std::mem::offset_of!(Directive, expression) == 8usize);
-    assert!(std::mem::offset_of!(Directive, directive) == 32usize);
+    assert!(std::mem::offset_of!(Directive, span) == 40usize);
+    assert!(std::mem::offset_of!(Directive, expression) == 0usize);
+    assert!(std::mem::offset_of!(Directive, directive) == 24usize);
     assert!(size_of::<Hashbang>() == 24usize);
     assert!(align_of::<Hashbang>() == 8usize);
-    assert!(std::mem::offset_of!(Hashbang, span) == 0usize);
-    assert!(std::mem::offset_of!(Hashbang, value) == 8usize);
+    assert!(std::mem::offset_of!(Hashbang, span) == 16usize);
+    assert!(std::mem::offset_of!(Hashbang, value) == 0usize);
     assert!(size_of::<BlockStatement>() == 48usize);
     assert!(align_of::<BlockStatement>() == 8usize);
-    assert!(std::mem::offset_of!(BlockStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(BlockStatement, body) == 8usize);
+    assert!(std::mem::offset_of!(BlockStatement, span) == 32usize);
+    assert!(std::mem::offset_of!(BlockStatement, body) == 0usize);
     assert!(std::mem::offset_of!(BlockStatement, scope_id) == 40usize);
     assert!(size_of::<Declaration>() == 16usize);
     assert!(align_of::<Declaration>() == 8usize);
-    assert!(size_of::<VariableDeclaration>() == 56usize);
+    assert!(size_of::<VariableDeclaration>() == 48usize);
     assert!(align_of::<VariableDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(VariableDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(VariableDeclaration, kind) == 8usize);
-    assert!(std::mem::offset_of!(VariableDeclaration, declarations) == 16usize);
-    assert!(std::mem::offset_of!(VariableDeclaration, declare) == 48usize);
+    assert!(std::mem::offset_of!(VariableDeclaration, span) == 32usize);
+    assert!(std::mem::offset_of!(VariableDeclaration, kind) == 40usize);
+    assert!(std::mem::offset_of!(VariableDeclaration, declarations) == 0usize);
+    assert!(std::mem::offset_of!(VariableDeclaration, declare) == 41usize);
     assert!(size_of::<VariableDeclarationKind>() == 1usize);
     assert!(align_of::<VariableDeclarationKind>() == 1usize);
-    assert!(size_of::<VariableDeclarator>() == 72usize);
+    assert!(size_of::<VariableDeclarator>() == 64usize);
     assert!(align_of::<VariableDeclarator>() == 8usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, span) == 0usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, kind) == 8usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, id) == 16usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, init) == 48usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, definite) == 64usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, span) == 48usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, kind) == 56usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, id) == 0usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, init) == 32usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, definite) == 57usize);
     assert!(size_of::<UsingDeclaration>() == 48usize);
     assert!(align_of::<UsingDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(UsingDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(UsingDeclaration, is_await) == 8usize);
-    assert!(std::mem::offset_of!(UsingDeclaration, declarations) == 16usize);
+    assert!(std::mem::offset_of!(UsingDeclaration, span) == 32usize);
+    assert!(std::mem::offset_of!(UsingDeclaration, is_await) == 40usize);
+    assert!(std::mem::offset_of!(UsingDeclaration, declarations) == 0usize);
     assert!(size_of::<EmptyStatement>() == 8usize);
     assert!(align_of::<EmptyStatement>() == 4usize);
     assert!(std::mem::offset_of!(EmptyStatement, span) == 0usize);
     assert!(size_of::<ExpressionStatement>() == 24usize);
     assert!(align_of::<ExpressionStatement>() == 8usize);
-    assert!(std::mem::offset_of!(ExpressionStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ExpressionStatement, expression) == 8usize);
+    assert!(std::mem::offset_of!(ExpressionStatement, span) == 16usize);
+    assert!(std::mem::offset_of!(ExpressionStatement, expression) == 0usize);
     assert!(size_of::<IfStatement>() == 56usize);
     assert!(align_of::<IfStatement>() == 8usize);
-    assert!(std::mem::offset_of!(IfStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(IfStatement, test) == 8usize);
-    assert!(std::mem::offset_of!(IfStatement, consequent) == 24usize);
-    assert!(std::mem::offset_of!(IfStatement, alternate) == 40usize);
+    assert!(std::mem::offset_of!(IfStatement, span) == 48usize);
+    assert!(std::mem::offset_of!(IfStatement, test) == 0usize);
+    assert!(std::mem::offset_of!(IfStatement, consequent) == 16usize);
+    assert!(std::mem::offset_of!(IfStatement, alternate) == 32usize);
     assert!(size_of::<DoWhileStatement>() == 40usize);
     assert!(align_of::<DoWhileStatement>() == 8usize);
-    assert!(std::mem::offset_of!(DoWhileStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(DoWhileStatement, body) == 8usize);
-    assert!(std::mem::offset_of!(DoWhileStatement, test) == 24usize);
+    assert!(std::mem::offset_of!(DoWhileStatement, span) == 32usize);
+    assert!(std::mem::offset_of!(DoWhileStatement, body) == 0usize);
+    assert!(std::mem::offset_of!(DoWhileStatement, test) == 16usize);
     assert!(size_of::<WhileStatement>() == 40usize);
     assert!(align_of::<WhileStatement>() == 8usize);
-    assert!(std::mem::offset_of!(WhileStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(WhileStatement, test) == 8usize);
-    assert!(std::mem::offset_of!(WhileStatement, body) == 24usize);
+    assert!(std::mem::offset_of!(WhileStatement, span) == 32usize);
+    assert!(std::mem::offset_of!(WhileStatement, test) == 0usize);
+    assert!(std::mem::offset_of!(WhileStatement, body) == 16usize);
     assert!(size_of::<ForStatement>() == 80usize);
     assert!(align_of::<ForStatement>() == 8usize);
-    assert!(std::mem::offset_of!(ForStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ForStatement, init) == 8usize);
-    assert!(std::mem::offset_of!(ForStatement, test) == 24usize);
-    assert!(std::mem::offset_of!(ForStatement, update) == 40usize);
-    assert!(std::mem::offset_of!(ForStatement, body) == 56usize);
+    assert!(std::mem::offset_of!(ForStatement, span) == 64usize);
+    assert!(std::mem::offset_of!(ForStatement, init) == 0usize);
+    assert!(std::mem::offset_of!(ForStatement, test) == 16usize);
+    assert!(std::mem::offset_of!(ForStatement, update) == 32usize);
+    assert!(std::mem::offset_of!(ForStatement, body) == 48usize);
     assert!(std::mem::offset_of!(ForStatement, scope_id) == 72usize);
     assert!(size_of::<ForStatementInit>() == 16usize);
     assert!(align_of::<ForStatementInit>() == 8usize);
     assert!(size_of::<ForInStatement>() == 64usize);
     assert!(align_of::<ForInStatement>() == 8usize);
-    assert!(std::mem::offset_of!(ForInStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ForInStatement, left) == 8usize);
-    assert!(std::mem::offset_of!(ForInStatement, right) == 24usize);
-    assert!(std::mem::offset_of!(ForInStatement, body) == 40usize);
+    assert!(std::mem::offset_of!(ForInStatement, span) == 48usize);
+    assert!(std::mem::offset_of!(ForInStatement, left) == 0usize);
+    assert!(std::mem::offset_of!(ForInStatement, right) == 16usize);
+    assert!(std::mem::offset_of!(ForInStatement, body) == 32usize);
     assert!(std::mem::offset_of!(ForInStatement, scope_id) == 56usize);
     assert!(size_of::<ForStatementLeft>() == 16usize);
     assert!(align_of::<ForStatementLeft>() == 8usize);
-    assert!(size_of::<ForOfStatement>() == 72usize);
+    assert!(size_of::<ForOfStatement>() == 64usize);
     assert!(align_of::<ForOfStatement>() == 8usize);
-    assert!(std::mem::offset_of!(ForOfStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ForOfStatement, r#await) == 8usize);
-    assert!(std::mem::offset_of!(ForOfStatement, left) == 16usize);
-    assert!(std::mem::offset_of!(ForOfStatement, right) == 32usize);
-    assert!(std::mem::offset_of!(ForOfStatement, body) == 48usize);
-    assert!(std::mem::offset_of!(ForOfStatement, scope_id) == 64usize);
+    assert!(std::mem::offset_of!(ForOfStatement, span) == 48usize);
+    assert!(std::mem::offset_of!(ForOfStatement, r#await) == 60usize);
+    assert!(std::mem::offset_of!(ForOfStatement, left) == 0usize);
+    assert!(std::mem::offset_of!(ForOfStatement, right) == 16usize);
+    assert!(std::mem::offset_of!(ForOfStatement, body) == 32usize);
+    assert!(std::mem::offset_of!(ForOfStatement, scope_id) == 56usize);
     assert!(size_of::<ContinueStatement>() == 32usize);
     assert!(align_of::<ContinueStatement>() == 8usize);
-    assert!(std::mem::offset_of!(ContinueStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ContinueStatement, label) == 8usize);
+    assert!(std::mem::offset_of!(ContinueStatement, span) == 24usize);
+    assert!(std::mem::offset_of!(ContinueStatement, label) == 0usize);
     assert!(size_of::<BreakStatement>() == 32usize);
     assert!(align_of::<BreakStatement>() == 8usize);
-    assert!(std::mem::offset_of!(BreakStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(BreakStatement, label) == 8usize);
+    assert!(std::mem::offset_of!(BreakStatement, span) == 24usize);
+    assert!(std::mem::offset_of!(BreakStatement, label) == 0usize);
     assert!(size_of::<ReturnStatement>() == 24usize);
     assert!(align_of::<ReturnStatement>() == 8usize);
-    assert!(std::mem::offset_of!(ReturnStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ReturnStatement, argument) == 8usize);
+    assert!(std::mem::offset_of!(ReturnStatement, span) == 16usize);
+    assert!(std::mem::offset_of!(ReturnStatement, argument) == 0usize);
     assert!(size_of::<WithStatement>() == 40usize);
     assert!(align_of::<WithStatement>() == 8usize);
-    assert!(std::mem::offset_of!(WithStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(WithStatement, object) == 8usize);
-    assert!(std::mem::offset_of!(WithStatement, body) == 24usize);
+    assert!(std::mem::offset_of!(WithStatement, span) == 32usize);
+    assert!(std::mem::offset_of!(WithStatement, object) == 0usize);
+    assert!(std::mem::offset_of!(WithStatement, body) == 16usize);
     assert!(size_of::<SwitchStatement>() == 64usize);
     assert!(align_of::<SwitchStatement>() == 8usize);
-    assert!(std::mem::offset_of!(SwitchStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(SwitchStatement, discriminant) == 8usize);
-    assert!(std::mem::offset_of!(SwitchStatement, cases) == 24usize);
+    assert!(std::mem::offset_of!(SwitchStatement, span) == 48usize);
+    assert!(std::mem::offset_of!(SwitchStatement, discriminant) == 32usize);
+    assert!(std::mem::offset_of!(SwitchStatement, cases) == 0usize);
     assert!(std::mem::offset_of!(SwitchStatement, scope_id) == 56usize);
     assert!(size_of::<SwitchCase>() == 56usize);
     assert!(align_of::<SwitchCase>() == 8usize);
-    assert!(std::mem::offset_of!(SwitchCase, span) == 0usize);
-    assert!(std::mem::offset_of!(SwitchCase, test) == 8usize);
-    assert!(std::mem::offset_of!(SwitchCase, consequent) == 24usize);
+    assert!(std::mem::offset_of!(SwitchCase, span) == 48usize);
+    assert!(std::mem::offset_of!(SwitchCase, test) == 32usize);
+    assert!(std::mem::offset_of!(SwitchCase, consequent) == 0usize);
     assert!(size_of::<LabeledStatement>() == 48usize);
     assert!(align_of::<LabeledStatement>() == 8usize);
-    assert!(std::mem::offset_of!(LabeledStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(LabeledStatement, label) == 8usize);
-    assert!(std::mem::offset_of!(LabeledStatement, body) == 32usize);
+    assert!(std::mem::offset_of!(LabeledStatement, span) == 40usize);
+    assert!(std::mem::offset_of!(LabeledStatement, label) == 0usize);
+    assert!(std::mem::offset_of!(LabeledStatement, body) == 24usize);
     assert!(size_of::<ThrowStatement>() == 24usize);
     assert!(align_of::<ThrowStatement>() == 8usize);
-    assert!(std::mem::offset_of!(ThrowStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ThrowStatement, argument) == 8usize);
+    assert!(std::mem::offset_of!(ThrowStatement, span) == 16usize);
+    assert!(std::mem::offset_of!(ThrowStatement, argument) == 0usize);
     assert!(size_of::<TryStatement>() == 32usize);
     assert!(align_of::<TryStatement>() == 8usize);
     assert!(std::mem::offset_of!(TryStatement, span) == 0usize);
@@ -400,14 +400,14 @@ const _: () = {
     assert!(std::mem::offset_of!(TryStatement, finalizer) == 24usize);
     assert!(size_of::<CatchClause>() == 64usize);
     assert!(align_of::<CatchClause>() == 8usize);
-    assert!(std::mem::offset_of!(CatchClause, span) == 0usize);
-    assert!(std::mem::offset_of!(CatchClause, param) == 8usize);
+    assert!(std::mem::offset_of!(CatchClause, span) == 40usize);
+    assert!(std::mem::offset_of!(CatchClause, param) == 0usize);
     assert!(std::mem::offset_of!(CatchClause, body) == 48usize);
     assert!(std::mem::offset_of!(CatchClause, scope_id) == 56usize);
     assert!(size_of::<CatchParameter>() == 40usize);
     assert!(align_of::<CatchParameter>() == 8usize);
-    assert!(std::mem::offset_of!(CatchParameter, span) == 0usize);
-    assert!(std::mem::offset_of!(CatchParameter, pattern) == 8usize);
+    assert!(std::mem::offset_of!(CatchParameter, span) == 32usize);
+    assert!(std::mem::offset_of!(CatchParameter, pattern) == 0usize);
     assert!(size_of::<DebuggerStatement>() == 8usize);
     assert!(align_of::<DebuggerStatement>() == 4usize);
     assert!(std::mem::offset_of!(DebuggerStatement, span) == 0usize);
@@ -420,57 +420,57 @@ const _: () = {
     assert!(align_of::<BindingPatternKind>() == 8usize);
     assert!(size_of::<AssignmentPattern>() == 56usize);
     assert!(align_of::<AssignmentPattern>() == 8usize);
-    assert!(std::mem::offset_of!(AssignmentPattern, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentPattern, left) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentPattern, right) == 40usize);
+    assert!(std::mem::offset_of!(AssignmentPattern, span) == 48usize);
+    assert!(std::mem::offset_of!(AssignmentPattern, left) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentPattern, right) == 32usize);
     assert!(size_of::<ObjectPattern>() == 48usize);
     assert!(align_of::<ObjectPattern>() == 8usize);
-    assert!(std::mem::offset_of!(ObjectPattern, span) == 0usize);
-    assert!(std::mem::offset_of!(ObjectPattern, properties) == 8usize);
+    assert!(std::mem::offset_of!(ObjectPattern, span) == 32usize);
+    assert!(std::mem::offset_of!(ObjectPattern, properties) == 0usize);
     assert!(std::mem::offset_of!(ObjectPattern, rest) == 40usize);
     assert!(size_of::<BindingProperty>() == 64usize);
     assert!(align_of::<BindingProperty>() == 8usize);
-    assert!(std::mem::offset_of!(BindingProperty, span) == 0usize);
-    assert!(std::mem::offset_of!(BindingProperty, key) == 8usize);
-    assert!(std::mem::offset_of!(BindingProperty, value) == 24usize);
+    assert!(std::mem::offset_of!(BindingProperty, span) == 48usize);
+    assert!(std::mem::offset_of!(BindingProperty, key) == 32usize);
+    assert!(std::mem::offset_of!(BindingProperty, value) == 0usize);
     assert!(std::mem::offset_of!(BindingProperty, shorthand) == 56usize);
     assert!(std::mem::offset_of!(BindingProperty, computed) == 57usize);
     assert!(size_of::<ArrayPattern>() == 48usize);
     assert!(align_of::<ArrayPattern>() == 8usize);
-    assert!(std::mem::offset_of!(ArrayPattern, span) == 0usize);
-    assert!(std::mem::offset_of!(ArrayPattern, elements) == 8usize);
+    assert!(std::mem::offset_of!(ArrayPattern, span) == 32usize);
+    assert!(std::mem::offset_of!(ArrayPattern, elements) == 0usize);
     assert!(std::mem::offset_of!(ArrayPattern, rest) == 40usize);
     assert!(size_of::<BindingRestElement>() == 40usize);
     assert!(align_of::<BindingRestElement>() == 8usize);
-    assert!(std::mem::offset_of!(BindingRestElement, span) == 0usize);
-    assert!(std::mem::offset_of!(BindingRestElement, argument) == 8usize);
-    assert!(size_of::<Function>() == 136usize);
+    assert!(std::mem::offset_of!(BindingRestElement, span) == 32usize);
+    assert!(std::mem::offset_of!(BindingRestElement, argument) == 0usize);
+    assert!(size_of::<Function>() == 120usize);
     assert!(align_of::<Function>() == 8usize);
-    assert!(std::mem::offset_of!(Function, r#type) == 0usize);
-    assert!(std::mem::offset_of!(Function, span) == 4usize);
-    assert!(std::mem::offset_of!(Function, id) == 16usize);
-    assert!(std::mem::offset_of!(Function, generator) == 48usize);
-    assert!(std::mem::offset_of!(Function, r#async) == 49usize);
-    assert!(std::mem::offset_of!(Function, declare) == 50usize);
-    assert!(std::mem::offset_of!(Function, type_parameters) == 56usize);
-    assert!(std::mem::offset_of!(Function, this_param) == 64usize);
-    assert!(std::mem::offset_of!(Function, params) == 104usize);
-    assert!(std::mem::offset_of!(Function, return_type) == 112usize);
-    assert!(std::mem::offset_of!(Function, body) == 120usize);
-    assert!(std::mem::offset_of!(Function, scope_id) == 128usize);
+    assert!(std::mem::offset_of!(Function, r#type) == 116usize);
+    assert!(std::mem::offset_of!(Function, span) == 72usize);
+    assert!(std::mem::offset_of!(Function, id) == 40usize);
+    assert!(std::mem::offset_of!(Function, generator) == 117usize);
+    assert!(std::mem::offset_of!(Function, r#async) == 118usize);
+    assert!(std::mem::offset_of!(Function, declare) == 119usize);
+    assert!(std::mem::offset_of!(Function, type_parameters) == 80usize);
+    assert!(std::mem::offset_of!(Function, this_param) == 0usize);
+    assert!(std::mem::offset_of!(Function, params) == 88usize);
+    assert!(std::mem::offset_of!(Function, return_type) == 96usize);
+    assert!(std::mem::offset_of!(Function, body) == 104usize);
+    assert!(std::mem::offset_of!(Function, scope_id) == 112usize);
     assert!(size_of::<FunctionType>() == 1usize);
     assert!(align_of::<FunctionType>() == 1usize);
     assert!(size_of::<FormalParameters>() == 56usize);
     assert!(align_of::<FormalParameters>() == 8usize);
-    assert!(std::mem::offset_of!(FormalParameters, span) == 0usize);
-    assert!(std::mem::offset_of!(FormalParameters, kind) == 8usize);
-    assert!(std::mem::offset_of!(FormalParameters, items) == 16usize);
-    assert!(std::mem::offset_of!(FormalParameters, rest) == 48usize);
+    assert!(std::mem::offset_of!(FormalParameters, span) == 32usize);
+    assert!(std::mem::offset_of!(FormalParameters, kind) == 48usize);
+    assert!(std::mem::offset_of!(FormalParameters, items) == 0usize);
+    assert!(std::mem::offset_of!(FormalParameters, rest) == 40usize);
     assert!(size_of::<FormalParameter>() == 80usize);
     assert!(align_of::<FormalParameter>() == 8usize);
-    assert!(std::mem::offset_of!(FormalParameter, span) == 0usize);
-    assert!(std::mem::offset_of!(FormalParameter, decorators) == 8usize);
-    assert!(std::mem::offset_of!(FormalParameter, pattern) == 40usize);
+    assert!(std::mem::offset_of!(FormalParameter, span) == 64usize);
+    assert!(std::mem::offset_of!(FormalParameter, decorators) == 0usize);
+    assert!(std::mem::offset_of!(FormalParameter, pattern) == 32usize);
     assert!(std::mem::offset_of!(FormalParameter, accessibility) == 72usize);
     assert!(std::mem::offset_of!(FormalParameter, readonly) == 73usize);
     assert!(std::mem::offset_of!(FormalParameter, r#override) == 74usize);
@@ -478,168 +478,168 @@ const _: () = {
     assert!(align_of::<FormalParameterKind>() == 1usize);
     assert!(size_of::<FunctionBody>() == 72usize);
     assert!(align_of::<FunctionBody>() == 8usize);
-    assert!(std::mem::offset_of!(FunctionBody, span) == 0usize);
-    assert!(std::mem::offset_of!(FunctionBody, directives) == 8usize);
-    assert!(std::mem::offset_of!(FunctionBody, statements) == 40usize);
-    assert!(size_of::<ArrowFunctionExpression>() == 56usize);
+    assert!(std::mem::offset_of!(FunctionBody, span) == 64usize);
+    assert!(std::mem::offset_of!(FunctionBody, directives) == 0usize);
+    assert!(std::mem::offset_of!(FunctionBody, statements) == 32usize);
+    assert!(size_of::<ArrowFunctionExpression>() == 48usize);
     assert!(align_of::<ArrowFunctionExpression>() == 8usize);
     assert!(std::mem::offset_of!(ArrowFunctionExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, expression) == 8usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, r#async) == 9usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, type_parameters) == 16usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, params) == 24usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, return_type) == 32usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, body) == 40usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, scope_id) == 48usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, expression) == 44usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, r#async) == 45usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, type_parameters) == 8usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, params) == 16usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, return_type) == 24usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, body) == 32usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, scope_id) == 40usize);
     assert!(size_of::<YieldExpression>() == 32usize);
     assert!(align_of::<YieldExpression>() == 8usize);
-    assert!(std::mem::offset_of!(YieldExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(YieldExpression, delegate) == 8usize);
-    assert!(std::mem::offset_of!(YieldExpression, argument) == 16usize);
-    assert!(size_of::<Class>() == 160usize);
+    assert!(std::mem::offset_of!(YieldExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(YieldExpression, delegate) == 24usize);
+    assert!(std::mem::offset_of!(YieldExpression, argument) == 0usize);
+    assert!(size_of::<Class>() == 152usize);
     assert!(align_of::<Class>() == 8usize);
-    assert!(std::mem::offset_of!(Class, r#type) == 0usize);
-    assert!(std::mem::offset_of!(Class, span) == 4usize);
-    assert!(std::mem::offset_of!(Class, decorators) == 16usize);
-    assert!(std::mem::offset_of!(Class, id) == 48usize);
-    assert!(std::mem::offset_of!(Class, type_parameters) == 80usize);
-    assert!(std::mem::offset_of!(Class, super_class) == 88usize);
-    assert!(std::mem::offset_of!(Class, super_type_parameters) == 104usize);
-    assert!(std::mem::offset_of!(Class, implements) == 112usize);
-    assert!(std::mem::offset_of!(Class, body) == 144usize);
-    assert!(std::mem::offset_of!(Class, r#abstract) == 152usize);
-    assert!(std::mem::offset_of!(Class, declare) == 153usize);
-    assert!(std::mem::offset_of!(Class, scope_id) == 156usize);
+    assert!(std::mem::offset_of!(Class, r#type) == 148usize);
+    assert!(std::mem::offset_of!(Class, span) == 112usize);
+    assert!(std::mem::offset_of!(Class, decorators) == 0usize);
+    assert!(std::mem::offset_of!(Class, id) == 32usize);
+    assert!(std::mem::offset_of!(Class, type_parameters) == 120usize);
+    assert!(std::mem::offset_of!(Class, super_class) == 96usize);
+    assert!(std::mem::offset_of!(Class, super_type_parameters) == 128usize);
+    assert!(std::mem::offset_of!(Class, implements) == 64usize);
+    assert!(std::mem::offset_of!(Class, body) == 136usize);
+    assert!(std::mem::offset_of!(Class, r#abstract) == 149usize);
+    assert!(std::mem::offset_of!(Class, declare) == 150usize);
+    assert!(std::mem::offset_of!(Class, scope_id) == 144usize);
     assert!(size_of::<ClassType>() == 1usize);
     assert!(align_of::<ClassType>() == 1usize);
     assert!(size_of::<ClassBody>() == 40usize);
     assert!(align_of::<ClassBody>() == 8usize);
-    assert!(std::mem::offset_of!(ClassBody, span) == 0usize);
-    assert!(std::mem::offset_of!(ClassBody, body) == 8usize);
+    assert!(std::mem::offset_of!(ClassBody, span) == 32usize);
+    assert!(std::mem::offset_of!(ClassBody, body) == 0usize);
     assert!(size_of::<ClassElement>() == 16usize);
     assert!(align_of::<ClassElement>() == 8usize);
-    assert!(size_of::<MethodDefinition>() == 80usize);
+    assert!(size_of::<MethodDefinition>() == 72usize);
     assert!(align_of::<MethodDefinition>() == 8usize);
-    assert!(std::mem::offset_of!(MethodDefinition, r#type) == 0usize);
-    assert!(std::mem::offset_of!(MethodDefinition, span) == 4usize);
-    assert!(std::mem::offset_of!(MethodDefinition, decorators) == 16usize);
-    assert!(std::mem::offset_of!(MethodDefinition, key) == 48usize);
-    assert!(std::mem::offset_of!(MethodDefinition, value) == 64usize);
-    assert!(std::mem::offset_of!(MethodDefinition, kind) == 72usize);
-    assert!(std::mem::offset_of!(MethodDefinition, computed) == 73usize);
-    assert!(std::mem::offset_of!(MethodDefinition, r#static) == 74usize);
-    assert!(std::mem::offset_of!(MethodDefinition, r#override) == 75usize);
-    assert!(std::mem::offset_of!(MethodDefinition, optional) == 76usize);
-    assert!(std::mem::offset_of!(MethodDefinition, accessibility) == 77usize);
+    assert!(std::mem::offset_of!(MethodDefinition, r#type) == 64usize);
+    assert!(std::mem::offset_of!(MethodDefinition, span) == 48usize);
+    assert!(std::mem::offset_of!(MethodDefinition, decorators) == 0usize);
+    assert!(std::mem::offset_of!(MethodDefinition, key) == 32usize);
+    assert!(std::mem::offset_of!(MethodDefinition, value) == 56usize);
+    assert!(std::mem::offset_of!(MethodDefinition, kind) == 65usize);
+    assert!(std::mem::offset_of!(MethodDefinition, computed) == 66usize);
+    assert!(std::mem::offset_of!(MethodDefinition, r#static) == 67usize);
+    assert!(std::mem::offset_of!(MethodDefinition, r#override) == 68usize);
+    assert!(std::mem::offset_of!(MethodDefinition, optional) == 69usize);
+    assert!(std::mem::offset_of!(MethodDefinition, accessibility) == 70usize);
     assert!(size_of::<MethodDefinitionType>() == 1usize);
     assert!(align_of::<MethodDefinitionType>() == 1usize);
-    assert!(size_of::<PropertyDefinition>() == 104usize);
+    assert!(size_of::<PropertyDefinition>() == 96usize);
     assert!(align_of::<PropertyDefinition>() == 8usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, r#type) == 0usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, span) == 4usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, decorators) == 16usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, key) == 48usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, value) == 64usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, computed) == 80usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, r#static) == 81usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, declare) == 82usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, r#override) == 83usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, optional) == 84usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, definite) == 85usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, readonly) == 86usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, type_annotation) == 88usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, accessibility) == 96usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, r#type) == 80usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, span) == 64usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, decorators) == 0usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, key) == 32usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, value) == 48usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, computed) == 81usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, r#static) == 82usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, declare) == 83usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, r#override) == 84usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, optional) == 85usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, definite) == 86usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, readonly) == 87usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, type_annotation) == 72usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, accessibility) == 88usize);
     assert!(size_of::<PropertyDefinitionType>() == 1usize);
     assert!(align_of::<PropertyDefinitionType>() == 1usize);
     assert!(size_of::<MethodDefinitionKind>() == 1usize);
     assert!(align_of::<MethodDefinitionKind>() == 1usize);
     assert!(size_of::<PrivateIdentifier>() == 24usize);
     assert!(align_of::<PrivateIdentifier>() == 8usize);
-    assert!(std::mem::offset_of!(PrivateIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(PrivateIdentifier, name) == 8usize);
+    assert!(std::mem::offset_of!(PrivateIdentifier, span) == 16usize);
+    assert!(std::mem::offset_of!(PrivateIdentifier, name) == 0usize);
     assert!(size_of::<StaticBlock>() == 48usize);
     assert!(align_of::<StaticBlock>() == 8usize);
-    assert!(std::mem::offset_of!(StaticBlock, span) == 0usize);
-    assert!(std::mem::offset_of!(StaticBlock, body) == 8usize);
+    assert!(std::mem::offset_of!(StaticBlock, span) == 32usize);
+    assert!(std::mem::offset_of!(StaticBlock, body) == 0usize);
     assert!(std::mem::offset_of!(StaticBlock, scope_id) == 40usize);
     assert!(size_of::<ModuleDeclaration>() == 16usize);
     assert!(align_of::<ModuleDeclaration>() == 8usize);
     assert!(size_of::<AccessorPropertyType>() == 1usize);
     assert!(align_of::<AccessorPropertyType>() == 1usize);
-    assert!(size_of::<AccessorProperty>() == 88usize);
+    assert!(size_of::<AccessorProperty>() == 80usize);
     assert!(align_of::<AccessorProperty>() == 8usize);
-    assert!(std::mem::offset_of!(AccessorProperty, r#type) == 0usize);
-    assert!(std::mem::offset_of!(AccessorProperty, span) == 4usize);
-    assert!(std::mem::offset_of!(AccessorProperty, decorators) == 16usize);
-    assert!(std::mem::offset_of!(AccessorProperty, key) == 48usize);
-    assert!(std::mem::offset_of!(AccessorProperty, value) == 64usize);
-    assert!(std::mem::offset_of!(AccessorProperty, computed) == 80usize);
-    assert!(std::mem::offset_of!(AccessorProperty, r#static) == 81usize);
+    assert!(std::mem::offset_of!(AccessorProperty, r#type) == 72usize);
+    assert!(std::mem::offset_of!(AccessorProperty, span) == 64usize);
+    assert!(std::mem::offset_of!(AccessorProperty, decorators) == 0usize);
+    assert!(std::mem::offset_of!(AccessorProperty, key) == 32usize);
+    assert!(std::mem::offset_of!(AccessorProperty, value) == 48usize);
+    assert!(std::mem::offset_of!(AccessorProperty, computed) == 73usize);
+    assert!(std::mem::offset_of!(AccessorProperty, r#static) == 74usize);
     assert!(size_of::<ImportExpression>() == 56usize);
     assert!(align_of::<ImportExpression>() == 8usize);
-    assert!(std::mem::offset_of!(ImportExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportExpression, source) == 8usize);
-    assert!(std::mem::offset_of!(ImportExpression, arguments) == 24usize);
+    assert!(std::mem::offset_of!(ImportExpression, span) == 48usize);
+    assert!(std::mem::offset_of!(ImportExpression, source) == 32usize);
+    assert!(std::mem::offset_of!(ImportExpression, arguments) == 0usize);
     assert!(size_of::<ImportDeclaration>() == 136usize);
     assert!(align_of::<ImportDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(ImportDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportDeclaration, specifiers) == 8usize);
-    assert!(std::mem::offset_of!(ImportDeclaration, source) == 40usize);
-    assert!(std::mem::offset_of!(ImportDeclaration, with_clause) == 64usize);
+    assert!(std::mem::offset_of!(ImportDeclaration, span) == 120usize);
+    assert!(std::mem::offset_of!(ImportDeclaration, specifiers) == 64usize);
+    assert!(std::mem::offset_of!(ImportDeclaration, source) == 96usize);
+    assert!(std::mem::offset_of!(ImportDeclaration, with_clause) == 0usize);
     assert!(std::mem::offset_of!(ImportDeclaration, import_kind) == 128usize);
     assert!(size_of::<ImportDeclarationSpecifier>() == 16usize);
     assert!(align_of::<ImportDeclarationSpecifier>() == 8usize);
     assert!(size_of::<ImportSpecifier>() == 88usize);
     assert!(align_of::<ImportSpecifier>() == 8usize);
-    assert!(std::mem::offset_of!(ImportSpecifier, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportSpecifier, imported) == 8usize);
-    assert!(std::mem::offset_of!(ImportSpecifier, local) == 48usize);
+    assert!(std::mem::offset_of!(ImportSpecifier, span) == 72usize);
+    assert!(std::mem::offset_of!(ImportSpecifier, imported) == 0usize);
+    assert!(std::mem::offset_of!(ImportSpecifier, local) == 40usize);
     assert!(std::mem::offset_of!(ImportSpecifier, import_kind) == 80usize);
     assert!(size_of::<ImportDefaultSpecifier>() == 40usize);
     assert!(align_of::<ImportDefaultSpecifier>() == 8usize);
-    assert!(std::mem::offset_of!(ImportDefaultSpecifier, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportDefaultSpecifier, local) == 8usize);
+    assert!(std::mem::offset_of!(ImportDefaultSpecifier, span) == 32usize);
+    assert!(std::mem::offset_of!(ImportDefaultSpecifier, local) == 0usize);
     assert!(size_of::<ImportNamespaceSpecifier>() == 40usize);
     assert!(align_of::<ImportNamespaceSpecifier>() == 8usize);
-    assert!(std::mem::offset_of!(ImportNamespaceSpecifier, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportNamespaceSpecifier, local) == 8usize);
+    assert!(std::mem::offset_of!(ImportNamespaceSpecifier, span) == 32usize);
+    assert!(std::mem::offset_of!(ImportNamespaceSpecifier, local) == 0usize);
     assert!(size_of::<WithClause>() == 64usize);
     assert!(align_of::<WithClause>() == 8usize);
-    assert!(std::mem::offset_of!(WithClause, span) == 0usize);
-    assert!(std::mem::offset_of!(WithClause, attributes_keyword) == 8usize);
-    assert!(std::mem::offset_of!(WithClause, with_entries) == 32usize);
+    assert!(std::mem::offset_of!(WithClause, span) == 56usize);
+    assert!(std::mem::offset_of!(WithClause, attributes_keyword) == 32usize);
+    assert!(std::mem::offset_of!(WithClause, with_entries) == 0usize);
     assert!(size_of::<ImportAttribute>() == 64usize);
     assert!(align_of::<ImportAttribute>() == 8usize);
-    assert!(std::mem::offset_of!(ImportAttribute, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportAttribute, key) == 8usize);
-    assert!(std::mem::offset_of!(ImportAttribute, value) == 40usize);
+    assert!(std::mem::offset_of!(ImportAttribute, span) == 56usize);
+    assert!(std::mem::offset_of!(ImportAttribute, key) == 0usize);
+    assert!(std::mem::offset_of!(ImportAttribute, value) == 32usize);
     assert!(size_of::<ImportAttributeKey>() == 32usize);
     assert!(align_of::<ImportAttributeKey>() == 8usize);
     assert!(size_of::<ExportNamedDeclaration>() == 152usize);
     assert!(align_of::<ExportNamedDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, declaration) == 8usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, specifiers) == 24usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, source) == 56usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, export_kind) == 80usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, with_clause) == 88usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, span) == 136usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, declaration) == 120usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, specifiers) == 64usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, source) == 96usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, export_kind) == 144usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, with_clause) == 0usize);
     assert!(size_of::<ExportDefaultDeclaration>() == 64usize);
     assert!(align_of::<ExportDefaultDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(ExportDefaultDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(ExportDefaultDeclaration, declaration) == 8usize);
-    assert!(std::mem::offset_of!(ExportDefaultDeclaration, exported) == 24usize);
+    assert!(std::mem::offset_of!(ExportDefaultDeclaration, span) == 56usize);
+    assert!(std::mem::offset_of!(ExportDefaultDeclaration, declaration) == 40usize);
+    assert!(std::mem::offset_of!(ExportDefaultDeclaration, exported) == 0usize);
     assert!(size_of::<ExportAllDeclaration>() == 144usize);
     assert!(align_of::<ExportAllDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(ExportAllDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(ExportAllDeclaration, exported) == 8usize);
-    assert!(std::mem::offset_of!(ExportAllDeclaration, source) == 48usize);
-    assert!(std::mem::offset_of!(ExportAllDeclaration, with_clause) == 72usize);
+    assert!(std::mem::offset_of!(ExportAllDeclaration, span) == 128usize);
+    assert!(std::mem::offset_of!(ExportAllDeclaration, exported) == 64usize);
+    assert!(std::mem::offset_of!(ExportAllDeclaration, source) == 104usize);
+    assert!(std::mem::offset_of!(ExportAllDeclaration, with_clause) == 0usize);
     assert!(std::mem::offset_of!(ExportAllDeclaration, export_kind) == 136usize);
     assert!(size_of::<ExportSpecifier>() == 96usize);
     assert!(align_of::<ExportSpecifier>() == 8usize);
-    assert!(std::mem::offset_of!(ExportSpecifier, span) == 0usize);
-    assert!(std::mem::offset_of!(ExportSpecifier, local) == 8usize);
-    assert!(std::mem::offset_of!(ExportSpecifier, exported) == 48usize);
+    assert!(std::mem::offset_of!(ExportSpecifier, span) == 80usize);
+    assert!(std::mem::offset_of!(ExportSpecifier, local) == 0usize);
+    assert!(std::mem::offset_of!(ExportSpecifier, exported) == 40usize);
     assert!(std::mem::offset_of!(ExportSpecifier, export_kind) == 88usize);
     assert!(size_of::<ExportDefaultDeclarationKind>() == 16usize);
     assert!(align_of::<ExportDefaultDeclarationKind>() == 8usize);
@@ -647,90 +647,90 @@ const _: () = {
     assert!(align_of::<ModuleExportName>() == 8usize);
     assert!(size_of::<TSThisParameter>() == 40usize);
     assert!(align_of::<TSThisParameter>() == 8usize);
-    assert!(std::mem::offset_of!(TSThisParameter, span) == 0usize);
-    assert!(std::mem::offset_of!(TSThisParameter, this) == 8usize);
+    assert!(std::mem::offset_of!(TSThisParameter, span) == 24usize);
+    assert!(std::mem::offset_of!(TSThisParameter, this) == 0usize);
     assert!(std::mem::offset_of!(TSThisParameter, type_annotation) == 32usize);
     assert!(size_of::<TSEnumDeclaration>() == 80usize);
     assert!(align_of::<TSEnumDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, members) == 40usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, r#const) == 72usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, declare) == 73usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, scope_id) == 76usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, span) == 64usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, members) == 32usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, r#const) == 76usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, declare) == 77usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, scope_id) == 72usize);
     assert!(size_of::<TSEnumMember>() == 40usize);
     assert!(align_of::<TSEnumMember>() == 8usize);
-    assert!(std::mem::offset_of!(TSEnumMember, span) == 0usize);
-    assert!(std::mem::offset_of!(TSEnumMember, id) == 8usize);
-    assert!(std::mem::offset_of!(TSEnumMember, initializer) == 24usize);
+    assert!(std::mem::offset_of!(TSEnumMember, span) == 32usize);
+    assert!(std::mem::offset_of!(TSEnumMember, id) == 0usize);
+    assert!(std::mem::offset_of!(TSEnumMember, initializer) == 16usize);
     assert!(size_of::<TSEnumMemberName>() == 16usize);
     assert!(align_of::<TSEnumMemberName>() == 8usize);
     assert!(size_of::<TSTypeAnnotation>() == 24usize);
     assert!(align_of::<TSTypeAnnotation>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeAnnotation, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeAnnotation, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeAnnotation, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeAnnotation, type_annotation) == 0usize);
     assert!(size_of::<TSLiteralType>() == 24usize);
     assert!(align_of::<TSLiteralType>() == 8usize);
-    assert!(std::mem::offset_of!(TSLiteralType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSLiteralType, literal) == 8usize);
+    assert!(std::mem::offset_of!(TSLiteralType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSLiteralType, literal) == 0usize);
     assert!(size_of::<TSLiteral>() == 16usize);
     assert!(align_of::<TSLiteral>() == 8usize);
     assert!(size_of::<TSType>() == 16usize);
     assert!(align_of::<TSType>() == 8usize);
     assert!(size_of::<TSConditionalType>() == 80usize);
     assert!(align_of::<TSConditionalType>() == 8usize);
-    assert!(std::mem::offset_of!(TSConditionalType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSConditionalType, check_type) == 8usize);
-    assert!(std::mem::offset_of!(TSConditionalType, extends_type) == 24usize);
-    assert!(std::mem::offset_of!(TSConditionalType, true_type) == 40usize);
-    assert!(std::mem::offset_of!(TSConditionalType, false_type) == 56usize);
+    assert!(std::mem::offset_of!(TSConditionalType, span) == 64usize);
+    assert!(std::mem::offset_of!(TSConditionalType, check_type) == 0usize);
+    assert!(std::mem::offset_of!(TSConditionalType, extends_type) == 16usize);
+    assert!(std::mem::offset_of!(TSConditionalType, true_type) == 32usize);
+    assert!(std::mem::offset_of!(TSConditionalType, false_type) == 48usize);
     assert!(std::mem::offset_of!(TSConditionalType, scope_id) == 72usize);
     assert!(size_of::<TSUnionType>() == 40usize);
     assert!(align_of::<TSUnionType>() == 8usize);
-    assert!(std::mem::offset_of!(TSUnionType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSUnionType, types) == 8usize);
+    assert!(std::mem::offset_of!(TSUnionType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSUnionType, types) == 0usize);
     assert!(size_of::<TSIntersectionType>() == 40usize);
     assert!(align_of::<TSIntersectionType>() == 8usize);
-    assert!(std::mem::offset_of!(TSIntersectionType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSIntersectionType, types) == 8usize);
+    assert!(std::mem::offset_of!(TSIntersectionType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSIntersectionType, types) == 0usize);
     assert!(size_of::<TSParenthesizedType>() == 24usize);
     assert!(align_of::<TSParenthesizedType>() == 8usize);
-    assert!(std::mem::offset_of!(TSParenthesizedType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSParenthesizedType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(TSParenthesizedType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSParenthesizedType, type_annotation) == 0usize);
     assert!(size_of::<TSTypeOperator>() == 32usize);
     assert!(align_of::<TSTypeOperator>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeOperator, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeOperator, operator) == 8usize);
-    assert!(std::mem::offset_of!(TSTypeOperator, type_annotation) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeOperator, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeOperator, operator) == 24usize);
+    assert!(std::mem::offset_of!(TSTypeOperator, type_annotation) == 0usize);
     assert!(size_of::<TSTypeOperatorOperator>() == 1usize);
     assert!(align_of::<TSTypeOperatorOperator>() == 1usize);
     assert!(size_of::<TSArrayType>() == 24usize);
     assert!(align_of::<TSArrayType>() == 8usize);
-    assert!(std::mem::offset_of!(TSArrayType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSArrayType, element_type) == 8usize);
+    assert!(std::mem::offset_of!(TSArrayType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSArrayType, element_type) == 0usize);
     assert!(size_of::<TSIndexedAccessType>() == 40usize);
     assert!(align_of::<TSIndexedAccessType>() == 8usize);
-    assert!(std::mem::offset_of!(TSIndexedAccessType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSIndexedAccessType, object_type) == 8usize);
-    assert!(std::mem::offset_of!(TSIndexedAccessType, index_type) == 24usize);
+    assert!(std::mem::offset_of!(TSIndexedAccessType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSIndexedAccessType, object_type) == 0usize);
+    assert!(std::mem::offset_of!(TSIndexedAccessType, index_type) == 16usize);
     assert!(size_of::<TSTupleType>() == 40usize);
     assert!(align_of::<TSTupleType>() == 8usize);
-    assert!(std::mem::offset_of!(TSTupleType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTupleType, element_types) == 8usize);
+    assert!(std::mem::offset_of!(TSTupleType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTupleType, element_types) == 0usize);
     assert!(size_of::<TSNamedTupleMember>() == 56usize);
     assert!(align_of::<TSNamedTupleMember>() == 8usize);
-    assert!(std::mem::offset_of!(TSNamedTupleMember, span) == 0usize);
-    assert!(std::mem::offset_of!(TSNamedTupleMember, element_type) == 8usize);
-    assert!(std::mem::offset_of!(TSNamedTupleMember, label) == 24usize);
+    assert!(std::mem::offset_of!(TSNamedTupleMember, span) == 40usize);
+    assert!(std::mem::offset_of!(TSNamedTupleMember, element_type) == 24usize);
+    assert!(std::mem::offset_of!(TSNamedTupleMember, label) == 0usize);
     assert!(std::mem::offset_of!(TSNamedTupleMember, optional) == 48usize);
     assert!(size_of::<TSOptionalType>() == 24usize);
     assert!(align_of::<TSOptionalType>() == 8usize);
-    assert!(std::mem::offset_of!(TSOptionalType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSOptionalType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(TSOptionalType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSOptionalType, type_annotation) == 0usize);
     assert!(size_of::<TSRestType>() == 24usize);
     assert!(align_of::<TSRestType>() == 8usize);
-    assert!(std::mem::offset_of!(TSRestType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSRestType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(TSRestType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSRestType, type_annotation) == 0usize);
     assert!(size_of::<TSTupleElement>() == 16usize);
     assert!(align_of::<TSTupleElement>() == 8usize);
     assert!(size_of::<TSAnyKeyword>() == 8usize);
@@ -777,98 +777,98 @@ const _: () = {
     assert!(std::mem::offset_of!(TSBigIntKeyword, span) == 0usize);
     assert!(size_of::<TSTypeReference>() == 32usize);
     assert!(align_of::<TSTypeReference>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeReference, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeReference, type_name) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeReference, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeReference, type_name) == 0usize);
     assert!(std::mem::offset_of!(TSTypeReference, type_parameters) == 24usize);
     assert!(size_of::<TSTypeName>() == 16usize);
     assert!(align_of::<TSTypeName>() == 8usize);
     assert!(size_of::<TSQualifiedName>() == 48usize);
     assert!(align_of::<TSQualifiedName>() == 8usize);
-    assert!(std::mem::offset_of!(TSQualifiedName, span) == 0usize);
-    assert!(std::mem::offset_of!(TSQualifiedName, left) == 8usize);
-    assert!(std::mem::offset_of!(TSQualifiedName, right) == 24usize);
+    assert!(std::mem::offset_of!(TSQualifiedName, span) == 40usize);
+    assert!(std::mem::offset_of!(TSQualifiedName, left) == 24usize);
+    assert!(std::mem::offset_of!(TSQualifiedName, right) == 0usize);
     assert!(size_of::<TSTypeParameterInstantiation>() == 40usize);
     assert!(align_of::<TSTypeParameterInstantiation>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeParameterInstantiation, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeParameterInstantiation, params) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeParameterInstantiation, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeParameterInstantiation, params) == 0usize);
     assert!(size_of::<TSTypeParameter>() == 80usize);
     assert!(align_of::<TSTypeParameter>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeParameter, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeParameter, name) == 8usize);
-    assert!(std::mem::offset_of!(TSTypeParameter, constraint) == 40usize);
-    assert!(std::mem::offset_of!(TSTypeParameter, default) == 56usize);
+    assert!(std::mem::offset_of!(TSTypeParameter, span) == 64usize);
+    assert!(std::mem::offset_of!(TSTypeParameter, name) == 0usize);
+    assert!(std::mem::offset_of!(TSTypeParameter, constraint) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeParameter, default) == 48usize);
     assert!(std::mem::offset_of!(TSTypeParameter, r#in) == 72usize);
     assert!(std::mem::offset_of!(TSTypeParameter, out) == 73usize);
     assert!(std::mem::offset_of!(TSTypeParameter, r#const) == 74usize);
     assert!(size_of::<TSTypeParameterDeclaration>() == 40usize);
     assert!(align_of::<TSTypeParameterDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeParameterDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeParameterDeclaration, params) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeParameterDeclaration, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeParameterDeclaration, params) == 0usize);
     assert!(size_of::<TSTypeAliasDeclaration>() == 72usize);
     assert!(align_of::<TSTypeAliasDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, type_parameters) == 40usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, type_annotation) == 48usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, declare) == 64usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, scope_id) == 68usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, span) == 48usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, type_parameters) == 56usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, type_annotation) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, declare) == 68usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, scope_id) == 64usize);
     assert!(size_of::<TSAccessibility>() == 1usize);
     assert!(align_of::<TSAccessibility>() == 1usize);
     assert!(size_of::<TSClassImplements>() == 32usize);
     assert!(align_of::<TSClassImplements>() == 8usize);
-    assert!(std::mem::offset_of!(TSClassImplements, span) == 0usize);
-    assert!(std::mem::offset_of!(TSClassImplements, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSClassImplements, span) == 16usize);
+    assert!(std::mem::offset_of!(TSClassImplements, expression) == 0usize);
     assert!(std::mem::offset_of!(TSClassImplements, type_parameters) == 24usize);
     assert!(size_of::<TSInterfaceDeclaration>() == 96usize);
     assert!(align_of::<TSInterfaceDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, extends) == 40usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, span) == 64usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, extends) == 32usize);
     assert!(std::mem::offset_of!(TSInterfaceDeclaration, type_parameters) == 72usize);
     assert!(std::mem::offset_of!(TSInterfaceDeclaration, body) == 80usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, declare) == 88usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, scope_id) == 92usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, declare) == 92usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, scope_id) == 88usize);
     assert!(size_of::<TSInterfaceBody>() == 40usize);
     assert!(align_of::<TSInterfaceBody>() == 8usize);
-    assert!(std::mem::offset_of!(TSInterfaceBody, span) == 0usize);
-    assert!(std::mem::offset_of!(TSInterfaceBody, body) == 8usize);
+    assert!(std::mem::offset_of!(TSInterfaceBody, span) == 32usize);
+    assert!(std::mem::offset_of!(TSInterfaceBody, body) == 0usize);
     assert!(size_of::<TSPropertySignature>() == 40usize);
     assert!(align_of::<TSPropertySignature>() == 8usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, span) == 0usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, computed) == 8usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, optional) == 9usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, readonly) == 10usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, key) == 16usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, type_annotation) == 32usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, span) == 16usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, computed) == 32usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, optional) == 33usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, readonly) == 34usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, key) == 0usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, type_annotation) == 24usize);
     assert!(size_of::<TSSignature>() == 16usize);
     assert!(align_of::<TSSignature>() == 8usize);
     assert!(size_of::<TSIndexSignature>() == 56usize);
     assert!(align_of::<TSIndexSignature>() == 8usize);
-    assert!(std::mem::offset_of!(TSIndexSignature, span) == 0usize);
-    assert!(std::mem::offset_of!(TSIndexSignature, parameters) == 8usize);
+    assert!(std::mem::offset_of!(TSIndexSignature, span) == 32usize);
+    assert!(std::mem::offset_of!(TSIndexSignature, parameters) == 0usize);
     assert!(std::mem::offset_of!(TSIndexSignature, type_annotation) == 40usize);
     assert!(std::mem::offset_of!(TSIndexSignature, readonly) == 48usize);
     assert!(size_of::<TSCallSignatureDeclaration>() == 72usize);
     assert!(align_of::<TSCallSignatureDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(TSCallSignatureDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSCallSignatureDeclaration, this_param) == 8usize);
+    assert!(std::mem::offset_of!(TSCallSignatureDeclaration, span) == 40usize);
+    assert!(std::mem::offset_of!(TSCallSignatureDeclaration, this_param) == 0usize);
     assert!(std::mem::offset_of!(TSCallSignatureDeclaration, params) == 48usize);
     assert!(std::mem::offset_of!(TSCallSignatureDeclaration, return_type) == 56usize);
     assert!(std::mem::offset_of!(TSCallSignatureDeclaration, type_parameters) == 64usize);
     assert!(size_of::<TSMethodSignatureKind>() == 1usize);
     assert!(align_of::<TSMethodSignatureKind>() == 1usize);
-    assert!(size_of::<TSMethodSignature>() == 104usize);
+    assert!(size_of::<TSMethodSignature>() == 96usize);
     assert!(align_of::<TSMethodSignature>() == 8usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, span) == 0usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, key) == 8usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, computed) == 24usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, optional) == 25usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, kind) == 26usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, this_param) == 32usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, params) == 72usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, return_type) == 80usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, type_parameters) == 88usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, scope_id) == 96usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, span) == 56usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, key) == 40usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, computed) == 92usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, optional) == 93usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, kind) == 94usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, this_param) == 0usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, params) == 64usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, return_type) == 72usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, type_parameters) == 80usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, scope_id) == 88usize);
     assert!(size_of::<TSConstructSignatureDeclaration>() == 40usize);
     assert!(align_of::<TSConstructSignatureDeclaration>() == 8usize);
     assert!(std::mem::offset_of!(TSConstructSignatureDeclaration, span) == 0usize);
@@ -878,30 +878,30 @@ const _: () = {
     assert!(std::mem::offset_of!(TSConstructSignatureDeclaration, scope_id) == 32usize);
     assert!(size_of::<TSIndexSignatureName>() == 32usize);
     assert!(align_of::<TSIndexSignatureName>() == 8usize);
-    assert!(std::mem::offset_of!(TSIndexSignatureName, span) == 0usize);
-    assert!(std::mem::offset_of!(TSIndexSignatureName, name) == 8usize);
+    assert!(std::mem::offset_of!(TSIndexSignatureName, span) == 16usize);
+    assert!(std::mem::offset_of!(TSIndexSignatureName, name) == 0usize);
     assert!(std::mem::offset_of!(TSIndexSignatureName, type_annotation) == 24usize);
     assert!(size_of::<TSInterfaceHeritage>() == 32usize);
     assert!(align_of::<TSInterfaceHeritage>() == 8usize);
-    assert!(std::mem::offset_of!(TSInterfaceHeritage, span) == 0usize);
-    assert!(std::mem::offset_of!(TSInterfaceHeritage, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSInterfaceHeritage, span) == 16usize);
+    assert!(std::mem::offset_of!(TSInterfaceHeritage, expression) == 0usize);
     assert!(std::mem::offset_of!(TSInterfaceHeritage, type_parameters) == 24usize);
     assert!(size_of::<TSTypePredicate>() == 40usize);
     assert!(align_of::<TSTypePredicate>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypePredicate, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypePredicate, parameter_name) == 8usize);
-    assert!(std::mem::offset_of!(TSTypePredicate, asserts) == 24usize);
-    assert!(std::mem::offset_of!(TSTypePredicate, type_annotation) == 32usize);
+    assert!(std::mem::offset_of!(TSTypePredicate, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypePredicate, parameter_name) == 0usize);
+    assert!(std::mem::offset_of!(TSTypePredicate, asserts) == 32usize);
+    assert!(std::mem::offset_of!(TSTypePredicate, type_annotation) == 24usize);
     assert!(size_of::<TSTypePredicateName>() == 16usize);
     assert!(align_of::<TSTypePredicateName>() == 8usize);
     assert!(size_of::<TSModuleDeclaration>() == 64usize);
     assert!(align_of::<TSModuleDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, body) == 40usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, kind) == 56usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, declare) == 57usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, scope_id) == 60usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, span) == 48usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, body) == 32usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, kind) == 60usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, declare) == 61usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, scope_id) == 56usize);
     assert!(size_of::<TSModuleDeclarationKind>() == 1usize);
     assert!(align_of::<TSModuleDeclarationKind>() == 1usize);
     assert!(size_of::<TSModuleDeclarationName>() == 32usize);
@@ -910,159 +910,159 @@ const _: () = {
     assert!(align_of::<TSModuleDeclarationBody>() == 8usize);
     assert!(size_of::<TSModuleBlock>() == 72usize);
     assert!(align_of::<TSModuleBlock>() == 8usize);
-    assert!(std::mem::offset_of!(TSModuleBlock, span) == 0usize);
-    assert!(std::mem::offset_of!(TSModuleBlock, directives) == 8usize);
-    assert!(std::mem::offset_of!(TSModuleBlock, body) == 40usize);
+    assert!(std::mem::offset_of!(TSModuleBlock, span) == 64usize);
+    assert!(std::mem::offset_of!(TSModuleBlock, directives) == 0usize);
+    assert!(std::mem::offset_of!(TSModuleBlock, body) == 32usize);
     assert!(size_of::<TSTypeLiteral>() == 40usize);
     assert!(align_of::<TSTypeLiteral>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeLiteral, members) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeLiteral, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeLiteral, members) == 0usize);
     assert!(size_of::<TSInferType>() == 16usize);
     assert!(align_of::<TSInferType>() == 8usize);
     assert!(std::mem::offset_of!(TSInferType, span) == 0usize);
     assert!(std::mem::offset_of!(TSInferType, type_parameter) == 8usize);
     assert!(size_of::<TSTypeQuery>() == 32usize);
     assert!(align_of::<TSTypeQuery>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeQuery, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeQuery, expr_name) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeQuery, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeQuery, expr_name) == 0usize);
     assert!(std::mem::offset_of!(TSTypeQuery, type_parameters) == 24usize);
     assert!(size_of::<TSTypeQueryExprName>() == 16usize);
     assert!(align_of::<TSTypeQueryExprName>() == 8usize);
     assert!(size_of::<TSImportType>() == 96usize);
     assert!(align_of::<TSImportType>() == 8usize);
-    assert!(std::mem::offset_of!(TSImportType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSImportType, is_type_of) == 8usize);
-    assert!(std::mem::offset_of!(TSImportType, parameter) == 16usize);
-    assert!(std::mem::offset_of!(TSImportType, qualifier) == 32usize);
-    assert!(std::mem::offset_of!(TSImportType, attributes) == 48usize);
-    assert!(std::mem::offset_of!(TSImportType, type_parameters) == 88usize);
+    assert!(std::mem::offset_of!(TSImportType, span) == 72usize);
+    assert!(std::mem::offset_of!(TSImportType, is_type_of) == 88usize);
+    assert!(std::mem::offset_of!(TSImportType, parameter) == 40usize);
+    assert!(std::mem::offset_of!(TSImportType, qualifier) == 56usize);
+    assert!(std::mem::offset_of!(TSImportType, attributes) == 0usize);
+    assert!(std::mem::offset_of!(TSImportType, type_parameters) == 80usize);
     assert!(size_of::<TSImportAttributes>() == 40usize);
     assert!(align_of::<TSImportAttributes>() == 8usize);
-    assert!(std::mem::offset_of!(TSImportAttributes, span) == 0usize);
-    assert!(std::mem::offset_of!(TSImportAttributes, elements) == 8usize);
+    assert!(std::mem::offset_of!(TSImportAttributes, span) == 32usize);
+    assert!(std::mem::offset_of!(TSImportAttributes, elements) == 0usize);
     assert!(size_of::<TSImportAttribute>() == 56usize);
     assert!(align_of::<TSImportAttribute>() == 8usize);
-    assert!(std::mem::offset_of!(TSImportAttribute, span) == 0usize);
-    assert!(std::mem::offset_of!(TSImportAttribute, name) == 8usize);
-    assert!(std::mem::offset_of!(TSImportAttribute, value) == 40usize);
+    assert!(std::mem::offset_of!(TSImportAttribute, span) == 48usize);
+    assert!(std::mem::offset_of!(TSImportAttribute, name) == 0usize);
+    assert!(std::mem::offset_of!(TSImportAttribute, value) == 32usize);
     assert!(size_of::<TSImportAttributeName>() == 32usize);
     assert!(align_of::<TSImportAttributeName>() == 8usize);
     assert!(size_of::<TSFunctionType>() == 72usize);
     assert!(align_of::<TSFunctionType>() == 8usize);
-    assert!(std::mem::offset_of!(TSFunctionType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSFunctionType, this_param) == 8usize);
+    assert!(std::mem::offset_of!(TSFunctionType, span) == 40usize);
+    assert!(std::mem::offset_of!(TSFunctionType, this_param) == 0usize);
     assert!(std::mem::offset_of!(TSFunctionType, params) == 48usize);
     assert!(std::mem::offset_of!(TSFunctionType, return_type) == 56usize);
     assert!(std::mem::offset_of!(TSFunctionType, type_parameters) == 64usize);
     assert!(size_of::<TSConstructorType>() == 40usize);
     assert!(align_of::<TSConstructorType>() == 8usize);
     assert!(std::mem::offset_of!(TSConstructorType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSConstructorType, r#abstract) == 8usize);
-    assert!(std::mem::offset_of!(TSConstructorType, params) == 16usize);
-    assert!(std::mem::offset_of!(TSConstructorType, return_type) == 24usize);
-    assert!(std::mem::offset_of!(TSConstructorType, type_parameters) == 32usize);
+    assert!(std::mem::offset_of!(TSConstructorType, r#abstract) == 32usize);
+    assert!(std::mem::offset_of!(TSConstructorType, params) == 8usize);
+    assert!(std::mem::offset_of!(TSConstructorType, return_type) == 16usize);
+    assert!(std::mem::offset_of!(TSConstructorType, type_parameters) == 24usize);
     assert!(size_of::<TSMappedType>() == 56usize);
     assert!(align_of::<TSMappedType>() == 8usize);
-    assert!(std::mem::offset_of!(TSMappedType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSMappedType, type_parameter) == 8usize);
-    assert!(std::mem::offset_of!(TSMappedType, name_type) == 16usize);
-    assert!(std::mem::offset_of!(TSMappedType, type_annotation) == 32usize);
-    assert!(std::mem::offset_of!(TSMappedType, optional) == 48usize);
-    assert!(std::mem::offset_of!(TSMappedType, readonly) == 49usize);
-    assert!(std::mem::offset_of!(TSMappedType, scope_id) == 52usize);
+    assert!(std::mem::offset_of!(TSMappedType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSMappedType, type_parameter) == 40usize);
+    assert!(std::mem::offset_of!(TSMappedType, name_type) == 0usize);
+    assert!(std::mem::offset_of!(TSMappedType, type_annotation) == 16usize);
+    assert!(std::mem::offset_of!(TSMappedType, optional) == 52usize);
+    assert!(std::mem::offset_of!(TSMappedType, readonly) == 53usize);
+    assert!(std::mem::offset_of!(TSMappedType, scope_id) == 48usize);
     assert!(size_of::<TSMappedTypeModifierOperator>() == 1usize);
     assert!(align_of::<TSMappedTypeModifierOperator>() == 1usize);
     assert!(size_of::<TSTemplateLiteralType>() == 72usize);
     assert!(align_of::<TSTemplateLiteralType>() == 8usize);
-    assert!(std::mem::offset_of!(TSTemplateLiteralType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTemplateLiteralType, quasis) == 8usize);
-    assert!(std::mem::offset_of!(TSTemplateLiteralType, types) == 40usize);
+    assert!(std::mem::offset_of!(TSTemplateLiteralType, span) == 64usize);
+    assert!(std::mem::offset_of!(TSTemplateLiteralType, quasis) == 0usize);
+    assert!(std::mem::offset_of!(TSTemplateLiteralType, types) == 32usize);
     assert!(size_of::<TSAsExpression>() == 40usize);
     assert!(align_of::<TSAsExpression>() == 8usize);
-    assert!(std::mem::offset_of!(TSAsExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TSAsExpression, expression) == 8usize);
-    assert!(std::mem::offset_of!(TSAsExpression, type_annotation) == 24usize);
+    assert!(std::mem::offset_of!(TSAsExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(TSAsExpression, expression) == 0usize);
+    assert!(std::mem::offset_of!(TSAsExpression, type_annotation) == 16usize);
     assert!(size_of::<TSSatisfiesExpression>() == 40usize);
     assert!(align_of::<TSSatisfiesExpression>() == 8usize);
-    assert!(std::mem::offset_of!(TSSatisfiesExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TSSatisfiesExpression, expression) == 8usize);
-    assert!(std::mem::offset_of!(TSSatisfiesExpression, type_annotation) == 24usize);
+    assert!(std::mem::offset_of!(TSSatisfiesExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(TSSatisfiesExpression, expression) == 0usize);
+    assert!(std::mem::offset_of!(TSSatisfiesExpression, type_annotation) == 16usize);
     assert!(size_of::<TSTypeAssertion>() == 40usize);
     assert!(align_of::<TSTypeAssertion>() == 8usize);
-    assert!(std::mem::offset_of!(TSTypeAssertion, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeAssertion, expression) == 8usize);
-    assert!(std::mem::offset_of!(TSTypeAssertion, type_annotation) == 24usize);
+    assert!(std::mem::offset_of!(TSTypeAssertion, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeAssertion, expression) == 0usize);
+    assert!(std::mem::offset_of!(TSTypeAssertion, type_annotation) == 16usize);
     assert!(size_of::<TSImportEqualsDeclaration>() == 64usize);
     assert!(align_of::<TSImportEqualsDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, module_reference) == 40usize);
+    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, span) == 48usize);
+    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, module_reference) == 32usize);
     assert!(std::mem::offset_of!(TSImportEqualsDeclaration, import_kind) == 56usize);
     assert!(size_of::<TSModuleReference>() == 16usize);
     assert!(align_of::<TSModuleReference>() == 8usize);
     assert!(size_of::<TSExternalModuleReference>() == 32usize);
     assert!(align_of::<TSExternalModuleReference>() == 8usize);
-    assert!(std::mem::offset_of!(TSExternalModuleReference, span) == 0usize);
-    assert!(std::mem::offset_of!(TSExternalModuleReference, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSExternalModuleReference, span) == 24usize);
+    assert!(std::mem::offset_of!(TSExternalModuleReference, expression) == 0usize);
     assert!(size_of::<TSNonNullExpression>() == 24usize);
     assert!(align_of::<TSNonNullExpression>() == 8usize);
-    assert!(std::mem::offset_of!(TSNonNullExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TSNonNullExpression, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSNonNullExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(TSNonNullExpression, expression) == 0usize);
     assert!(size_of::<Decorator>() == 24usize);
     assert!(align_of::<Decorator>() == 8usize);
-    assert!(std::mem::offset_of!(Decorator, span) == 0usize);
-    assert!(std::mem::offset_of!(Decorator, expression) == 8usize);
+    assert!(std::mem::offset_of!(Decorator, span) == 16usize);
+    assert!(std::mem::offset_of!(Decorator, expression) == 0usize);
     assert!(size_of::<TSExportAssignment>() == 24usize);
     assert!(align_of::<TSExportAssignment>() == 8usize);
-    assert!(std::mem::offset_of!(TSExportAssignment, span) == 0usize);
-    assert!(std::mem::offset_of!(TSExportAssignment, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSExportAssignment, span) == 16usize);
+    assert!(std::mem::offset_of!(TSExportAssignment, expression) == 0usize);
     assert!(size_of::<TSNamespaceExportDeclaration>() == 32usize);
     assert!(align_of::<TSNamespaceExportDeclaration>() == 8usize);
-    assert!(std::mem::offset_of!(TSNamespaceExportDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSNamespaceExportDeclaration, id) == 8usize);
+    assert!(std::mem::offset_of!(TSNamespaceExportDeclaration, span) == 24usize);
+    assert!(std::mem::offset_of!(TSNamespaceExportDeclaration, id) == 0usize);
     assert!(size_of::<TSInstantiationExpression>() == 32usize);
     assert!(align_of::<TSInstantiationExpression>() == 8usize);
-    assert!(std::mem::offset_of!(TSInstantiationExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TSInstantiationExpression, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSInstantiationExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(TSInstantiationExpression, expression) == 0usize);
     assert!(std::mem::offset_of!(TSInstantiationExpression, type_parameters) == 24usize);
     assert!(size_of::<ImportOrExportKind>() == 1usize);
     assert!(align_of::<ImportOrExportKind>() == 1usize);
     assert!(size_of::<JSDocNullableType>() == 32usize);
     assert!(align_of::<JSDocNullableType>() == 8usize);
-    assert!(std::mem::offset_of!(JSDocNullableType, span) == 0usize);
-    assert!(std::mem::offset_of!(JSDocNullableType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(JSDocNullableType, span) == 16usize);
+    assert!(std::mem::offset_of!(JSDocNullableType, type_annotation) == 0usize);
     assert!(std::mem::offset_of!(JSDocNullableType, postfix) == 24usize);
     assert!(size_of::<JSDocNonNullableType>() == 32usize);
     assert!(align_of::<JSDocNonNullableType>() == 8usize);
-    assert!(std::mem::offset_of!(JSDocNonNullableType, span) == 0usize);
-    assert!(std::mem::offset_of!(JSDocNonNullableType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(JSDocNonNullableType, span) == 16usize);
+    assert!(std::mem::offset_of!(JSDocNonNullableType, type_annotation) == 0usize);
     assert!(std::mem::offset_of!(JSDocNonNullableType, postfix) == 24usize);
     assert!(size_of::<JSDocUnknownType>() == 8usize);
     assert!(align_of::<JSDocUnknownType>() == 4usize);
     assert!(std::mem::offset_of!(JSDocUnknownType, span) == 0usize);
     assert!(size_of::<JSXElement>() == 56usize);
     assert!(align_of::<JSXElement>() == 8usize);
-    assert!(std::mem::offset_of!(JSXElement, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXElement, opening_element) == 8usize);
-    assert!(std::mem::offset_of!(JSXElement, closing_element) == 16usize);
-    assert!(std::mem::offset_of!(JSXElement, children) == 24usize);
+    assert!(std::mem::offset_of!(JSXElement, span) == 32usize);
+    assert!(std::mem::offset_of!(JSXElement, opening_element) == 40usize);
+    assert!(std::mem::offset_of!(JSXElement, closing_element) == 48usize);
+    assert!(std::mem::offset_of!(JSXElement, children) == 0usize);
     assert!(size_of::<JSXOpeningElement>() == 72usize);
     assert!(align_of::<JSXOpeningElement>() == 8usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, self_closing) == 8usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, name) == 16usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, attributes) == 32usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, type_parameters) == 64usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, span) == 48usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, self_closing) == 64usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, name) == 32usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, attributes) == 0usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, type_parameters) == 56usize);
     assert!(size_of::<JSXClosingElement>() == 24usize);
     assert!(align_of::<JSXClosingElement>() == 8usize);
-    assert!(std::mem::offset_of!(JSXClosingElement, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXClosingElement, name) == 8usize);
+    assert!(std::mem::offset_of!(JSXClosingElement, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXClosingElement, name) == 0usize);
     assert!(size_of::<JSXFragment>() == 56usize);
     assert!(align_of::<JSXFragment>() == 8usize);
-    assert!(std::mem::offset_of!(JSXFragment, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXFragment, opening_fragment) == 8usize);
-    assert!(std::mem::offset_of!(JSXFragment, closing_fragment) == 16usize);
-    assert!(std::mem::offset_of!(JSXFragment, children) == 24usize);
+    assert!(std::mem::offset_of!(JSXFragment, span) == 32usize);
+    assert!(std::mem::offset_of!(JSXFragment, opening_fragment) == 40usize);
+    assert!(std::mem::offset_of!(JSXFragment, closing_fragment) == 48usize);
+    assert!(std::mem::offset_of!(JSXFragment, children) == 0usize);
     assert!(size_of::<JSXOpeningFragment>() == 8usize);
     assert!(align_of::<JSXOpeningFragment>() == 4usize);
     assert!(std::mem::offset_of!(JSXOpeningFragment, span) == 0usize);
@@ -1073,20 +1073,20 @@ const _: () = {
     assert!(align_of::<JSXElementName>() == 8usize);
     assert!(size_of::<JSXNamespacedName>() == 56usize);
     assert!(align_of::<JSXNamespacedName>() == 8usize);
-    assert!(std::mem::offset_of!(JSXNamespacedName, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXNamespacedName, namespace) == 8usize);
-    assert!(std::mem::offset_of!(JSXNamespacedName, property) == 32usize);
+    assert!(std::mem::offset_of!(JSXNamespacedName, span) == 48usize);
+    assert!(std::mem::offset_of!(JSXNamespacedName, namespace) == 0usize);
+    assert!(std::mem::offset_of!(JSXNamespacedName, property) == 24usize);
     assert!(size_of::<JSXMemberExpression>() == 48usize);
     assert!(align_of::<JSXMemberExpression>() == 8usize);
-    assert!(std::mem::offset_of!(JSXMemberExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXMemberExpression, object) == 8usize);
-    assert!(std::mem::offset_of!(JSXMemberExpression, property) == 24usize);
+    assert!(std::mem::offset_of!(JSXMemberExpression, span) == 40usize);
+    assert!(std::mem::offset_of!(JSXMemberExpression, object) == 24usize);
+    assert!(std::mem::offset_of!(JSXMemberExpression, property) == 0usize);
     assert!(size_of::<JSXMemberExpressionObject>() == 16usize);
     assert!(align_of::<JSXMemberExpressionObject>() == 8usize);
     assert!(size_of::<JSXExpressionContainer>() == 24usize);
     assert!(align_of::<JSXExpressionContainer>() == 8usize);
-    assert!(std::mem::offset_of!(JSXExpressionContainer, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXExpressionContainer, expression) == 8usize);
+    assert!(std::mem::offset_of!(JSXExpressionContainer, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXExpressionContainer, expression) == 0usize);
     assert!(size_of::<JSXExpression>() == 16usize);
     assert!(align_of::<JSXExpression>() == 8usize);
     assert!(size_of::<JSXEmptyExpression>() == 8usize);
@@ -1096,31 +1096,31 @@ const _: () = {
     assert!(align_of::<JSXAttributeItem>() == 8usize);
     assert!(size_of::<JSXAttribute>() == 40usize);
     assert!(align_of::<JSXAttribute>() == 8usize);
-    assert!(std::mem::offset_of!(JSXAttribute, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXAttribute, name) == 8usize);
-    assert!(std::mem::offset_of!(JSXAttribute, value) == 24usize);
+    assert!(std::mem::offset_of!(JSXAttribute, span) == 32usize);
+    assert!(std::mem::offset_of!(JSXAttribute, name) == 0usize);
+    assert!(std::mem::offset_of!(JSXAttribute, value) == 16usize);
     assert!(size_of::<JSXSpreadAttribute>() == 24usize);
     assert!(align_of::<JSXSpreadAttribute>() == 8usize);
-    assert!(std::mem::offset_of!(JSXSpreadAttribute, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXSpreadAttribute, argument) == 8usize);
+    assert!(std::mem::offset_of!(JSXSpreadAttribute, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXSpreadAttribute, argument) == 0usize);
     assert!(size_of::<JSXAttributeName>() == 16usize);
     assert!(align_of::<JSXAttributeName>() == 8usize);
     assert!(size_of::<JSXAttributeValue>() == 16usize);
     assert!(align_of::<JSXAttributeValue>() == 8usize);
     assert!(size_of::<JSXIdentifier>() == 24usize);
     assert!(align_of::<JSXIdentifier>() == 8usize);
-    assert!(std::mem::offset_of!(JSXIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXIdentifier, name) == 8usize);
+    assert!(std::mem::offset_of!(JSXIdentifier, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXIdentifier, name) == 0usize);
     assert!(size_of::<JSXChild>() == 16usize);
     assert!(align_of::<JSXChild>() == 8usize);
     assert!(size_of::<JSXSpreadChild>() == 24usize);
     assert!(align_of::<JSXSpreadChild>() == 8usize);
-    assert!(std::mem::offset_of!(JSXSpreadChild, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXSpreadChild, expression) == 8usize);
+    assert!(std::mem::offset_of!(JSXSpreadChild, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXSpreadChild, expression) == 0usize);
     assert!(size_of::<JSXText>() == 24usize);
     assert!(align_of::<JSXText>() == 8usize);
-    assert!(std::mem::offset_of!(JSXText, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXText, value) == 8usize);
+    assert!(std::mem::offset_of!(JSXText, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXText, value) == 0usize);
 };
 #[cfg(target_pointer_width = "32")]
 const _: () = {
@@ -1133,20 +1133,20 @@ const _: () = {
     assert!(std::mem::offset_of!(NullLiteral, span) == 0usize);
     assert!(size_of::<NumericLiteral>() == 32usize);
     assert!(align_of::<NumericLiteral>() == 8usize);
-    assert!(std::mem::offset_of!(NumericLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(NumericLiteral, value) == 8usize);
-    assert!(std::mem::offset_of!(NumericLiteral, raw) == 16usize);
+    assert!(std::mem::offset_of!(NumericLiteral, span) == 16usize);
+    assert!(std::mem::offset_of!(NumericLiteral, value) == 24usize);
+    assert!(std::mem::offset_of!(NumericLiteral, raw) == 0usize);
     assert!(std::mem::offset_of!(NumericLiteral, base) == 32usize);
     assert!(size_of::<BigIntLiteral>() == 20usize);
     assert!(align_of::<BigIntLiteral>() == 4usize);
-    assert!(std::mem::offset_of!(BigIntLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(BigIntLiteral, raw) == 8usize);
+    assert!(std::mem::offset_of!(BigIntLiteral, span) == 16usize);
+    assert!(std::mem::offset_of!(BigIntLiteral, raw) == 0usize);
     assert!(std::mem::offset_of!(BigIntLiteral, base) == 24usize);
     assert!(size_of::<RegExpLiteral>() == 20usize);
     assert!(align_of::<RegExpLiteral>() == 4usize);
-    assert!(std::mem::offset_of!(RegExpLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(RegExpLiteral, value) == 8usize);
-    assert!(std::mem::offset_of!(RegExpLiteral, regex) == 8usize);
+    assert!(std::mem::offset_of!(RegExpLiteral, span) == 24usize);
+    assert!(std::mem::offset_of!(RegExpLiteral, value) == 32usize);
+    assert!(std::mem::offset_of!(RegExpLiteral, regex) == 0usize);
     assert!(size_of::<RegExp>() == 12usize);
     assert!(align_of::<RegExp>() == 4usize);
     assert!(std::mem::offset_of!(RegExp, pattern) == 0usize);
@@ -1155,45 +1155,45 @@ const _: () = {
     assert!(align_of::<EmptyObject>() == 1usize);
     assert!(size_of::<StringLiteral>() == 16usize);
     assert!(align_of::<StringLiteral>() == 4usize);
-    assert!(std::mem::offset_of!(StringLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(StringLiteral, value) == 8usize);
+    assert!(std::mem::offset_of!(StringLiteral, span) == 16usize);
+    assert!(std::mem::offset_of!(StringLiteral, value) == 0usize);
     assert!(size_of::<Program>() == 64usize);
     assert!(align_of::<Program>() == 4usize);
-    assert!(std::mem::offset_of!(Program, span) == 0usize);
-    assert!(std::mem::offset_of!(Program, source_type) == 8usize);
-    assert!(std::mem::offset_of!(Program, hashbang) == 16usize);
-    assert!(std::mem::offset_of!(Program, directives) == 40usize);
-    assert!(std::mem::offset_of!(Program, body) == 72usize);
-    assert!(std::mem::offset_of!(Program, scope_id) == 104usize);
+    assert!(std::mem::offset_of!(Program, span) == 88usize);
+    assert!(std::mem::offset_of!(Program, source_type) == 96usize);
+    assert!(std::mem::offset_of!(Program, hashbang) == 64usize);
+    assert!(std::mem::offset_of!(Program, directives) == 0usize);
+    assert!(std::mem::offset_of!(Program, body) == 32usize);
+    assert!(std::mem::offset_of!(Program, scope_id) == 100usize);
     assert!(size_of::<Expression>() == 8usize);
     assert!(align_of::<Expression>() == 4usize);
     assert!(size_of::<IdentifierName>() == 16usize);
     assert!(align_of::<IdentifierName>() == 4usize);
-    assert!(std::mem::offset_of!(IdentifierName, span) == 0usize);
-    assert!(std::mem::offset_of!(IdentifierName, name) == 8usize);
+    assert!(std::mem::offset_of!(IdentifierName, span) == 16usize);
+    assert!(std::mem::offset_of!(IdentifierName, name) == 0usize);
     assert!(size_of::<IdentifierReference>() == 24usize);
     assert!(align_of::<IdentifierReference>() == 4usize);
-    assert!(std::mem::offset_of!(IdentifierReference, span) == 0usize);
-    assert!(std::mem::offset_of!(IdentifierReference, name) == 8usize);
+    assert!(std::mem::offset_of!(IdentifierReference, span) == 16usize);
+    assert!(std::mem::offset_of!(IdentifierReference, name) == 0usize);
     assert!(std::mem::offset_of!(IdentifierReference, reference_id) == 24usize);
     assert!(std::mem::offset_of!(IdentifierReference, reference_flag) == 28usize);
     assert!(size_of::<BindingIdentifier>() == 20usize);
     assert!(align_of::<BindingIdentifier>() == 4usize);
-    assert!(std::mem::offset_of!(BindingIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(BindingIdentifier, name) == 8usize);
+    assert!(std::mem::offset_of!(BindingIdentifier, span) == 16usize);
+    assert!(std::mem::offset_of!(BindingIdentifier, name) == 0usize);
     assert!(std::mem::offset_of!(BindingIdentifier, symbol_id) == 24usize);
     assert!(size_of::<LabelIdentifier>() == 16usize);
     assert!(align_of::<LabelIdentifier>() == 4usize);
-    assert!(std::mem::offset_of!(LabelIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(LabelIdentifier, name) == 8usize);
+    assert!(std::mem::offset_of!(LabelIdentifier, span) == 16usize);
+    assert!(std::mem::offset_of!(LabelIdentifier, name) == 0usize);
     assert!(size_of::<ThisExpression>() == 8usize);
     assert!(align_of::<ThisExpression>() == 4usize);
     assert!(std::mem::offset_of!(ThisExpression, span) == 0usize);
     assert!(size_of::<ArrayExpression>() == 36usize);
     assert!(align_of::<ArrayExpression>() == 4usize);
-    assert!(std::mem::offset_of!(ArrayExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ArrayExpression, elements) == 8usize);
-    assert!(std::mem::offset_of!(ArrayExpression, trailing_comma) == 40usize);
+    assert!(std::mem::offset_of!(ArrayExpression, span) == 44usize);
+    assert!(std::mem::offset_of!(ArrayExpression, elements) == 0usize);
+    assert!(std::mem::offset_of!(ArrayExpression, trailing_comma) == 32usize);
     assert!(size_of::<ArrayExpressionElement>() == 12usize);
     assert!(align_of::<ArrayExpressionElement>() == 4usize);
     assert!(size_of::<Elision>() == 8usize);
@@ -1201,41 +1201,41 @@ const _: () = {
     assert!(std::mem::offset_of!(Elision, span) == 0usize);
     assert!(size_of::<ObjectExpression>() == 36usize);
     assert!(align_of::<ObjectExpression>() == 4usize);
-    assert!(std::mem::offset_of!(ObjectExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ObjectExpression, properties) == 8usize);
-    assert!(std::mem::offset_of!(ObjectExpression, trailing_comma) == 40usize);
+    assert!(std::mem::offset_of!(ObjectExpression, span) == 44usize);
+    assert!(std::mem::offset_of!(ObjectExpression, properties) == 0usize);
+    assert!(std::mem::offset_of!(ObjectExpression, trailing_comma) == 32usize);
     assert!(size_of::<ObjectPropertyKind>() == 8usize);
     assert!(align_of::<ObjectPropertyKind>() == 4usize);
-    assert!(size_of::<ObjectProperty>() == 40usize);
+    assert!(size_of::<ObjectProperty>() == 36usize);
     assert!(align_of::<ObjectProperty>() == 4usize);
-    assert!(std::mem::offset_of!(ObjectProperty, span) == 0usize);
-    assert!(std::mem::offset_of!(ObjectProperty, kind) == 8usize);
-    assert!(std::mem::offset_of!(ObjectProperty, key) == 16usize);
-    assert!(std::mem::offset_of!(ObjectProperty, value) == 32usize);
-    assert!(std::mem::offset_of!(ObjectProperty, init) == 48usize);
-    assert!(std::mem::offset_of!(ObjectProperty, method) == 64usize);
-    assert!(std::mem::offset_of!(ObjectProperty, shorthand) == 65usize);
-    assert!(std::mem::offset_of!(ObjectProperty, computed) == 66usize);
+    assert!(std::mem::offset_of!(ObjectProperty, span) == 48usize);
+    assert!(std::mem::offset_of!(ObjectProperty, kind) == 56usize);
+    assert!(std::mem::offset_of!(ObjectProperty, key) == 0usize);
+    assert!(std::mem::offset_of!(ObjectProperty, value) == 16usize);
+    assert!(std::mem::offset_of!(ObjectProperty, init) == 32usize);
+    assert!(std::mem::offset_of!(ObjectProperty, method) == 57usize);
+    assert!(std::mem::offset_of!(ObjectProperty, shorthand) == 58usize);
+    assert!(std::mem::offset_of!(ObjectProperty, computed) == 59usize);
     assert!(size_of::<PropertyKey>() == 8usize);
     assert!(align_of::<PropertyKey>() == 4usize);
     assert!(size_of::<PropertyKind>() == 1usize);
     assert!(align_of::<PropertyKind>() == 1usize);
     assert!(size_of::<TemplateLiteral>() == 40usize);
     assert!(align_of::<TemplateLiteral>() == 4usize);
-    assert!(std::mem::offset_of!(TemplateLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(TemplateLiteral, quasis) == 8usize);
-    assert!(std::mem::offset_of!(TemplateLiteral, expressions) == 40usize);
+    assert!(std::mem::offset_of!(TemplateLiteral, span) == 64usize);
+    assert!(std::mem::offset_of!(TemplateLiteral, quasis) == 0usize);
+    assert!(std::mem::offset_of!(TemplateLiteral, expressions) == 32usize);
     assert!(size_of::<TaggedTemplateExpression>() == 60usize);
     assert!(align_of::<TaggedTemplateExpression>() == 4usize);
-    assert!(std::mem::offset_of!(TaggedTemplateExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TaggedTemplateExpression, tag) == 8usize);
-    assert!(std::mem::offset_of!(TaggedTemplateExpression, quasi) == 24usize);
+    assert!(std::mem::offset_of!(TaggedTemplateExpression, span) == 88usize);
+    assert!(std::mem::offset_of!(TaggedTemplateExpression, tag) == 72usize);
+    assert!(std::mem::offset_of!(TaggedTemplateExpression, quasi) == 0usize);
     assert!(std::mem::offset_of!(TaggedTemplateExpression, type_parameters) == 96usize);
     assert!(size_of::<TemplateElement>() == 28usize);
     assert!(align_of::<TemplateElement>() == 4usize);
-    assert!(std::mem::offset_of!(TemplateElement, span) == 0usize);
-    assert!(std::mem::offset_of!(TemplateElement, tail) == 8usize);
-    assert!(std::mem::offset_of!(TemplateElement, value) == 16usize);
+    assert!(std::mem::offset_of!(TemplateElement, span) == 32usize);
+    assert!(std::mem::offset_of!(TemplateElement, tail) == 40usize);
+    assert!(std::mem::offset_of!(TemplateElement, value) == 0usize);
     assert!(size_of::<TemplateElementValue>() == 16usize);
     assert!(align_of::<TemplateElementValue>() == 4usize);
     assert!(std::mem::offset_of!(TemplateElementValue, raw) == 0usize);
@@ -1244,87 +1244,87 @@ const _: () = {
     assert!(align_of::<MemberExpression>() == 4usize);
     assert!(size_of::<ComputedMemberExpression>() == 28usize);
     assert!(align_of::<ComputedMemberExpression>() == 4usize);
-    assert!(std::mem::offset_of!(ComputedMemberExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ComputedMemberExpression, object) == 8usize);
-    assert!(std::mem::offset_of!(ComputedMemberExpression, expression) == 24usize);
+    assert!(std::mem::offset_of!(ComputedMemberExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(ComputedMemberExpression, object) == 0usize);
+    assert!(std::mem::offset_of!(ComputedMemberExpression, expression) == 16usize);
     assert!(std::mem::offset_of!(ComputedMemberExpression, optional) == 40usize);
     assert!(size_of::<StaticMemberExpression>() == 36usize);
     assert!(align_of::<StaticMemberExpression>() == 4usize);
-    assert!(std::mem::offset_of!(StaticMemberExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(StaticMemberExpression, object) == 8usize);
-    assert!(std::mem::offset_of!(StaticMemberExpression, property) == 24usize);
+    assert!(std::mem::offset_of!(StaticMemberExpression, span) == 40usize);
+    assert!(std::mem::offset_of!(StaticMemberExpression, object) == 24usize);
+    assert!(std::mem::offset_of!(StaticMemberExpression, property) == 0usize);
     assert!(std::mem::offset_of!(StaticMemberExpression, optional) == 48usize);
     assert!(size_of::<PrivateFieldExpression>() == 36usize);
     assert!(align_of::<PrivateFieldExpression>() == 4usize);
-    assert!(std::mem::offset_of!(PrivateFieldExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(PrivateFieldExpression, object) == 8usize);
-    assert!(std::mem::offset_of!(PrivateFieldExpression, field) == 24usize);
+    assert!(std::mem::offset_of!(PrivateFieldExpression, span) == 40usize);
+    assert!(std::mem::offset_of!(PrivateFieldExpression, object) == 24usize);
+    assert!(std::mem::offset_of!(PrivateFieldExpression, field) == 0usize);
     assert!(std::mem::offset_of!(PrivateFieldExpression, optional) == 48usize);
     assert!(size_of::<CallExpression>() == 40usize);
     assert!(align_of::<CallExpression>() == 4usize);
-    assert!(std::mem::offset_of!(CallExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(CallExpression, arguments) == 8usize);
-    assert!(std::mem::offset_of!(CallExpression, callee) == 40usize);
+    assert!(std::mem::offset_of!(CallExpression, span) == 48usize);
+    assert!(std::mem::offset_of!(CallExpression, arguments) == 0usize);
+    assert!(std::mem::offset_of!(CallExpression, callee) == 32usize);
     assert!(std::mem::offset_of!(CallExpression, type_parameters) == 56usize);
     assert!(std::mem::offset_of!(CallExpression, optional) == 64usize);
     assert!(size_of::<NewExpression>() == 36usize);
     assert!(align_of::<NewExpression>() == 4usize);
-    assert!(std::mem::offset_of!(NewExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(NewExpression, callee) == 8usize);
-    assert!(std::mem::offset_of!(NewExpression, arguments) == 24usize);
+    assert!(std::mem::offset_of!(NewExpression, span) == 48usize);
+    assert!(std::mem::offset_of!(NewExpression, callee) == 32usize);
+    assert!(std::mem::offset_of!(NewExpression, arguments) == 0usize);
     assert!(std::mem::offset_of!(NewExpression, type_parameters) == 56usize);
     assert!(size_of::<MetaProperty>() == 40usize);
     assert!(align_of::<MetaProperty>() == 4usize);
-    assert!(std::mem::offset_of!(MetaProperty, span) == 0usize);
-    assert!(std::mem::offset_of!(MetaProperty, meta) == 8usize);
-    assert!(std::mem::offset_of!(MetaProperty, property) == 32usize);
+    assert!(std::mem::offset_of!(MetaProperty, span) == 48usize);
+    assert!(std::mem::offset_of!(MetaProperty, meta) == 0usize);
+    assert!(std::mem::offset_of!(MetaProperty, property) == 24usize);
     assert!(size_of::<SpreadElement>() == 16usize);
     assert!(align_of::<SpreadElement>() == 4usize);
-    assert!(std::mem::offset_of!(SpreadElement, span) == 0usize);
-    assert!(std::mem::offset_of!(SpreadElement, argument) == 8usize);
+    assert!(std::mem::offset_of!(SpreadElement, span) == 16usize);
+    assert!(std::mem::offset_of!(SpreadElement, argument) == 0usize);
     assert!(size_of::<Argument>() == 8usize);
     assert!(align_of::<Argument>() == 4usize);
     assert!(size_of::<UpdateExpression>() == 20usize);
     assert!(align_of::<UpdateExpression>() == 4usize);
-    assert!(std::mem::offset_of!(UpdateExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(UpdateExpression, operator) == 8usize);
-    assert!(std::mem::offset_of!(UpdateExpression, prefix) == 9usize);
-    assert!(std::mem::offset_of!(UpdateExpression, argument) == 16usize);
+    assert!(std::mem::offset_of!(UpdateExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(UpdateExpression, operator) == 24usize);
+    assert!(std::mem::offset_of!(UpdateExpression, prefix) == 25usize);
+    assert!(std::mem::offset_of!(UpdateExpression, argument) == 0usize);
     assert!(size_of::<UnaryExpression>() == 20usize);
     assert!(align_of::<UnaryExpression>() == 4usize);
-    assert!(std::mem::offset_of!(UnaryExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(UnaryExpression, operator) == 8usize);
-    assert!(std::mem::offset_of!(UnaryExpression, argument) == 16usize);
+    assert!(std::mem::offset_of!(UnaryExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(UnaryExpression, operator) == 24usize);
+    assert!(std::mem::offset_of!(UnaryExpression, argument) == 0usize);
     assert!(size_of::<BinaryExpression>() == 28usize);
     assert!(align_of::<BinaryExpression>() == 4usize);
-    assert!(std::mem::offset_of!(BinaryExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(BinaryExpression, left) == 8usize);
-    assert!(std::mem::offset_of!(BinaryExpression, operator) == 24usize);
-    assert!(std::mem::offset_of!(BinaryExpression, right) == 32usize);
+    assert!(std::mem::offset_of!(BinaryExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(BinaryExpression, left) == 0usize);
+    assert!(std::mem::offset_of!(BinaryExpression, operator) == 40usize);
+    assert!(std::mem::offset_of!(BinaryExpression, right) == 16usize);
     assert!(size_of::<PrivateInExpression>() == 36usize);
     assert!(align_of::<PrivateInExpression>() == 4usize);
-    assert!(std::mem::offset_of!(PrivateInExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(PrivateInExpression, left) == 8usize);
-    assert!(std::mem::offset_of!(PrivateInExpression, operator) == 32usize);
-    assert!(std::mem::offset_of!(PrivateInExpression, right) == 40usize);
+    assert!(std::mem::offset_of!(PrivateInExpression, span) == 40usize);
+    assert!(std::mem::offset_of!(PrivateInExpression, left) == 0usize);
+    assert!(std::mem::offset_of!(PrivateInExpression, operator) == 48usize);
+    assert!(std::mem::offset_of!(PrivateInExpression, right) == 24usize);
     assert!(size_of::<LogicalExpression>() == 28usize);
     assert!(align_of::<LogicalExpression>() == 4usize);
-    assert!(std::mem::offset_of!(LogicalExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(LogicalExpression, left) == 8usize);
-    assert!(std::mem::offset_of!(LogicalExpression, operator) == 24usize);
-    assert!(std::mem::offset_of!(LogicalExpression, right) == 32usize);
+    assert!(std::mem::offset_of!(LogicalExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(LogicalExpression, left) == 0usize);
+    assert!(std::mem::offset_of!(LogicalExpression, operator) == 40usize);
+    assert!(std::mem::offset_of!(LogicalExpression, right) == 16usize);
     assert!(size_of::<ConditionalExpression>() == 32usize);
     assert!(align_of::<ConditionalExpression>() == 4usize);
-    assert!(std::mem::offset_of!(ConditionalExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ConditionalExpression, test) == 8usize);
-    assert!(std::mem::offset_of!(ConditionalExpression, consequent) == 24usize);
-    assert!(std::mem::offset_of!(ConditionalExpression, alternate) == 40usize);
+    assert!(std::mem::offset_of!(ConditionalExpression, span) == 48usize);
+    assert!(std::mem::offset_of!(ConditionalExpression, test) == 0usize);
+    assert!(std::mem::offset_of!(ConditionalExpression, consequent) == 16usize);
+    assert!(std::mem::offset_of!(ConditionalExpression, alternate) == 32usize);
     assert!(size_of::<AssignmentExpression>() == 28usize);
     assert!(align_of::<AssignmentExpression>() == 4usize);
-    assert!(std::mem::offset_of!(AssignmentExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentExpression, operator) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentExpression, left) == 16usize);
-    assert!(std::mem::offset_of!(AssignmentExpression, right) == 32usize);
+    assert!(std::mem::offset_of!(AssignmentExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(AssignmentExpression, operator) == 40usize);
+    assert!(std::mem::offset_of!(AssignmentExpression, left) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentExpression, right) == 16usize);
     assert!(size_of::<AssignmentTarget>() == 8usize);
     assert!(align_of::<AssignmentTarget>() == 4usize);
     assert!(size_of::<SimpleAssignmentTarget>() == 8usize);
@@ -1333,184 +1333,184 @@ const _: () = {
     assert!(align_of::<AssignmentTargetPattern>() == 4usize);
     assert!(size_of::<ArrayAssignmentTarget>() == 52usize);
     assert!(align_of::<ArrayAssignmentTarget>() == 4usize);
-    assert!(std::mem::offset_of!(ArrayAssignmentTarget, span) == 0usize);
-    assert!(std::mem::offset_of!(ArrayAssignmentTarget, elements) == 8usize);
-    assert!(std::mem::offset_of!(ArrayAssignmentTarget, rest) == 40usize);
-    assert!(std::mem::offset_of!(ArrayAssignmentTarget, trailing_comma) == 64usize);
+    assert!(std::mem::offset_of!(ArrayAssignmentTarget, span) == 68usize);
+    assert!(std::mem::offset_of!(ArrayAssignmentTarget, elements) == 0usize);
+    assert!(std::mem::offset_of!(ArrayAssignmentTarget, rest) == 32usize);
+    assert!(std::mem::offset_of!(ArrayAssignmentTarget, trailing_comma) == 56usize);
     assert!(size_of::<ObjectAssignmentTarget>() == 40usize);
     assert!(align_of::<ObjectAssignmentTarget>() == 4usize);
-    assert!(std::mem::offset_of!(ObjectAssignmentTarget, span) == 0usize);
-    assert!(std::mem::offset_of!(ObjectAssignmentTarget, properties) == 8usize);
-    assert!(std::mem::offset_of!(ObjectAssignmentTarget, rest) == 40usize);
+    assert!(std::mem::offset_of!(ObjectAssignmentTarget, span) == 56usize);
+    assert!(std::mem::offset_of!(ObjectAssignmentTarget, properties) == 0usize);
+    assert!(std::mem::offset_of!(ObjectAssignmentTarget, rest) == 32usize);
     assert!(size_of::<AssignmentTargetRest>() == 16usize);
     assert!(align_of::<AssignmentTargetRest>() == 4usize);
-    assert!(std::mem::offset_of!(AssignmentTargetRest, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentTargetRest, target) == 8usize);
+    assert!(std::mem::offset_of!(AssignmentTargetRest, span) == 16usize);
+    assert!(std::mem::offset_of!(AssignmentTargetRest, target) == 0usize);
     assert!(size_of::<AssignmentTargetMaybeDefault>() == 8usize);
     assert!(align_of::<AssignmentTargetMaybeDefault>() == 4usize);
     assert!(size_of::<AssignmentTargetWithDefault>() == 24usize);
     assert!(align_of::<AssignmentTargetWithDefault>() == 4usize);
-    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, binding) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, init) == 24usize);
+    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, span) == 32usize);
+    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, binding) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentTargetWithDefault, init) == 16usize);
     assert!(size_of::<AssignmentTargetProperty>() == 8usize);
     assert!(align_of::<AssignmentTargetProperty>() == 4usize);
     assert!(size_of::<AssignmentTargetPropertyIdentifier>() == 40usize);
     assert!(align_of::<AssignmentTargetPropertyIdentifier>() == 4usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, binding) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, init) == 40usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, span) == 48usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, binding) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier, init) == 32usize);
     assert!(size_of::<AssignmentTargetPropertyProperty>() == 24usize);
     assert!(align_of::<AssignmentTargetPropertyProperty>() == 4usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, name) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, binding) == 24usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, span) == 32usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, name) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty, binding) == 16usize);
     assert!(size_of::<SequenceExpression>() == 24usize);
     assert!(align_of::<SequenceExpression>() == 4usize);
-    assert!(std::mem::offset_of!(SequenceExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(SequenceExpression, expressions) == 8usize);
+    assert!(std::mem::offset_of!(SequenceExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(SequenceExpression, expressions) == 0usize);
     assert!(size_of::<Super>() == 8usize);
     assert!(align_of::<Super>() == 4usize);
     assert!(std::mem::offset_of!(Super, span) == 0usize);
     assert!(size_of::<AwaitExpression>() == 16usize);
     assert!(align_of::<AwaitExpression>() == 4usize);
-    assert!(std::mem::offset_of!(AwaitExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(AwaitExpression, argument) == 8usize);
+    assert!(std::mem::offset_of!(AwaitExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(AwaitExpression, argument) == 0usize);
     assert!(size_of::<ChainExpression>() == 16usize);
     assert!(align_of::<ChainExpression>() == 4usize);
-    assert!(std::mem::offset_of!(ChainExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ChainExpression, expression) == 8usize);
+    assert!(std::mem::offset_of!(ChainExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(ChainExpression, expression) == 0usize);
     assert!(size_of::<ChainElement>() == 8usize);
     assert!(align_of::<ChainElement>() == 4usize);
     assert!(size_of::<ParenthesizedExpression>() == 16usize);
     assert!(align_of::<ParenthesizedExpression>() == 4usize);
-    assert!(std::mem::offset_of!(ParenthesizedExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ParenthesizedExpression, expression) == 8usize);
+    assert!(std::mem::offset_of!(ParenthesizedExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(ParenthesizedExpression, expression) == 0usize);
     assert!(size_of::<Statement>() == 8usize);
     assert!(align_of::<Statement>() == 4usize);
     assert!(size_of::<Directive>() == 32usize);
     assert!(align_of::<Directive>() == 4usize);
-    assert!(std::mem::offset_of!(Directive, span) == 0usize);
-    assert!(std::mem::offset_of!(Directive, expression) == 8usize);
-    assert!(std::mem::offset_of!(Directive, directive) == 32usize);
+    assert!(std::mem::offset_of!(Directive, span) == 40usize);
+    assert!(std::mem::offset_of!(Directive, expression) == 0usize);
+    assert!(std::mem::offset_of!(Directive, directive) == 24usize);
     assert!(size_of::<Hashbang>() == 16usize);
     assert!(align_of::<Hashbang>() == 4usize);
-    assert!(std::mem::offset_of!(Hashbang, span) == 0usize);
-    assert!(std::mem::offset_of!(Hashbang, value) == 8usize);
+    assert!(std::mem::offset_of!(Hashbang, span) == 16usize);
+    assert!(std::mem::offset_of!(Hashbang, value) == 0usize);
     assert!(size_of::<BlockStatement>() == 28usize);
     assert!(align_of::<BlockStatement>() == 4usize);
-    assert!(std::mem::offset_of!(BlockStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(BlockStatement, body) == 8usize);
+    assert!(std::mem::offset_of!(BlockStatement, span) == 32usize);
+    assert!(std::mem::offset_of!(BlockStatement, body) == 0usize);
     assert!(std::mem::offset_of!(BlockStatement, scope_id) == 40usize);
     assert!(size_of::<Declaration>() == 8usize);
     assert!(align_of::<Declaration>() == 4usize);
-    assert!(size_of::<VariableDeclaration>() == 32usize);
+    assert!(size_of::<VariableDeclaration>() == 28usize);
     assert!(align_of::<VariableDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(VariableDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(VariableDeclaration, kind) == 8usize);
-    assert!(std::mem::offset_of!(VariableDeclaration, declarations) == 16usize);
-    assert!(std::mem::offset_of!(VariableDeclaration, declare) == 48usize);
+    assert!(std::mem::offset_of!(VariableDeclaration, span) == 32usize);
+    assert!(std::mem::offset_of!(VariableDeclaration, kind) == 40usize);
+    assert!(std::mem::offset_of!(VariableDeclaration, declarations) == 0usize);
+    assert!(std::mem::offset_of!(VariableDeclaration, declare) == 41usize);
     assert!(size_of::<VariableDeclarationKind>() == 1usize);
     assert!(align_of::<VariableDeclarationKind>() == 1usize);
-    assert!(size_of::<VariableDeclarator>() == 40usize);
+    assert!(size_of::<VariableDeclarator>() == 36usize);
     assert!(align_of::<VariableDeclarator>() == 4usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, span) == 0usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, kind) == 8usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, id) == 16usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, init) == 48usize);
-    assert!(std::mem::offset_of!(VariableDeclarator, definite) == 64usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, span) == 48usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, kind) == 56usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, id) == 0usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, init) == 32usize);
+    assert!(std::mem::offset_of!(VariableDeclarator, definite) == 57usize);
     assert!(size_of::<UsingDeclaration>() == 28usize);
     assert!(align_of::<UsingDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(UsingDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(UsingDeclaration, is_await) == 8usize);
-    assert!(std::mem::offset_of!(UsingDeclaration, declarations) == 16usize);
+    assert!(std::mem::offset_of!(UsingDeclaration, span) == 32usize);
+    assert!(std::mem::offset_of!(UsingDeclaration, is_await) == 40usize);
+    assert!(std::mem::offset_of!(UsingDeclaration, declarations) == 0usize);
     assert!(size_of::<EmptyStatement>() == 8usize);
     assert!(align_of::<EmptyStatement>() == 4usize);
     assert!(std::mem::offset_of!(EmptyStatement, span) == 0usize);
     assert!(size_of::<ExpressionStatement>() == 16usize);
     assert!(align_of::<ExpressionStatement>() == 4usize);
-    assert!(std::mem::offset_of!(ExpressionStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ExpressionStatement, expression) == 8usize);
+    assert!(std::mem::offset_of!(ExpressionStatement, span) == 16usize);
+    assert!(std::mem::offset_of!(ExpressionStatement, expression) == 0usize);
     assert!(size_of::<IfStatement>() == 32usize);
     assert!(align_of::<IfStatement>() == 4usize);
-    assert!(std::mem::offset_of!(IfStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(IfStatement, test) == 8usize);
-    assert!(std::mem::offset_of!(IfStatement, consequent) == 24usize);
-    assert!(std::mem::offset_of!(IfStatement, alternate) == 40usize);
+    assert!(std::mem::offset_of!(IfStatement, span) == 48usize);
+    assert!(std::mem::offset_of!(IfStatement, test) == 0usize);
+    assert!(std::mem::offset_of!(IfStatement, consequent) == 16usize);
+    assert!(std::mem::offset_of!(IfStatement, alternate) == 32usize);
     assert!(size_of::<DoWhileStatement>() == 24usize);
     assert!(align_of::<DoWhileStatement>() == 4usize);
-    assert!(std::mem::offset_of!(DoWhileStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(DoWhileStatement, body) == 8usize);
-    assert!(std::mem::offset_of!(DoWhileStatement, test) == 24usize);
+    assert!(std::mem::offset_of!(DoWhileStatement, span) == 32usize);
+    assert!(std::mem::offset_of!(DoWhileStatement, body) == 0usize);
+    assert!(std::mem::offset_of!(DoWhileStatement, test) == 16usize);
     assert!(size_of::<WhileStatement>() == 24usize);
     assert!(align_of::<WhileStatement>() == 4usize);
-    assert!(std::mem::offset_of!(WhileStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(WhileStatement, test) == 8usize);
-    assert!(std::mem::offset_of!(WhileStatement, body) == 24usize);
+    assert!(std::mem::offset_of!(WhileStatement, span) == 32usize);
+    assert!(std::mem::offset_of!(WhileStatement, test) == 0usize);
+    assert!(std::mem::offset_of!(WhileStatement, body) == 16usize);
     assert!(size_of::<ForStatement>() == 44usize);
     assert!(align_of::<ForStatement>() == 4usize);
-    assert!(std::mem::offset_of!(ForStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ForStatement, init) == 8usize);
-    assert!(std::mem::offset_of!(ForStatement, test) == 24usize);
-    assert!(std::mem::offset_of!(ForStatement, update) == 40usize);
-    assert!(std::mem::offset_of!(ForStatement, body) == 56usize);
+    assert!(std::mem::offset_of!(ForStatement, span) == 64usize);
+    assert!(std::mem::offset_of!(ForStatement, init) == 0usize);
+    assert!(std::mem::offset_of!(ForStatement, test) == 16usize);
+    assert!(std::mem::offset_of!(ForStatement, update) == 32usize);
+    assert!(std::mem::offset_of!(ForStatement, body) == 48usize);
     assert!(std::mem::offset_of!(ForStatement, scope_id) == 72usize);
     assert!(size_of::<ForStatementInit>() == 8usize);
     assert!(align_of::<ForStatementInit>() == 4usize);
     assert!(size_of::<ForInStatement>() == 36usize);
     assert!(align_of::<ForInStatement>() == 4usize);
-    assert!(std::mem::offset_of!(ForInStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ForInStatement, left) == 8usize);
-    assert!(std::mem::offset_of!(ForInStatement, right) == 24usize);
-    assert!(std::mem::offset_of!(ForInStatement, body) == 40usize);
+    assert!(std::mem::offset_of!(ForInStatement, span) == 48usize);
+    assert!(std::mem::offset_of!(ForInStatement, left) == 0usize);
+    assert!(std::mem::offset_of!(ForInStatement, right) == 16usize);
+    assert!(std::mem::offset_of!(ForInStatement, body) == 32usize);
     assert!(std::mem::offset_of!(ForInStatement, scope_id) == 56usize);
     assert!(size_of::<ForStatementLeft>() == 8usize);
     assert!(align_of::<ForStatementLeft>() == 4usize);
     assert!(size_of::<ForOfStatement>() == 40usize);
     assert!(align_of::<ForOfStatement>() == 4usize);
-    assert!(std::mem::offset_of!(ForOfStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ForOfStatement, r#await) == 8usize);
-    assert!(std::mem::offset_of!(ForOfStatement, left) == 16usize);
-    assert!(std::mem::offset_of!(ForOfStatement, right) == 32usize);
-    assert!(std::mem::offset_of!(ForOfStatement, body) == 48usize);
-    assert!(std::mem::offset_of!(ForOfStatement, scope_id) == 64usize);
+    assert!(std::mem::offset_of!(ForOfStatement, span) == 48usize);
+    assert!(std::mem::offset_of!(ForOfStatement, r#await) == 60usize);
+    assert!(std::mem::offset_of!(ForOfStatement, left) == 0usize);
+    assert!(std::mem::offset_of!(ForOfStatement, right) == 16usize);
+    assert!(std::mem::offset_of!(ForOfStatement, body) == 32usize);
+    assert!(std::mem::offset_of!(ForOfStatement, scope_id) == 56usize);
     assert!(size_of::<ContinueStatement>() == 24usize);
     assert!(align_of::<ContinueStatement>() == 4usize);
-    assert!(std::mem::offset_of!(ContinueStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ContinueStatement, label) == 8usize);
+    assert!(std::mem::offset_of!(ContinueStatement, span) == 24usize);
+    assert!(std::mem::offset_of!(ContinueStatement, label) == 0usize);
     assert!(size_of::<BreakStatement>() == 24usize);
     assert!(align_of::<BreakStatement>() == 4usize);
-    assert!(std::mem::offset_of!(BreakStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(BreakStatement, label) == 8usize);
+    assert!(std::mem::offset_of!(BreakStatement, span) == 24usize);
+    assert!(std::mem::offset_of!(BreakStatement, label) == 0usize);
     assert!(size_of::<ReturnStatement>() == 16usize);
     assert!(align_of::<ReturnStatement>() == 4usize);
-    assert!(std::mem::offset_of!(ReturnStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ReturnStatement, argument) == 8usize);
+    assert!(std::mem::offset_of!(ReturnStatement, span) == 16usize);
+    assert!(std::mem::offset_of!(ReturnStatement, argument) == 0usize);
     assert!(size_of::<WithStatement>() == 24usize);
     assert!(align_of::<WithStatement>() == 4usize);
-    assert!(std::mem::offset_of!(WithStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(WithStatement, object) == 8usize);
-    assert!(std::mem::offset_of!(WithStatement, body) == 24usize);
+    assert!(std::mem::offset_of!(WithStatement, span) == 32usize);
+    assert!(std::mem::offset_of!(WithStatement, object) == 0usize);
+    assert!(std::mem::offset_of!(WithStatement, body) == 16usize);
     assert!(size_of::<SwitchStatement>() == 36usize);
     assert!(align_of::<SwitchStatement>() == 4usize);
-    assert!(std::mem::offset_of!(SwitchStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(SwitchStatement, discriminant) == 8usize);
-    assert!(std::mem::offset_of!(SwitchStatement, cases) == 24usize);
+    assert!(std::mem::offset_of!(SwitchStatement, span) == 48usize);
+    assert!(std::mem::offset_of!(SwitchStatement, discriminant) == 32usize);
+    assert!(std::mem::offset_of!(SwitchStatement, cases) == 0usize);
     assert!(std::mem::offset_of!(SwitchStatement, scope_id) == 56usize);
     assert!(size_of::<SwitchCase>() == 32usize);
     assert!(align_of::<SwitchCase>() == 4usize);
-    assert!(std::mem::offset_of!(SwitchCase, span) == 0usize);
-    assert!(std::mem::offset_of!(SwitchCase, test) == 8usize);
-    assert!(std::mem::offset_of!(SwitchCase, consequent) == 24usize);
+    assert!(std::mem::offset_of!(SwitchCase, span) == 48usize);
+    assert!(std::mem::offset_of!(SwitchCase, test) == 32usize);
+    assert!(std::mem::offset_of!(SwitchCase, consequent) == 0usize);
     assert!(size_of::<LabeledStatement>() == 32usize);
     assert!(align_of::<LabeledStatement>() == 4usize);
-    assert!(std::mem::offset_of!(LabeledStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(LabeledStatement, label) == 8usize);
-    assert!(std::mem::offset_of!(LabeledStatement, body) == 32usize);
+    assert!(std::mem::offset_of!(LabeledStatement, span) == 40usize);
+    assert!(std::mem::offset_of!(LabeledStatement, label) == 0usize);
+    assert!(std::mem::offset_of!(LabeledStatement, body) == 24usize);
     assert!(size_of::<ThrowStatement>() == 16usize);
     assert!(align_of::<ThrowStatement>() == 4usize);
-    assert!(std::mem::offset_of!(ThrowStatement, span) == 0usize);
-    assert!(std::mem::offset_of!(ThrowStatement, argument) == 8usize);
+    assert!(std::mem::offset_of!(ThrowStatement, span) == 16usize);
+    assert!(std::mem::offset_of!(ThrowStatement, argument) == 0usize);
     assert!(size_of::<TryStatement>() == 20usize);
     assert!(align_of::<TryStatement>() == 4usize);
     assert!(std::mem::offset_of!(TryStatement, span) == 0usize);
@@ -1519,14 +1519,14 @@ const _: () = {
     assert!(std::mem::offset_of!(TryStatement, finalizer) == 24usize);
     assert!(size_of::<CatchClause>() == 40usize);
     assert!(align_of::<CatchClause>() == 4usize);
-    assert!(std::mem::offset_of!(CatchClause, span) == 0usize);
-    assert!(std::mem::offset_of!(CatchClause, param) == 8usize);
+    assert!(std::mem::offset_of!(CatchClause, span) == 40usize);
+    assert!(std::mem::offset_of!(CatchClause, param) == 0usize);
     assert!(std::mem::offset_of!(CatchClause, body) == 48usize);
     assert!(std::mem::offset_of!(CatchClause, scope_id) == 56usize);
     assert!(size_of::<CatchParameter>() == 24usize);
     assert!(align_of::<CatchParameter>() == 4usize);
-    assert!(std::mem::offset_of!(CatchParameter, span) == 0usize);
-    assert!(std::mem::offset_of!(CatchParameter, pattern) == 8usize);
+    assert!(std::mem::offset_of!(CatchParameter, span) == 32usize);
+    assert!(std::mem::offset_of!(CatchParameter, pattern) == 0usize);
     assert!(size_of::<DebuggerStatement>() == 8usize);
     assert!(align_of::<DebuggerStatement>() == 4usize);
     assert!(std::mem::offset_of!(DebuggerStatement, span) == 0usize);
@@ -1539,57 +1539,57 @@ const _: () = {
     assert!(align_of::<BindingPatternKind>() == 4usize);
     assert!(size_of::<AssignmentPattern>() == 32usize);
     assert!(align_of::<AssignmentPattern>() == 4usize);
-    assert!(std::mem::offset_of!(AssignmentPattern, span) == 0usize);
-    assert!(std::mem::offset_of!(AssignmentPattern, left) == 8usize);
-    assert!(std::mem::offset_of!(AssignmentPattern, right) == 40usize);
+    assert!(std::mem::offset_of!(AssignmentPattern, span) == 48usize);
+    assert!(std::mem::offset_of!(AssignmentPattern, left) == 0usize);
+    assert!(std::mem::offset_of!(AssignmentPattern, right) == 32usize);
     assert!(size_of::<ObjectPattern>() == 28usize);
     assert!(align_of::<ObjectPattern>() == 4usize);
-    assert!(std::mem::offset_of!(ObjectPattern, span) == 0usize);
-    assert!(std::mem::offset_of!(ObjectPattern, properties) == 8usize);
+    assert!(std::mem::offset_of!(ObjectPattern, span) == 32usize);
+    assert!(std::mem::offset_of!(ObjectPattern, properties) == 0usize);
     assert!(std::mem::offset_of!(ObjectPattern, rest) == 40usize);
     assert!(size_of::<BindingProperty>() == 36usize);
     assert!(align_of::<BindingProperty>() == 4usize);
-    assert!(std::mem::offset_of!(BindingProperty, span) == 0usize);
-    assert!(std::mem::offset_of!(BindingProperty, key) == 8usize);
-    assert!(std::mem::offset_of!(BindingProperty, value) == 24usize);
+    assert!(std::mem::offset_of!(BindingProperty, span) == 48usize);
+    assert!(std::mem::offset_of!(BindingProperty, key) == 32usize);
+    assert!(std::mem::offset_of!(BindingProperty, value) == 0usize);
     assert!(std::mem::offset_of!(BindingProperty, shorthand) == 56usize);
     assert!(std::mem::offset_of!(BindingProperty, computed) == 57usize);
     assert!(size_of::<ArrayPattern>() == 28usize);
     assert!(align_of::<ArrayPattern>() == 4usize);
-    assert!(std::mem::offset_of!(ArrayPattern, span) == 0usize);
-    assert!(std::mem::offset_of!(ArrayPattern, elements) == 8usize);
+    assert!(std::mem::offset_of!(ArrayPattern, span) == 32usize);
+    assert!(std::mem::offset_of!(ArrayPattern, elements) == 0usize);
     assert!(std::mem::offset_of!(ArrayPattern, rest) == 40usize);
     assert!(size_of::<BindingRestElement>() == 24usize);
     assert!(align_of::<BindingRestElement>() == 4usize);
-    assert!(std::mem::offset_of!(BindingRestElement, span) == 0usize);
-    assert!(std::mem::offset_of!(BindingRestElement, argument) == 8usize);
-    assert!(size_of::<Function>() == 84usize);
+    assert!(std::mem::offset_of!(BindingRestElement, span) == 32usize);
+    assert!(std::mem::offset_of!(BindingRestElement, argument) == 0usize);
+    assert!(size_of::<Function>() == 80usize);
     assert!(align_of::<Function>() == 4usize);
-    assert!(std::mem::offset_of!(Function, r#type) == 0usize);
-    assert!(std::mem::offset_of!(Function, span) == 4usize);
-    assert!(std::mem::offset_of!(Function, id) == 16usize);
-    assert!(std::mem::offset_of!(Function, generator) == 48usize);
-    assert!(std::mem::offset_of!(Function, r#async) == 49usize);
-    assert!(std::mem::offset_of!(Function, declare) == 50usize);
-    assert!(std::mem::offset_of!(Function, type_parameters) == 56usize);
-    assert!(std::mem::offset_of!(Function, this_param) == 64usize);
-    assert!(std::mem::offset_of!(Function, params) == 104usize);
-    assert!(std::mem::offset_of!(Function, return_type) == 112usize);
-    assert!(std::mem::offset_of!(Function, body) == 120usize);
-    assert!(std::mem::offset_of!(Function, scope_id) == 128usize);
+    assert!(std::mem::offset_of!(Function, r#type) == 116usize);
+    assert!(std::mem::offset_of!(Function, span) == 72usize);
+    assert!(std::mem::offset_of!(Function, id) == 40usize);
+    assert!(std::mem::offset_of!(Function, generator) == 117usize);
+    assert!(std::mem::offset_of!(Function, r#async) == 118usize);
+    assert!(std::mem::offset_of!(Function, declare) == 119usize);
+    assert!(std::mem::offset_of!(Function, type_parameters) == 80usize);
+    assert!(std::mem::offset_of!(Function, this_param) == 0usize);
+    assert!(std::mem::offset_of!(Function, params) == 88usize);
+    assert!(std::mem::offset_of!(Function, return_type) == 96usize);
+    assert!(std::mem::offset_of!(Function, body) == 104usize);
+    assert!(std::mem::offset_of!(Function, scope_id) == 112usize);
     assert!(size_of::<FunctionType>() == 1usize);
     assert!(align_of::<FunctionType>() == 1usize);
     assert!(size_of::<FormalParameters>() == 32usize);
     assert!(align_of::<FormalParameters>() == 4usize);
-    assert!(std::mem::offset_of!(FormalParameters, span) == 0usize);
-    assert!(std::mem::offset_of!(FormalParameters, kind) == 8usize);
-    assert!(std::mem::offset_of!(FormalParameters, items) == 16usize);
-    assert!(std::mem::offset_of!(FormalParameters, rest) == 48usize);
+    assert!(std::mem::offset_of!(FormalParameters, span) == 32usize);
+    assert!(std::mem::offset_of!(FormalParameters, kind) == 48usize);
+    assert!(std::mem::offset_of!(FormalParameters, items) == 0usize);
+    assert!(std::mem::offset_of!(FormalParameters, rest) == 40usize);
     assert!(size_of::<FormalParameter>() == 44usize);
     assert!(align_of::<FormalParameter>() == 4usize);
-    assert!(std::mem::offset_of!(FormalParameter, span) == 0usize);
-    assert!(std::mem::offset_of!(FormalParameter, decorators) == 8usize);
-    assert!(std::mem::offset_of!(FormalParameter, pattern) == 40usize);
+    assert!(std::mem::offset_of!(FormalParameter, span) == 64usize);
+    assert!(std::mem::offset_of!(FormalParameter, decorators) == 0usize);
+    assert!(std::mem::offset_of!(FormalParameter, pattern) == 32usize);
     assert!(std::mem::offset_of!(FormalParameter, accessibility) == 72usize);
     assert!(std::mem::offset_of!(FormalParameter, readonly) == 73usize);
     assert!(std::mem::offset_of!(FormalParameter, r#override) == 74usize);
@@ -1597,168 +1597,168 @@ const _: () = {
     assert!(align_of::<FormalParameterKind>() == 1usize);
     assert!(size_of::<FunctionBody>() == 40usize);
     assert!(align_of::<FunctionBody>() == 4usize);
-    assert!(std::mem::offset_of!(FunctionBody, span) == 0usize);
-    assert!(std::mem::offset_of!(FunctionBody, directives) == 8usize);
-    assert!(std::mem::offset_of!(FunctionBody, statements) == 40usize);
+    assert!(std::mem::offset_of!(FunctionBody, span) == 64usize);
+    assert!(std::mem::offset_of!(FunctionBody, directives) == 0usize);
+    assert!(std::mem::offset_of!(FunctionBody, statements) == 32usize);
     assert!(size_of::<ArrowFunctionExpression>() == 32usize);
     assert!(align_of::<ArrowFunctionExpression>() == 4usize);
     assert!(std::mem::offset_of!(ArrowFunctionExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, expression) == 8usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, r#async) == 9usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, type_parameters) == 16usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, params) == 24usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, return_type) == 32usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, body) == 40usize);
-    assert!(std::mem::offset_of!(ArrowFunctionExpression, scope_id) == 48usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, expression) == 44usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, r#async) == 45usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, type_parameters) == 8usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, params) == 16usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, return_type) == 24usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, body) == 32usize);
+    assert!(std::mem::offset_of!(ArrowFunctionExpression, scope_id) == 40usize);
     assert!(size_of::<YieldExpression>() == 20usize);
     assert!(align_of::<YieldExpression>() == 4usize);
-    assert!(std::mem::offset_of!(YieldExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(YieldExpression, delegate) == 8usize);
-    assert!(std::mem::offset_of!(YieldExpression, argument) == 16usize);
-    assert!(size_of::<Class>() == 92usize);
+    assert!(std::mem::offset_of!(YieldExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(YieldExpression, delegate) == 24usize);
+    assert!(std::mem::offset_of!(YieldExpression, argument) == 0usize);
+    assert!(size_of::<Class>() == 88usize);
     assert!(align_of::<Class>() == 4usize);
-    assert!(std::mem::offset_of!(Class, r#type) == 0usize);
-    assert!(std::mem::offset_of!(Class, span) == 4usize);
-    assert!(std::mem::offset_of!(Class, decorators) == 16usize);
-    assert!(std::mem::offset_of!(Class, id) == 48usize);
-    assert!(std::mem::offset_of!(Class, type_parameters) == 80usize);
-    assert!(std::mem::offset_of!(Class, super_class) == 88usize);
-    assert!(std::mem::offset_of!(Class, super_type_parameters) == 104usize);
-    assert!(std::mem::offset_of!(Class, implements) == 112usize);
-    assert!(std::mem::offset_of!(Class, body) == 144usize);
-    assert!(std::mem::offset_of!(Class, r#abstract) == 152usize);
-    assert!(std::mem::offset_of!(Class, declare) == 153usize);
-    assert!(std::mem::offset_of!(Class, scope_id) == 156usize);
+    assert!(std::mem::offset_of!(Class, r#type) == 148usize);
+    assert!(std::mem::offset_of!(Class, span) == 112usize);
+    assert!(std::mem::offset_of!(Class, decorators) == 0usize);
+    assert!(std::mem::offset_of!(Class, id) == 32usize);
+    assert!(std::mem::offset_of!(Class, type_parameters) == 120usize);
+    assert!(std::mem::offset_of!(Class, super_class) == 96usize);
+    assert!(std::mem::offset_of!(Class, super_type_parameters) == 128usize);
+    assert!(std::mem::offset_of!(Class, implements) == 64usize);
+    assert!(std::mem::offset_of!(Class, body) == 136usize);
+    assert!(std::mem::offset_of!(Class, r#abstract) == 149usize);
+    assert!(std::mem::offset_of!(Class, declare) == 150usize);
+    assert!(std::mem::offset_of!(Class, scope_id) == 144usize);
     assert!(size_of::<ClassType>() == 1usize);
     assert!(align_of::<ClassType>() == 1usize);
     assert!(size_of::<ClassBody>() == 24usize);
     assert!(align_of::<ClassBody>() == 4usize);
-    assert!(std::mem::offset_of!(ClassBody, span) == 0usize);
-    assert!(std::mem::offset_of!(ClassBody, body) == 8usize);
+    assert!(std::mem::offset_of!(ClassBody, span) == 32usize);
+    assert!(std::mem::offset_of!(ClassBody, body) == 0usize);
     assert!(size_of::<ClassElement>() == 8usize);
     assert!(align_of::<ClassElement>() == 4usize);
-    assert!(size_of::<MethodDefinition>() == 48usize);
+    assert!(size_of::<MethodDefinition>() == 44usize);
     assert!(align_of::<MethodDefinition>() == 4usize);
-    assert!(std::mem::offset_of!(MethodDefinition, r#type) == 0usize);
-    assert!(std::mem::offset_of!(MethodDefinition, span) == 4usize);
-    assert!(std::mem::offset_of!(MethodDefinition, decorators) == 16usize);
-    assert!(std::mem::offset_of!(MethodDefinition, key) == 48usize);
-    assert!(std::mem::offset_of!(MethodDefinition, value) == 64usize);
-    assert!(std::mem::offset_of!(MethodDefinition, kind) == 72usize);
-    assert!(std::mem::offset_of!(MethodDefinition, computed) == 73usize);
-    assert!(std::mem::offset_of!(MethodDefinition, r#static) == 74usize);
-    assert!(std::mem::offset_of!(MethodDefinition, r#override) == 75usize);
-    assert!(std::mem::offset_of!(MethodDefinition, optional) == 76usize);
-    assert!(std::mem::offset_of!(MethodDefinition, accessibility) == 77usize);
+    assert!(std::mem::offset_of!(MethodDefinition, r#type) == 64usize);
+    assert!(std::mem::offset_of!(MethodDefinition, span) == 48usize);
+    assert!(std::mem::offset_of!(MethodDefinition, decorators) == 0usize);
+    assert!(std::mem::offset_of!(MethodDefinition, key) == 32usize);
+    assert!(std::mem::offset_of!(MethodDefinition, value) == 56usize);
+    assert!(std::mem::offset_of!(MethodDefinition, kind) == 65usize);
+    assert!(std::mem::offset_of!(MethodDefinition, computed) == 66usize);
+    assert!(std::mem::offset_of!(MethodDefinition, r#static) == 67usize);
+    assert!(std::mem::offset_of!(MethodDefinition, r#override) == 68usize);
+    assert!(std::mem::offset_of!(MethodDefinition, optional) == 69usize);
+    assert!(std::mem::offset_of!(MethodDefinition, accessibility) == 70usize);
     assert!(size_of::<MethodDefinitionType>() == 1usize);
     assert!(align_of::<MethodDefinitionType>() == 1usize);
-    assert!(size_of::<PropertyDefinition>() == 60usize);
+    assert!(size_of::<PropertyDefinition>() == 56usize);
     assert!(align_of::<PropertyDefinition>() == 4usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, r#type) == 0usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, span) == 4usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, decorators) == 16usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, key) == 48usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, value) == 64usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, computed) == 80usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, r#static) == 81usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, declare) == 82usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, r#override) == 83usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, optional) == 84usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, definite) == 85usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, readonly) == 86usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, type_annotation) == 88usize);
-    assert!(std::mem::offset_of!(PropertyDefinition, accessibility) == 96usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, r#type) == 80usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, span) == 64usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, decorators) == 0usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, key) == 32usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, value) == 48usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, computed) == 81usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, r#static) == 82usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, declare) == 83usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, r#override) == 84usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, optional) == 85usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, definite) == 86usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, readonly) == 87usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, type_annotation) == 72usize);
+    assert!(std::mem::offset_of!(PropertyDefinition, accessibility) == 88usize);
     assert!(size_of::<PropertyDefinitionType>() == 1usize);
     assert!(align_of::<PropertyDefinitionType>() == 1usize);
     assert!(size_of::<MethodDefinitionKind>() == 1usize);
     assert!(align_of::<MethodDefinitionKind>() == 1usize);
     assert!(size_of::<PrivateIdentifier>() == 16usize);
     assert!(align_of::<PrivateIdentifier>() == 4usize);
-    assert!(std::mem::offset_of!(PrivateIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(PrivateIdentifier, name) == 8usize);
+    assert!(std::mem::offset_of!(PrivateIdentifier, span) == 16usize);
+    assert!(std::mem::offset_of!(PrivateIdentifier, name) == 0usize);
     assert!(size_of::<StaticBlock>() == 28usize);
     assert!(align_of::<StaticBlock>() == 4usize);
-    assert!(std::mem::offset_of!(StaticBlock, span) == 0usize);
-    assert!(std::mem::offset_of!(StaticBlock, body) == 8usize);
+    assert!(std::mem::offset_of!(StaticBlock, span) == 32usize);
+    assert!(std::mem::offset_of!(StaticBlock, body) == 0usize);
     assert!(std::mem::offset_of!(StaticBlock, scope_id) == 40usize);
     assert!(size_of::<ModuleDeclaration>() == 8usize);
     assert!(align_of::<ModuleDeclaration>() == 4usize);
     assert!(size_of::<AccessorPropertyType>() == 1usize);
     assert!(align_of::<AccessorPropertyType>() == 1usize);
-    assert!(size_of::<AccessorProperty>() == 48usize);
+    assert!(size_of::<AccessorProperty>() == 44usize);
     assert!(align_of::<AccessorProperty>() == 4usize);
-    assert!(std::mem::offset_of!(AccessorProperty, r#type) == 0usize);
-    assert!(std::mem::offset_of!(AccessorProperty, span) == 4usize);
-    assert!(std::mem::offset_of!(AccessorProperty, decorators) == 16usize);
-    assert!(std::mem::offset_of!(AccessorProperty, key) == 48usize);
-    assert!(std::mem::offset_of!(AccessorProperty, value) == 64usize);
-    assert!(std::mem::offset_of!(AccessorProperty, computed) == 80usize);
-    assert!(std::mem::offset_of!(AccessorProperty, r#static) == 81usize);
+    assert!(std::mem::offset_of!(AccessorProperty, r#type) == 72usize);
+    assert!(std::mem::offset_of!(AccessorProperty, span) == 64usize);
+    assert!(std::mem::offset_of!(AccessorProperty, decorators) == 0usize);
+    assert!(std::mem::offset_of!(AccessorProperty, key) == 32usize);
+    assert!(std::mem::offset_of!(AccessorProperty, value) == 48usize);
+    assert!(std::mem::offset_of!(AccessorProperty, computed) == 73usize);
+    assert!(std::mem::offset_of!(AccessorProperty, r#static) == 74usize);
     assert!(size_of::<ImportExpression>() == 32usize);
     assert!(align_of::<ImportExpression>() == 4usize);
-    assert!(std::mem::offset_of!(ImportExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportExpression, source) == 8usize);
-    assert!(std::mem::offset_of!(ImportExpression, arguments) == 24usize);
+    assert!(std::mem::offset_of!(ImportExpression, span) == 48usize);
+    assert!(std::mem::offset_of!(ImportExpression, source) == 32usize);
+    assert!(std::mem::offset_of!(ImportExpression, arguments) == 0usize);
     assert!(size_of::<ImportDeclaration>() == 84usize);
     assert!(align_of::<ImportDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(ImportDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportDeclaration, specifiers) == 8usize);
-    assert!(std::mem::offset_of!(ImportDeclaration, source) == 40usize);
-    assert!(std::mem::offset_of!(ImportDeclaration, with_clause) == 64usize);
+    assert!(std::mem::offset_of!(ImportDeclaration, span) == 120usize);
+    assert!(std::mem::offset_of!(ImportDeclaration, specifiers) == 64usize);
+    assert!(std::mem::offset_of!(ImportDeclaration, source) == 96usize);
+    assert!(std::mem::offset_of!(ImportDeclaration, with_clause) == 0usize);
     assert!(std::mem::offset_of!(ImportDeclaration, import_kind) == 128usize);
     assert!(size_of::<ImportDeclarationSpecifier>() == 8usize);
     assert!(align_of::<ImportDeclarationSpecifier>() == 4usize);
     assert!(size_of::<ImportSpecifier>() == 60usize);
     assert!(align_of::<ImportSpecifier>() == 4usize);
-    assert!(std::mem::offset_of!(ImportSpecifier, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportSpecifier, imported) == 8usize);
-    assert!(std::mem::offset_of!(ImportSpecifier, local) == 48usize);
+    assert!(std::mem::offset_of!(ImportSpecifier, span) == 72usize);
+    assert!(std::mem::offset_of!(ImportSpecifier, imported) == 0usize);
+    assert!(std::mem::offset_of!(ImportSpecifier, local) == 40usize);
     assert!(std::mem::offset_of!(ImportSpecifier, import_kind) == 80usize);
     assert!(size_of::<ImportDefaultSpecifier>() == 28usize);
     assert!(align_of::<ImportDefaultSpecifier>() == 4usize);
-    assert!(std::mem::offset_of!(ImportDefaultSpecifier, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportDefaultSpecifier, local) == 8usize);
+    assert!(std::mem::offset_of!(ImportDefaultSpecifier, span) == 32usize);
+    assert!(std::mem::offset_of!(ImportDefaultSpecifier, local) == 0usize);
     assert!(size_of::<ImportNamespaceSpecifier>() == 28usize);
     assert!(align_of::<ImportNamespaceSpecifier>() == 4usize);
-    assert!(std::mem::offset_of!(ImportNamespaceSpecifier, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportNamespaceSpecifier, local) == 8usize);
+    assert!(std::mem::offset_of!(ImportNamespaceSpecifier, span) == 32usize);
+    assert!(std::mem::offset_of!(ImportNamespaceSpecifier, local) == 0usize);
     assert!(size_of::<WithClause>() == 40usize);
     assert!(align_of::<WithClause>() == 4usize);
-    assert!(std::mem::offset_of!(WithClause, span) == 0usize);
-    assert!(std::mem::offset_of!(WithClause, attributes_keyword) == 8usize);
-    assert!(std::mem::offset_of!(WithClause, with_entries) == 32usize);
+    assert!(std::mem::offset_of!(WithClause, span) == 56usize);
+    assert!(std::mem::offset_of!(WithClause, attributes_keyword) == 32usize);
+    assert!(std::mem::offset_of!(WithClause, with_entries) == 0usize);
     assert!(size_of::<ImportAttribute>() == 44usize);
     assert!(align_of::<ImportAttribute>() == 4usize);
-    assert!(std::mem::offset_of!(ImportAttribute, span) == 0usize);
-    assert!(std::mem::offset_of!(ImportAttribute, key) == 8usize);
-    assert!(std::mem::offset_of!(ImportAttribute, value) == 40usize);
+    assert!(std::mem::offset_of!(ImportAttribute, span) == 56usize);
+    assert!(std::mem::offset_of!(ImportAttribute, key) == 0usize);
+    assert!(std::mem::offset_of!(ImportAttribute, value) == 32usize);
     assert!(size_of::<ImportAttributeKey>() == 20usize);
     assert!(align_of::<ImportAttributeKey>() == 4usize);
     assert!(size_of::<ExportNamedDeclaration>() == 92usize);
     assert!(align_of::<ExportNamedDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, declaration) == 8usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, specifiers) == 24usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, source) == 56usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, export_kind) == 80usize);
-    assert!(std::mem::offset_of!(ExportNamedDeclaration, with_clause) == 88usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, span) == 136usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, declaration) == 120usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, specifiers) == 64usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, source) == 96usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, export_kind) == 144usize);
+    assert!(std::mem::offset_of!(ExportNamedDeclaration, with_clause) == 0usize);
     assert!(size_of::<ExportDefaultDeclaration>() == 44usize);
     assert!(align_of::<ExportDefaultDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(ExportDefaultDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(ExportDefaultDeclaration, declaration) == 8usize);
-    assert!(std::mem::offset_of!(ExportDefaultDeclaration, exported) == 24usize);
+    assert!(std::mem::offset_of!(ExportDefaultDeclaration, span) == 56usize);
+    assert!(std::mem::offset_of!(ExportDefaultDeclaration, declaration) == 40usize);
+    assert!(std::mem::offset_of!(ExportDefaultDeclaration, exported) == 0usize);
     assert!(size_of::<ExportAllDeclaration>() == 96usize);
     assert!(align_of::<ExportAllDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(ExportAllDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(ExportAllDeclaration, exported) == 8usize);
-    assert!(std::mem::offset_of!(ExportAllDeclaration, source) == 48usize);
-    assert!(std::mem::offset_of!(ExportAllDeclaration, with_clause) == 72usize);
+    assert!(std::mem::offset_of!(ExportAllDeclaration, span) == 128usize);
+    assert!(std::mem::offset_of!(ExportAllDeclaration, exported) == 64usize);
+    assert!(std::mem::offset_of!(ExportAllDeclaration, source) == 104usize);
+    assert!(std::mem::offset_of!(ExportAllDeclaration, with_clause) == 0usize);
     assert!(std::mem::offset_of!(ExportAllDeclaration, export_kind) == 136usize);
     assert!(size_of::<ExportSpecifier>() == 68usize);
     assert!(align_of::<ExportSpecifier>() == 4usize);
-    assert!(std::mem::offset_of!(ExportSpecifier, span) == 0usize);
-    assert!(std::mem::offset_of!(ExportSpecifier, local) == 8usize);
-    assert!(std::mem::offset_of!(ExportSpecifier, exported) == 48usize);
+    assert!(std::mem::offset_of!(ExportSpecifier, span) == 80usize);
+    assert!(std::mem::offset_of!(ExportSpecifier, local) == 0usize);
+    assert!(std::mem::offset_of!(ExportSpecifier, exported) == 40usize);
     assert!(std::mem::offset_of!(ExportSpecifier, export_kind) == 88usize);
     assert!(size_of::<ExportDefaultDeclarationKind>() == 8usize);
     assert!(align_of::<ExportDefaultDeclarationKind>() == 4usize);
@@ -1766,90 +1766,90 @@ const _: () = {
     assert!(align_of::<ModuleExportName>() == 4usize);
     assert!(size_of::<TSThisParameter>() == 28usize);
     assert!(align_of::<TSThisParameter>() == 4usize);
-    assert!(std::mem::offset_of!(TSThisParameter, span) == 0usize);
-    assert!(std::mem::offset_of!(TSThisParameter, this) == 8usize);
+    assert!(std::mem::offset_of!(TSThisParameter, span) == 24usize);
+    assert!(std::mem::offset_of!(TSThisParameter, this) == 0usize);
     assert!(std::mem::offset_of!(TSThisParameter, type_annotation) == 32usize);
     assert!(size_of::<TSEnumDeclaration>() == 52usize);
     assert!(align_of::<TSEnumDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, members) == 40usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, r#const) == 72usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, declare) == 73usize);
-    assert!(std::mem::offset_of!(TSEnumDeclaration, scope_id) == 76usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, span) == 64usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, members) == 32usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, r#const) == 76usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, declare) == 77usize);
+    assert!(std::mem::offset_of!(TSEnumDeclaration, scope_id) == 72usize);
     assert!(size_of::<TSEnumMember>() == 24usize);
     assert!(align_of::<TSEnumMember>() == 4usize);
-    assert!(std::mem::offset_of!(TSEnumMember, span) == 0usize);
-    assert!(std::mem::offset_of!(TSEnumMember, id) == 8usize);
-    assert!(std::mem::offset_of!(TSEnumMember, initializer) == 24usize);
+    assert!(std::mem::offset_of!(TSEnumMember, span) == 32usize);
+    assert!(std::mem::offset_of!(TSEnumMember, id) == 0usize);
+    assert!(std::mem::offset_of!(TSEnumMember, initializer) == 16usize);
     assert!(size_of::<TSEnumMemberName>() == 8usize);
     assert!(align_of::<TSEnumMemberName>() == 4usize);
     assert!(size_of::<TSTypeAnnotation>() == 16usize);
     assert!(align_of::<TSTypeAnnotation>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeAnnotation, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeAnnotation, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeAnnotation, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeAnnotation, type_annotation) == 0usize);
     assert!(size_of::<TSLiteralType>() == 16usize);
     assert!(align_of::<TSLiteralType>() == 4usize);
-    assert!(std::mem::offset_of!(TSLiteralType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSLiteralType, literal) == 8usize);
+    assert!(std::mem::offset_of!(TSLiteralType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSLiteralType, literal) == 0usize);
     assert!(size_of::<TSLiteral>() == 8usize);
     assert!(align_of::<TSLiteral>() == 4usize);
     assert!(size_of::<TSType>() == 8usize);
     assert!(align_of::<TSType>() == 4usize);
     assert!(size_of::<TSConditionalType>() == 44usize);
     assert!(align_of::<TSConditionalType>() == 4usize);
-    assert!(std::mem::offset_of!(TSConditionalType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSConditionalType, check_type) == 8usize);
-    assert!(std::mem::offset_of!(TSConditionalType, extends_type) == 24usize);
-    assert!(std::mem::offset_of!(TSConditionalType, true_type) == 40usize);
-    assert!(std::mem::offset_of!(TSConditionalType, false_type) == 56usize);
+    assert!(std::mem::offset_of!(TSConditionalType, span) == 64usize);
+    assert!(std::mem::offset_of!(TSConditionalType, check_type) == 0usize);
+    assert!(std::mem::offset_of!(TSConditionalType, extends_type) == 16usize);
+    assert!(std::mem::offset_of!(TSConditionalType, true_type) == 32usize);
+    assert!(std::mem::offset_of!(TSConditionalType, false_type) == 48usize);
     assert!(std::mem::offset_of!(TSConditionalType, scope_id) == 72usize);
     assert!(size_of::<TSUnionType>() == 24usize);
     assert!(align_of::<TSUnionType>() == 4usize);
-    assert!(std::mem::offset_of!(TSUnionType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSUnionType, types) == 8usize);
+    assert!(std::mem::offset_of!(TSUnionType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSUnionType, types) == 0usize);
     assert!(size_of::<TSIntersectionType>() == 24usize);
     assert!(align_of::<TSIntersectionType>() == 4usize);
-    assert!(std::mem::offset_of!(TSIntersectionType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSIntersectionType, types) == 8usize);
+    assert!(std::mem::offset_of!(TSIntersectionType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSIntersectionType, types) == 0usize);
     assert!(size_of::<TSParenthesizedType>() == 16usize);
     assert!(align_of::<TSParenthesizedType>() == 4usize);
-    assert!(std::mem::offset_of!(TSParenthesizedType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSParenthesizedType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(TSParenthesizedType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSParenthesizedType, type_annotation) == 0usize);
     assert!(size_of::<TSTypeOperator>() == 20usize);
     assert!(align_of::<TSTypeOperator>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeOperator, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeOperator, operator) == 8usize);
-    assert!(std::mem::offset_of!(TSTypeOperator, type_annotation) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeOperator, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeOperator, operator) == 24usize);
+    assert!(std::mem::offset_of!(TSTypeOperator, type_annotation) == 0usize);
     assert!(size_of::<TSTypeOperatorOperator>() == 1usize);
     assert!(align_of::<TSTypeOperatorOperator>() == 1usize);
     assert!(size_of::<TSArrayType>() == 16usize);
     assert!(align_of::<TSArrayType>() == 4usize);
-    assert!(std::mem::offset_of!(TSArrayType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSArrayType, element_type) == 8usize);
+    assert!(std::mem::offset_of!(TSArrayType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSArrayType, element_type) == 0usize);
     assert!(size_of::<TSIndexedAccessType>() == 24usize);
     assert!(align_of::<TSIndexedAccessType>() == 4usize);
-    assert!(std::mem::offset_of!(TSIndexedAccessType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSIndexedAccessType, object_type) == 8usize);
-    assert!(std::mem::offset_of!(TSIndexedAccessType, index_type) == 24usize);
+    assert!(std::mem::offset_of!(TSIndexedAccessType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSIndexedAccessType, object_type) == 0usize);
+    assert!(std::mem::offset_of!(TSIndexedAccessType, index_type) == 16usize);
     assert!(size_of::<TSTupleType>() == 24usize);
     assert!(align_of::<TSTupleType>() == 4usize);
-    assert!(std::mem::offset_of!(TSTupleType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTupleType, element_types) == 8usize);
+    assert!(std::mem::offset_of!(TSTupleType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTupleType, element_types) == 0usize);
     assert!(size_of::<TSNamedTupleMember>() == 36usize);
     assert!(align_of::<TSNamedTupleMember>() == 4usize);
-    assert!(std::mem::offset_of!(TSNamedTupleMember, span) == 0usize);
-    assert!(std::mem::offset_of!(TSNamedTupleMember, element_type) == 8usize);
-    assert!(std::mem::offset_of!(TSNamedTupleMember, label) == 24usize);
+    assert!(std::mem::offset_of!(TSNamedTupleMember, span) == 40usize);
+    assert!(std::mem::offset_of!(TSNamedTupleMember, element_type) == 24usize);
+    assert!(std::mem::offset_of!(TSNamedTupleMember, label) == 0usize);
     assert!(std::mem::offset_of!(TSNamedTupleMember, optional) == 48usize);
     assert!(size_of::<TSOptionalType>() == 16usize);
     assert!(align_of::<TSOptionalType>() == 4usize);
-    assert!(std::mem::offset_of!(TSOptionalType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSOptionalType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(TSOptionalType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSOptionalType, type_annotation) == 0usize);
     assert!(size_of::<TSRestType>() == 16usize);
     assert!(align_of::<TSRestType>() == 4usize);
-    assert!(std::mem::offset_of!(TSRestType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSRestType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(TSRestType, span) == 16usize);
+    assert!(std::mem::offset_of!(TSRestType, type_annotation) == 0usize);
     assert!(size_of::<TSTupleElement>() == 8usize);
     assert!(align_of::<TSTupleElement>() == 4usize);
     assert!(size_of::<TSAnyKeyword>() == 8usize);
@@ -1896,81 +1896,81 @@ const _: () = {
     assert!(std::mem::offset_of!(TSBigIntKeyword, span) == 0usize);
     assert!(size_of::<TSTypeReference>() == 20usize);
     assert!(align_of::<TSTypeReference>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeReference, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeReference, type_name) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeReference, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeReference, type_name) == 0usize);
     assert!(std::mem::offset_of!(TSTypeReference, type_parameters) == 24usize);
     assert!(size_of::<TSTypeName>() == 8usize);
     assert!(align_of::<TSTypeName>() == 4usize);
     assert!(size_of::<TSQualifiedName>() == 32usize);
     assert!(align_of::<TSQualifiedName>() == 4usize);
-    assert!(std::mem::offset_of!(TSQualifiedName, span) == 0usize);
-    assert!(std::mem::offset_of!(TSQualifiedName, left) == 8usize);
-    assert!(std::mem::offset_of!(TSQualifiedName, right) == 24usize);
+    assert!(std::mem::offset_of!(TSQualifiedName, span) == 40usize);
+    assert!(std::mem::offset_of!(TSQualifiedName, left) == 24usize);
+    assert!(std::mem::offset_of!(TSQualifiedName, right) == 0usize);
     assert!(size_of::<TSTypeParameterInstantiation>() == 24usize);
     assert!(align_of::<TSTypeParameterInstantiation>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeParameterInstantiation, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeParameterInstantiation, params) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeParameterInstantiation, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeParameterInstantiation, params) == 0usize);
     assert!(size_of::<TSTypeParameter>() == 48usize);
     assert!(align_of::<TSTypeParameter>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeParameter, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeParameter, name) == 8usize);
-    assert!(std::mem::offset_of!(TSTypeParameter, constraint) == 40usize);
-    assert!(std::mem::offset_of!(TSTypeParameter, default) == 56usize);
+    assert!(std::mem::offset_of!(TSTypeParameter, span) == 64usize);
+    assert!(std::mem::offset_of!(TSTypeParameter, name) == 0usize);
+    assert!(std::mem::offset_of!(TSTypeParameter, constraint) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeParameter, default) == 48usize);
     assert!(std::mem::offset_of!(TSTypeParameter, r#in) == 72usize);
     assert!(std::mem::offset_of!(TSTypeParameter, out) == 73usize);
     assert!(std::mem::offset_of!(TSTypeParameter, r#const) == 74usize);
     assert!(size_of::<TSTypeParameterDeclaration>() == 24usize);
     assert!(align_of::<TSTypeParameterDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeParameterDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeParameterDeclaration, params) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeParameterDeclaration, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeParameterDeclaration, params) == 0usize);
     assert!(size_of::<TSTypeAliasDeclaration>() == 48usize);
     assert!(align_of::<TSTypeAliasDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, type_parameters) == 40usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, type_annotation) == 48usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, declare) == 64usize);
-    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, scope_id) == 68usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, span) == 48usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, type_parameters) == 56usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, type_annotation) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, declare) == 68usize);
+    assert!(std::mem::offset_of!(TSTypeAliasDeclaration, scope_id) == 64usize);
     assert!(size_of::<TSAccessibility>() == 1usize);
     assert!(align_of::<TSAccessibility>() == 1usize);
     assert!(size_of::<TSClassImplements>() == 20usize);
     assert!(align_of::<TSClassImplements>() == 4usize);
-    assert!(std::mem::offset_of!(TSClassImplements, span) == 0usize);
-    assert!(std::mem::offset_of!(TSClassImplements, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSClassImplements, span) == 16usize);
+    assert!(std::mem::offset_of!(TSClassImplements, expression) == 0usize);
     assert!(std::mem::offset_of!(TSClassImplements, type_parameters) == 24usize);
     assert!(size_of::<TSInterfaceDeclaration>() == 60usize);
     assert!(align_of::<TSInterfaceDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, extends) == 40usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, span) == 64usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, extends) == 32usize);
     assert!(std::mem::offset_of!(TSInterfaceDeclaration, type_parameters) == 72usize);
     assert!(std::mem::offset_of!(TSInterfaceDeclaration, body) == 80usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, declare) == 88usize);
-    assert!(std::mem::offset_of!(TSInterfaceDeclaration, scope_id) == 92usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, declare) == 92usize);
+    assert!(std::mem::offset_of!(TSInterfaceDeclaration, scope_id) == 88usize);
     assert!(size_of::<TSInterfaceBody>() == 24usize);
     assert!(align_of::<TSInterfaceBody>() == 4usize);
-    assert!(std::mem::offset_of!(TSInterfaceBody, span) == 0usize);
-    assert!(std::mem::offset_of!(TSInterfaceBody, body) == 8usize);
+    assert!(std::mem::offset_of!(TSInterfaceBody, span) == 32usize);
+    assert!(std::mem::offset_of!(TSInterfaceBody, body) == 0usize);
     assert!(size_of::<TSPropertySignature>() == 24usize);
     assert!(align_of::<TSPropertySignature>() == 4usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, span) == 0usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, computed) == 8usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, optional) == 9usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, readonly) == 10usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, key) == 16usize);
-    assert!(std::mem::offset_of!(TSPropertySignature, type_annotation) == 32usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, span) == 16usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, computed) == 32usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, optional) == 33usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, readonly) == 34usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, key) == 0usize);
+    assert!(std::mem::offset_of!(TSPropertySignature, type_annotation) == 24usize);
     assert!(size_of::<TSSignature>() == 8usize);
     assert!(align_of::<TSSignature>() == 4usize);
     assert!(size_of::<TSIndexSignature>() == 32usize);
     assert!(align_of::<TSIndexSignature>() == 4usize);
-    assert!(std::mem::offset_of!(TSIndexSignature, span) == 0usize);
-    assert!(std::mem::offset_of!(TSIndexSignature, parameters) == 8usize);
+    assert!(std::mem::offset_of!(TSIndexSignature, span) == 32usize);
+    assert!(std::mem::offset_of!(TSIndexSignature, parameters) == 0usize);
     assert!(std::mem::offset_of!(TSIndexSignature, type_annotation) == 40usize);
     assert!(std::mem::offset_of!(TSIndexSignature, readonly) == 48usize);
     assert!(size_of::<TSCallSignatureDeclaration>() == 48usize);
     assert!(align_of::<TSCallSignatureDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(TSCallSignatureDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSCallSignatureDeclaration, this_param) == 8usize);
+    assert!(std::mem::offset_of!(TSCallSignatureDeclaration, span) == 40usize);
+    assert!(std::mem::offset_of!(TSCallSignatureDeclaration, this_param) == 0usize);
     assert!(std::mem::offset_of!(TSCallSignatureDeclaration, params) == 48usize);
     assert!(std::mem::offset_of!(TSCallSignatureDeclaration, return_type) == 56usize);
     assert!(std::mem::offset_of!(TSCallSignatureDeclaration, type_parameters) == 64usize);
@@ -1978,16 +1978,16 @@ const _: () = {
     assert!(align_of::<TSMethodSignatureKind>() == 1usize);
     assert!(size_of::<TSMethodSignature>() == 64usize);
     assert!(align_of::<TSMethodSignature>() == 4usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, span) == 0usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, key) == 8usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, computed) == 24usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, optional) == 25usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, kind) == 26usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, this_param) == 32usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, params) == 72usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, return_type) == 80usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, type_parameters) == 88usize);
-    assert!(std::mem::offset_of!(TSMethodSignature, scope_id) == 96usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, span) == 56usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, key) == 40usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, computed) == 92usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, optional) == 93usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, kind) == 94usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, this_param) == 0usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, params) == 64usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, return_type) == 72usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, type_parameters) == 80usize);
+    assert!(std::mem::offset_of!(TSMethodSignature, scope_id) == 88usize);
     assert!(size_of::<TSConstructSignatureDeclaration>() == 24usize);
     assert!(align_of::<TSConstructSignatureDeclaration>() == 4usize);
     assert!(std::mem::offset_of!(TSConstructSignatureDeclaration, span) == 0usize);
@@ -1997,30 +1997,30 @@ const _: () = {
     assert!(std::mem::offset_of!(TSConstructSignatureDeclaration, scope_id) == 32usize);
     assert!(size_of::<TSIndexSignatureName>() == 20usize);
     assert!(align_of::<TSIndexSignatureName>() == 4usize);
-    assert!(std::mem::offset_of!(TSIndexSignatureName, span) == 0usize);
-    assert!(std::mem::offset_of!(TSIndexSignatureName, name) == 8usize);
+    assert!(std::mem::offset_of!(TSIndexSignatureName, span) == 16usize);
+    assert!(std::mem::offset_of!(TSIndexSignatureName, name) == 0usize);
     assert!(std::mem::offset_of!(TSIndexSignatureName, type_annotation) == 24usize);
     assert!(size_of::<TSInterfaceHeritage>() == 20usize);
     assert!(align_of::<TSInterfaceHeritage>() == 4usize);
-    assert!(std::mem::offset_of!(TSInterfaceHeritage, span) == 0usize);
-    assert!(std::mem::offset_of!(TSInterfaceHeritage, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSInterfaceHeritage, span) == 16usize);
+    assert!(std::mem::offset_of!(TSInterfaceHeritage, expression) == 0usize);
     assert!(std::mem::offset_of!(TSInterfaceHeritage, type_parameters) == 24usize);
     assert!(size_of::<TSTypePredicate>() == 28usize);
     assert!(align_of::<TSTypePredicate>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypePredicate, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypePredicate, parameter_name) == 8usize);
-    assert!(std::mem::offset_of!(TSTypePredicate, asserts) == 24usize);
-    assert!(std::mem::offset_of!(TSTypePredicate, type_annotation) == 32usize);
+    assert!(std::mem::offset_of!(TSTypePredicate, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypePredicate, parameter_name) == 0usize);
+    assert!(std::mem::offset_of!(TSTypePredicate, asserts) == 32usize);
+    assert!(std::mem::offset_of!(TSTypePredicate, type_annotation) == 24usize);
     assert!(size_of::<TSTypePredicateName>() == 12usize);
     assert!(align_of::<TSTypePredicateName>() == 4usize);
     assert!(size_of::<TSModuleDeclaration>() == 44usize);
     assert!(align_of::<TSModuleDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, body) == 40usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, kind) == 56usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, declare) == 57usize);
-    assert!(std::mem::offset_of!(TSModuleDeclaration, scope_id) == 60usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, span) == 48usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, body) == 32usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, kind) == 60usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, declare) == 61usize);
+    assert!(std::mem::offset_of!(TSModuleDeclaration, scope_id) == 56usize);
     assert!(size_of::<TSModuleDeclarationKind>() == 1usize);
     assert!(align_of::<TSModuleDeclarationKind>() == 1usize);
     assert!(size_of::<TSModuleDeclarationName>() == 20usize);
@@ -2029,159 +2029,159 @@ const _: () = {
     assert!(align_of::<TSModuleDeclarationBody>() == 4usize);
     assert!(size_of::<TSModuleBlock>() == 40usize);
     assert!(align_of::<TSModuleBlock>() == 4usize);
-    assert!(std::mem::offset_of!(TSModuleBlock, span) == 0usize);
-    assert!(std::mem::offset_of!(TSModuleBlock, directives) == 8usize);
-    assert!(std::mem::offset_of!(TSModuleBlock, body) == 40usize);
+    assert!(std::mem::offset_of!(TSModuleBlock, span) == 64usize);
+    assert!(std::mem::offset_of!(TSModuleBlock, directives) == 0usize);
+    assert!(std::mem::offset_of!(TSModuleBlock, body) == 32usize);
     assert!(size_of::<TSTypeLiteral>() == 24usize);
     assert!(align_of::<TSTypeLiteral>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeLiteral, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeLiteral, members) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeLiteral, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeLiteral, members) == 0usize);
     assert!(size_of::<TSInferType>() == 12usize);
     assert!(align_of::<TSInferType>() == 4usize);
     assert!(std::mem::offset_of!(TSInferType, span) == 0usize);
     assert!(std::mem::offset_of!(TSInferType, type_parameter) == 8usize);
     assert!(size_of::<TSTypeQuery>() == 20usize);
     assert!(align_of::<TSTypeQuery>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeQuery, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeQuery, expr_name) == 8usize);
+    assert!(std::mem::offset_of!(TSTypeQuery, span) == 16usize);
+    assert!(std::mem::offset_of!(TSTypeQuery, expr_name) == 0usize);
     assert!(std::mem::offset_of!(TSTypeQuery, type_parameters) == 24usize);
     assert!(size_of::<TSTypeQueryExprName>() == 8usize);
     assert!(align_of::<TSTypeQueryExprName>() == 4usize);
     assert!(size_of::<TSImportType>() == 56usize);
     assert!(align_of::<TSImportType>() == 4usize);
-    assert!(std::mem::offset_of!(TSImportType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSImportType, is_type_of) == 8usize);
-    assert!(std::mem::offset_of!(TSImportType, parameter) == 16usize);
-    assert!(std::mem::offset_of!(TSImportType, qualifier) == 32usize);
-    assert!(std::mem::offset_of!(TSImportType, attributes) == 48usize);
-    assert!(std::mem::offset_of!(TSImportType, type_parameters) == 88usize);
+    assert!(std::mem::offset_of!(TSImportType, span) == 72usize);
+    assert!(std::mem::offset_of!(TSImportType, is_type_of) == 88usize);
+    assert!(std::mem::offset_of!(TSImportType, parameter) == 40usize);
+    assert!(std::mem::offset_of!(TSImportType, qualifier) == 56usize);
+    assert!(std::mem::offset_of!(TSImportType, attributes) == 0usize);
+    assert!(std::mem::offset_of!(TSImportType, type_parameters) == 80usize);
     assert!(size_of::<TSImportAttributes>() == 24usize);
     assert!(align_of::<TSImportAttributes>() == 4usize);
-    assert!(std::mem::offset_of!(TSImportAttributes, span) == 0usize);
-    assert!(std::mem::offset_of!(TSImportAttributes, elements) == 8usize);
+    assert!(std::mem::offset_of!(TSImportAttributes, span) == 32usize);
+    assert!(std::mem::offset_of!(TSImportAttributes, elements) == 0usize);
     assert!(size_of::<TSImportAttribute>() == 36usize);
     assert!(align_of::<TSImportAttribute>() == 4usize);
-    assert!(std::mem::offset_of!(TSImportAttribute, span) == 0usize);
-    assert!(std::mem::offset_of!(TSImportAttribute, name) == 8usize);
-    assert!(std::mem::offset_of!(TSImportAttribute, value) == 40usize);
+    assert!(std::mem::offset_of!(TSImportAttribute, span) == 48usize);
+    assert!(std::mem::offset_of!(TSImportAttribute, name) == 0usize);
+    assert!(std::mem::offset_of!(TSImportAttribute, value) == 32usize);
     assert!(size_of::<TSImportAttributeName>() == 20usize);
     assert!(align_of::<TSImportAttributeName>() == 4usize);
     assert!(size_of::<TSFunctionType>() == 48usize);
     assert!(align_of::<TSFunctionType>() == 4usize);
-    assert!(std::mem::offset_of!(TSFunctionType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSFunctionType, this_param) == 8usize);
+    assert!(std::mem::offset_of!(TSFunctionType, span) == 40usize);
+    assert!(std::mem::offset_of!(TSFunctionType, this_param) == 0usize);
     assert!(std::mem::offset_of!(TSFunctionType, params) == 48usize);
     assert!(std::mem::offset_of!(TSFunctionType, return_type) == 56usize);
     assert!(std::mem::offset_of!(TSFunctionType, type_parameters) == 64usize);
     assert!(size_of::<TSConstructorType>() == 24usize);
     assert!(align_of::<TSConstructorType>() == 4usize);
     assert!(std::mem::offset_of!(TSConstructorType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSConstructorType, r#abstract) == 8usize);
-    assert!(std::mem::offset_of!(TSConstructorType, params) == 16usize);
-    assert!(std::mem::offset_of!(TSConstructorType, return_type) == 24usize);
-    assert!(std::mem::offset_of!(TSConstructorType, type_parameters) == 32usize);
+    assert!(std::mem::offset_of!(TSConstructorType, r#abstract) == 32usize);
+    assert!(std::mem::offset_of!(TSConstructorType, params) == 8usize);
+    assert!(std::mem::offset_of!(TSConstructorType, return_type) == 16usize);
+    assert!(std::mem::offset_of!(TSConstructorType, type_parameters) == 24usize);
     assert!(size_of::<TSMappedType>() == 36usize);
     assert!(align_of::<TSMappedType>() == 4usize);
-    assert!(std::mem::offset_of!(TSMappedType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSMappedType, type_parameter) == 8usize);
-    assert!(std::mem::offset_of!(TSMappedType, name_type) == 16usize);
-    assert!(std::mem::offset_of!(TSMappedType, type_annotation) == 32usize);
-    assert!(std::mem::offset_of!(TSMappedType, optional) == 48usize);
-    assert!(std::mem::offset_of!(TSMappedType, readonly) == 49usize);
-    assert!(std::mem::offset_of!(TSMappedType, scope_id) == 52usize);
+    assert!(std::mem::offset_of!(TSMappedType, span) == 32usize);
+    assert!(std::mem::offset_of!(TSMappedType, type_parameter) == 40usize);
+    assert!(std::mem::offset_of!(TSMappedType, name_type) == 0usize);
+    assert!(std::mem::offset_of!(TSMappedType, type_annotation) == 16usize);
+    assert!(std::mem::offset_of!(TSMappedType, optional) == 52usize);
+    assert!(std::mem::offset_of!(TSMappedType, readonly) == 53usize);
+    assert!(std::mem::offset_of!(TSMappedType, scope_id) == 48usize);
     assert!(size_of::<TSMappedTypeModifierOperator>() == 1usize);
     assert!(align_of::<TSMappedTypeModifierOperator>() == 1usize);
     assert!(size_of::<TSTemplateLiteralType>() == 40usize);
     assert!(align_of::<TSTemplateLiteralType>() == 4usize);
-    assert!(std::mem::offset_of!(TSTemplateLiteralType, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTemplateLiteralType, quasis) == 8usize);
-    assert!(std::mem::offset_of!(TSTemplateLiteralType, types) == 40usize);
+    assert!(std::mem::offset_of!(TSTemplateLiteralType, span) == 64usize);
+    assert!(std::mem::offset_of!(TSTemplateLiteralType, quasis) == 0usize);
+    assert!(std::mem::offset_of!(TSTemplateLiteralType, types) == 32usize);
     assert!(size_of::<TSAsExpression>() == 24usize);
     assert!(align_of::<TSAsExpression>() == 4usize);
-    assert!(std::mem::offset_of!(TSAsExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TSAsExpression, expression) == 8usize);
-    assert!(std::mem::offset_of!(TSAsExpression, type_annotation) == 24usize);
+    assert!(std::mem::offset_of!(TSAsExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(TSAsExpression, expression) == 0usize);
+    assert!(std::mem::offset_of!(TSAsExpression, type_annotation) == 16usize);
     assert!(size_of::<TSSatisfiesExpression>() == 24usize);
     assert!(align_of::<TSSatisfiesExpression>() == 4usize);
-    assert!(std::mem::offset_of!(TSSatisfiesExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TSSatisfiesExpression, expression) == 8usize);
-    assert!(std::mem::offset_of!(TSSatisfiesExpression, type_annotation) == 24usize);
+    assert!(std::mem::offset_of!(TSSatisfiesExpression, span) == 32usize);
+    assert!(std::mem::offset_of!(TSSatisfiesExpression, expression) == 0usize);
+    assert!(std::mem::offset_of!(TSSatisfiesExpression, type_annotation) == 16usize);
     assert!(size_of::<TSTypeAssertion>() == 24usize);
     assert!(align_of::<TSTypeAssertion>() == 4usize);
-    assert!(std::mem::offset_of!(TSTypeAssertion, span) == 0usize);
-    assert!(std::mem::offset_of!(TSTypeAssertion, expression) == 8usize);
-    assert!(std::mem::offset_of!(TSTypeAssertion, type_annotation) == 24usize);
+    assert!(std::mem::offset_of!(TSTypeAssertion, span) == 32usize);
+    assert!(std::mem::offset_of!(TSTypeAssertion, expression) == 0usize);
+    assert!(std::mem::offset_of!(TSTypeAssertion, type_annotation) == 16usize);
     assert!(size_of::<TSImportEqualsDeclaration>() == 40usize);
     assert!(align_of::<TSImportEqualsDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, id) == 8usize);
-    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, module_reference) == 40usize);
+    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, span) == 48usize);
+    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, id) == 0usize);
+    assert!(std::mem::offset_of!(TSImportEqualsDeclaration, module_reference) == 32usize);
     assert!(std::mem::offset_of!(TSImportEqualsDeclaration, import_kind) == 56usize);
     assert!(size_of::<TSModuleReference>() == 8usize);
     assert!(align_of::<TSModuleReference>() == 4usize);
     assert!(size_of::<TSExternalModuleReference>() == 24usize);
     assert!(align_of::<TSExternalModuleReference>() == 4usize);
-    assert!(std::mem::offset_of!(TSExternalModuleReference, span) == 0usize);
-    assert!(std::mem::offset_of!(TSExternalModuleReference, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSExternalModuleReference, span) == 24usize);
+    assert!(std::mem::offset_of!(TSExternalModuleReference, expression) == 0usize);
     assert!(size_of::<TSNonNullExpression>() == 16usize);
     assert!(align_of::<TSNonNullExpression>() == 4usize);
-    assert!(std::mem::offset_of!(TSNonNullExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TSNonNullExpression, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSNonNullExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(TSNonNullExpression, expression) == 0usize);
     assert!(size_of::<Decorator>() == 16usize);
     assert!(align_of::<Decorator>() == 4usize);
-    assert!(std::mem::offset_of!(Decorator, span) == 0usize);
-    assert!(std::mem::offset_of!(Decorator, expression) == 8usize);
+    assert!(std::mem::offset_of!(Decorator, span) == 16usize);
+    assert!(std::mem::offset_of!(Decorator, expression) == 0usize);
     assert!(size_of::<TSExportAssignment>() == 16usize);
     assert!(align_of::<TSExportAssignment>() == 4usize);
-    assert!(std::mem::offset_of!(TSExportAssignment, span) == 0usize);
-    assert!(std::mem::offset_of!(TSExportAssignment, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSExportAssignment, span) == 16usize);
+    assert!(std::mem::offset_of!(TSExportAssignment, expression) == 0usize);
     assert!(size_of::<TSNamespaceExportDeclaration>() == 24usize);
     assert!(align_of::<TSNamespaceExportDeclaration>() == 4usize);
-    assert!(std::mem::offset_of!(TSNamespaceExportDeclaration, span) == 0usize);
-    assert!(std::mem::offset_of!(TSNamespaceExportDeclaration, id) == 8usize);
+    assert!(std::mem::offset_of!(TSNamespaceExportDeclaration, span) == 24usize);
+    assert!(std::mem::offset_of!(TSNamespaceExportDeclaration, id) == 0usize);
     assert!(size_of::<TSInstantiationExpression>() == 20usize);
     assert!(align_of::<TSInstantiationExpression>() == 4usize);
-    assert!(std::mem::offset_of!(TSInstantiationExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(TSInstantiationExpression, expression) == 8usize);
+    assert!(std::mem::offset_of!(TSInstantiationExpression, span) == 16usize);
+    assert!(std::mem::offset_of!(TSInstantiationExpression, expression) == 0usize);
     assert!(std::mem::offset_of!(TSInstantiationExpression, type_parameters) == 24usize);
     assert!(size_of::<ImportOrExportKind>() == 1usize);
     assert!(align_of::<ImportOrExportKind>() == 1usize);
     assert!(size_of::<JSDocNullableType>() == 20usize);
     assert!(align_of::<JSDocNullableType>() == 4usize);
-    assert!(std::mem::offset_of!(JSDocNullableType, span) == 0usize);
-    assert!(std::mem::offset_of!(JSDocNullableType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(JSDocNullableType, span) == 16usize);
+    assert!(std::mem::offset_of!(JSDocNullableType, type_annotation) == 0usize);
     assert!(std::mem::offset_of!(JSDocNullableType, postfix) == 24usize);
     assert!(size_of::<JSDocNonNullableType>() == 20usize);
     assert!(align_of::<JSDocNonNullableType>() == 4usize);
-    assert!(std::mem::offset_of!(JSDocNonNullableType, span) == 0usize);
-    assert!(std::mem::offset_of!(JSDocNonNullableType, type_annotation) == 8usize);
+    assert!(std::mem::offset_of!(JSDocNonNullableType, span) == 16usize);
+    assert!(std::mem::offset_of!(JSDocNonNullableType, type_annotation) == 0usize);
     assert!(std::mem::offset_of!(JSDocNonNullableType, postfix) == 24usize);
     assert!(size_of::<JSDocUnknownType>() == 8usize);
     assert!(align_of::<JSDocUnknownType>() == 4usize);
     assert!(std::mem::offset_of!(JSDocUnknownType, span) == 0usize);
     assert!(size_of::<JSXElement>() == 32usize);
     assert!(align_of::<JSXElement>() == 4usize);
-    assert!(std::mem::offset_of!(JSXElement, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXElement, opening_element) == 8usize);
-    assert!(std::mem::offset_of!(JSXElement, closing_element) == 16usize);
-    assert!(std::mem::offset_of!(JSXElement, children) == 24usize);
+    assert!(std::mem::offset_of!(JSXElement, span) == 32usize);
+    assert!(std::mem::offset_of!(JSXElement, opening_element) == 40usize);
+    assert!(std::mem::offset_of!(JSXElement, closing_element) == 48usize);
+    assert!(std::mem::offset_of!(JSXElement, children) == 0usize);
     assert!(size_of::<JSXOpeningElement>() == 40usize);
     assert!(align_of::<JSXOpeningElement>() == 4usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, self_closing) == 8usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, name) == 16usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, attributes) == 32usize);
-    assert!(std::mem::offset_of!(JSXOpeningElement, type_parameters) == 64usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, span) == 48usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, self_closing) == 64usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, name) == 32usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, attributes) == 0usize);
+    assert!(std::mem::offset_of!(JSXOpeningElement, type_parameters) == 56usize);
     assert!(size_of::<JSXClosingElement>() == 16usize);
     assert!(align_of::<JSXClosingElement>() == 4usize);
-    assert!(std::mem::offset_of!(JSXClosingElement, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXClosingElement, name) == 8usize);
+    assert!(std::mem::offset_of!(JSXClosingElement, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXClosingElement, name) == 0usize);
     assert!(size_of::<JSXFragment>() == 40usize);
     assert!(align_of::<JSXFragment>() == 4usize);
-    assert!(std::mem::offset_of!(JSXFragment, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXFragment, opening_fragment) == 8usize);
-    assert!(std::mem::offset_of!(JSXFragment, closing_fragment) == 16usize);
-    assert!(std::mem::offset_of!(JSXFragment, children) == 24usize);
+    assert!(std::mem::offset_of!(JSXFragment, span) == 32usize);
+    assert!(std::mem::offset_of!(JSXFragment, opening_fragment) == 40usize);
+    assert!(std::mem::offset_of!(JSXFragment, closing_fragment) == 48usize);
+    assert!(std::mem::offset_of!(JSXFragment, children) == 0usize);
     assert!(size_of::<JSXOpeningFragment>() == 8usize);
     assert!(align_of::<JSXOpeningFragment>() == 4usize);
     assert!(std::mem::offset_of!(JSXOpeningFragment, span) == 0usize);
@@ -2192,20 +2192,20 @@ const _: () = {
     assert!(align_of::<JSXElementName>() == 4usize);
     assert!(size_of::<JSXNamespacedName>() == 40usize);
     assert!(align_of::<JSXNamespacedName>() == 4usize);
-    assert!(std::mem::offset_of!(JSXNamespacedName, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXNamespacedName, namespace) == 8usize);
-    assert!(std::mem::offset_of!(JSXNamespacedName, property) == 32usize);
+    assert!(std::mem::offset_of!(JSXNamespacedName, span) == 48usize);
+    assert!(std::mem::offset_of!(JSXNamespacedName, namespace) == 0usize);
+    assert!(std::mem::offset_of!(JSXNamespacedName, property) == 24usize);
     assert!(size_of::<JSXMemberExpression>() == 32usize);
     assert!(align_of::<JSXMemberExpression>() == 4usize);
-    assert!(std::mem::offset_of!(JSXMemberExpression, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXMemberExpression, object) == 8usize);
-    assert!(std::mem::offset_of!(JSXMemberExpression, property) == 24usize);
+    assert!(std::mem::offset_of!(JSXMemberExpression, span) == 40usize);
+    assert!(std::mem::offset_of!(JSXMemberExpression, object) == 24usize);
+    assert!(std::mem::offset_of!(JSXMemberExpression, property) == 0usize);
     assert!(size_of::<JSXMemberExpressionObject>() == 8usize);
     assert!(align_of::<JSXMemberExpressionObject>() == 4usize);
     assert!(size_of::<JSXExpressionContainer>() == 20usize);
     assert!(align_of::<JSXExpressionContainer>() == 4usize);
-    assert!(std::mem::offset_of!(JSXExpressionContainer, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXExpressionContainer, expression) == 8usize);
+    assert!(std::mem::offset_of!(JSXExpressionContainer, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXExpressionContainer, expression) == 0usize);
     assert!(size_of::<JSXExpression>() == 12usize);
     assert!(align_of::<JSXExpression>() == 4usize);
     assert!(size_of::<JSXEmptyExpression>() == 8usize);
@@ -2215,31 +2215,31 @@ const _: () = {
     assert!(align_of::<JSXAttributeItem>() == 4usize);
     assert!(size_of::<JSXAttribute>() == 24usize);
     assert!(align_of::<JSXAttribute>() == 4usize);
-    assert!(std::mem::offset_of!(JSXAttribute, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXAttribute, name) == 8usize);
-    assert!(std::mem::offset_of!(JSXAttribute, value) == 24usize);
+    assert!(std::mem::offset_of!(JSXAttribute, span) == 32usize);
+    assert!(std::mem::offset_of!(JSXAttribute, name) == 0usize);
+    assert!(std::mem::offset_of!(JSXAttribute, value) == 16usize);
     assert!(size_of::<JSXSpreadAttribute>() == 16usize);
     assert!(align_of::<JSXSpreadAttribute>() == 4usize);
-    assert!(std::mem::offset_of!(JSXSpreadAttribute, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXSpreadAttribute, argument) == 8usize);
+    assert!(std::mem::offset_of!(JSXSpreadAttribute, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXSpreadAttribute, argument) == 0usize);
     assert!(size_of::<JSXAttributeName>() == 8usize);
     assert!(align_of::<JSXAttributeName>() == 4usize);
     assert!(size_of::<JSXAttributeValue>() == 8usize);
     assert!(align_of::<JSXAttributeValue>() == 4usize);
     assert!(size_of::<JSXIdentifier>() == 16usize);
     assert!(align_of::<JSXIdentifier>() == 4usize);
-    assert!(std::mem::offset_of!(JSXIdentifier, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXIdentifier, name) == 8usize);
+    assert!(std::mem::offset_of!(JSXIdentifier, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXIdentifier, name) == 0usize);
     assert!(size_of::<JSXChild>() == 8usize);
     assert!(align_of::<JSXChild>() == 4usize);
     assert!(size_of::<JSXSpreadChild>() == 16usize);
     assert!(align_of::<JSXSpreadChild>() == 4usize);
-    assert!(std::mem::offset_of!(JSXSpreadChild, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXSpreadChild, expression) == 8usize);
+    assert!(std::mem::offset_of!(JSXSpreadChild, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXSpreadChild, expression) == 0usize);
     assert!(size_of::<JSXText>() == 16usize);
     assert!(align_of::<JSXText>() == 4usize);
-    assert!(std::mem::offset_of!(JSXText, span) == 0usize);
-    assert!(std::mem::offset_of!(JSXText, value) == 8usize);
+    assert!(std::mem::offset_of!(JSXText, span) == 16usize);
+    assert!(std::mem::offset_of!(JSXText, value) == 0usize);
 };
 #[cfg(not(any(target_pointer_width = "64", target_pointer_width = "32")))]
 const _: () = panic!("Platforms with pointer width other than 64 or 32 bit are not supported");
diff --git a/crates/oxc_ast/src/generated/assert_repr_rust_layout.rs b/crates/oxc_ast/src/generated/assert_repr_rust_layout.rs
new file mode 100644
index 0000000000000..7f0c8c5dd3676
--- /dev/null
+++ b/crates/oxc_ast/src/generated/assert_repr_rust_layout.rs
@@ -0,0 +1,1899 @@
+use crate::ast::*;
+macro_rules! wrap {
+    ($($tt:tt)*) => {
+        // NOTE: disabled!
+        // $($tt)*
+    };
+}
+const _: () = {
+    {
+        assert!(size_of::<BooleanLiteral>() == 12usize);
+        assert!(align_of::<BooleanLiteral>() == 4usize);
+        wrap!(
+            assert!(std::mem::offset_of!(BooleanLiteral, span) == 0usize);
+            assert!(std::mem::offset_of!(BooleanLiteral, value) == 8usize);
+        );
+    }
+    {
+        assert!(size_of::<NullLiteral>() == 8usize);
+        assert!(align_of::<NullLiteral>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(NullLiteral, span) == 0usize););
+    }
+    {
+        assert!(size_of::<NumericLiteral<'static>>() == 40usize);
+        assert!(align_of::<NumericLiteral<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(NumericLiteral < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(NumericLiteral < 'static >, value) == 24usize);
+            assert!(std::mem::offset_of!(NumericLiteral < 'static >, raw) == 0usize);
+            assert!(std::mem::offset_of!(NumericLiteral < 'static >, base) == 32usize);
+        );
+    }
+    {
+        assert!(size_of::<BigIntLiteral<'static>>() == 32usize);
+        assert!(align_of::<BigIntLiteral<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(BigIntLiteral < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(BigIntLiteral < 'static >, raw) == 0usize);
+            assert!(std::mem::offset_of!(BigIntLiteral < 'static >, base) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<RegExpLiteral<'static>>() == 32usize);
+        assert!(align_of::<RegExpLiteral<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(RegExpLiteral < 'static >, span) == 24usize);
+            assert!(std::mem::offset_of!(RegExpLiteral < 'static >, value) == 32usize);
+            assert!(std::mem::offset_of!(RegExpLiteral < 'static >, regex) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<RegExp<'static>>() == 24usize);
+        assert!(align_of::<RegExp<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(RegExp < 'static >, pattern) == 0usize);
+            assert!(std::mem::offset_of!(RegExp < 'static >, flags) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<EmptyObject>() == 0usize);
+        assert!(align_of::<EmptyObject>() == 1usize);
+        wrap!();
+    }
+    {
+        assert!(size_of::<StringLiteral<'static>>() == 24usize);
+        assert!(align_of::<StringLiteral<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(StringLiteral < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(StringLiteral < 'static >, value) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<Program<'static>>() == 104usize);
+        assert!(align_of::<Program<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(Program < 'static >, span) == 64usize);
+            assert!(std::mem::offset_of!(Program < 'static >, source_type) == 100usize);
+            assert!(std::mem::offset_of!(Program < 'static >, hashbang) == 72usize);
+            assert!(std::mem::offset_of!(Program < 'static >, directives) == 0usize);
+            assert!(std::mem::offset_of!(Program < 'static >, body) == 32usize);
+            assert!(std::mem::offset_of!(Program < 'static >, scope_id) == 96usize);
+        );
+    }
+    {
+        assert!(size_of::<IdentifierName<'static>>() == 24usize);
+        assert!(align_of::<IdentifierName<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(IdentifierName < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(IdentifierName < 'static >, name) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<IdentifierReference<'static>>() == 32usize);
+        assert!(align_of::<IdentifierReference<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(IdentifierReference < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(IdentifierReference < 'static >, name)
+            == 0usize); assert!(std::mem::offset_of!(IdentifierReference < 'static >,
+            reference_id) == 24usize); assert!(std::mem::offset_of!(IdentifierReference <
+            'static >, reference_flag) == 28usize);
+        );
+    }
+    {
+        assert!(size_of::<BindingIdentifier<'static>>() == 32usize);
+        assert!(align_of::<BindingIdentifier<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(BindingIdentifier < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(BindingIdentifier < 'static >, name)
+            == 0usize); assert!(std::mem::offset_of!(BindingIdentifier < 'static >,
+            symbol_id) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<LabelIdentifier<'static>>() == 24usize);
+        assert!(align_of::<LabelIdentifier<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(LabelIdentifier < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(LabelIdentifier < 'static >, name) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<ThisExpression>() == 8usize);
+        assert!(align_of::<ThisExpression>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(ThisExpression, span) == 0usize););
+    }
+    {
+        assert!(size_of::<ArrayExpression<'static>>() == 56usize);
+        assert!(align_of::<ArrayExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ArrayExpression < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(ArrayExpression < 'static >, elements) ==
+            0usize); assert!(std::mem::offset_of!(ArrayExpression < 'static >,
+            trailing_comma) == 40usize);
+        );
+    }
+    {
+        assert!(size_of::<Elision>() == 8usize);
+        assert!(align_of::<Elision>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(Elision, span) == 0usize););
+    }
+    {
+        assert!(size_of::<ObjectExpression<'static>>() == 56usize);
+        assert!(align_of::<ObjectExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ObjectExpression < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(ObjectExpression < 'static >, properties) ==
+            0usize); assert!(std::mem::offset_of!(ObjectExpression < 'static >,
+            trailing_comma) == 40usize);
+        );
+    }
+    {
+        assert!(size_of::<ObjectProperty<'static>>() == 64usize);
+        assert!(align_of::<ObjectProperty<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ObjectProperty < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(ObjectProperty < 'static >, kind) == 56usize);
+            assert!(std::mem::offset_of!(ObjectProperty < 'static >, key) == 0usize);
+            assert!(std::mem::offset_of!(ObjectProperty < 'static >, value) == 32usize);
+            assert!(std::mem::offset_of!(ObjectProperty < 'static >, init) == 16usize);
+            assert!(std::mem::offset_of!(ObjectProperty < 'static >, method) == 57usize);
+            assert!(std::mem::offset_of!(ObjectProperty < 'static >, shorthand) ==
+            58usize); assert!(std::mem::offset_of!(ObjectProperty < 'static >, computed)
+            == 59usize);
+        );
+    }
+    {
+        assert!(size_of::<TemplateLiteral<'static>>() == 72usize);
+        assert!(align_of::<TemplateLiteral<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TemplateLiteral < 'static >, span) == 64usize);
+            assert!(std::mem::offset_of!(TemplateLiteral < 'static >, quasis) == 0usize);
+            assert!(std::mem::offset_of!(TemplateLiteral < 'static >, expressions) ==
+            32usize);
+        );
+    }
+    {
+        assert!(size_of::<TaggedTemplateExpression<'static>>() == 104usize);
+        assert!(align_of::<TaggedTemplateExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TaggedTemplateExpression < 'static >, span) ==
+            88usize); assert!(std::mem::offset_of!(TaggedTemplateExpression < 'static >,
+            tag) == 0usize); assert!(std::mem::offset_of!(TaggedTemplateExpression <
+            'static >, quasi) == 16usize);
+            assert!(std::mem::offset_of!(TaggedTemplateExpression < 'static >,
+            type_parameters) == 96usize);
+        );
+    }
+    {
+        assert!(size_of::<TemplateElement<'static>>() == 48usize);
+        assert!(align_of::<TemplateElement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TemplateElement < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TemplateElement < 'static >, tail) == 40usize);
+            assert!(std::mem::offset_of!(TemplateElement < 'static >, value) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TemplateElementValue<'static>>() == 32usize);
+        assert!(align_of::<TemplateElementValue<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TemplateElementValue < 'static >, raw) ==
+            0usize); assert!(std::mem::offset_of!(TemplateElementValue < 'static >,
+            cooked) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<ComputedMemberExpression<'static>>() == 48usize);
+        assert!(align_of::<ComputedMemberExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ComputedMemberExpression < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(ComputedMemberExpression < 'static >,
+            object) == 0usize); assert!(std::mem::offset_of!(ComputedMemberExpression <
+            'static >, expression) == 16usize);
+            assert!(std::mem::offset_of!(ComputedMemberExpression < 'static >, optional)
+            == 40usize);
+        );
+    }
+    {
+        assert!(size_of::<StaticMemberExpression<'static>>() == 56usize);
+        assert!(align_of::<StaticMemberExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(StaticMemberExpression < 'static >, span) ==
+            40usize); assert!(std::mem::offset_of!(StaticMemberExpression < 'static >,
+            object) == 0usize); assert!(std::mem::offset_of!(StaticMemberExpression <
+            'static >, property) == 16usize);
+            assert!(std::mem::offset_of!(StaticMemberExpression < 'static >, optional) ==
+            48usize);
+        );
+    }
+    {
+        assert!(size_of::<PrivateFieldExpression<'static>>() == 56usize);
+        assert!(align_of::<PrivateFieldExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(PrivateFieldExpression < 'static >, span) ==
+            40usize); assert!(std::mem::offset_of!(PrivateFieldExpression < 'static >,
+            object) == 0usize); assert!(std::mem::offset_of!(PrivateFieldExpression <
+            'static >, field) == 16usize);
+            assert!(std::mem::offset_of!(PrivateFieldExpression < 'static >, optional) ==
+            48usize);
+        );
+    }
+    {
+        assert!(size_of::<CallExpression<'static>>() == 72usize);
+        assert!(align_of::<CallExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(CallExpression < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(CallExpression < 'static >, arguments) ==
+            16usize); assert!(std::mem::offset_of!(CallExpression < 'static >, callee) ==
+            0usize); assert!(std::mem::offset_of!(CallExpression < 'static >,
+            type_parameters) == 56usize); assert!(std::mem::offset_of!(CallExpression <
+            'static >, optional) == 64usize);
+        );
+    }
+    {
+        assert!(size_of::<NewExpression<'static>>() == 64usize);
+        assert!(align_of::<NewExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(NewExpression < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(NewExpression < 'static >, callee) == 0usize);
+            assert!(std::mem::offset_of!(NewExpression < 'static >, arguments) ==
+            16usize); assert!(std::mem::offset_of!(NewExpression < 'static >,
+            type_parameters) == 56usize);
+        );
+    }
+    {
+        assert!(size_of::<MetaProperty<'static>>() == 56usize);
+        assert!(align_of::<MetaProperty<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(MetaProperty < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(MetaProperty < 'static >, meta) == 0usize);
+            assert!(std::mem::offset_of!(MetaProperty < 'static >, property) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<SpreadElement<'static>>() == 24usize);
+        assert!(align_of::<SpreadElement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(SpreadElement < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(SpreadElement < 'static >, argument) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<UpdateExpression<'static>>() == 32usize);
+        assert!(align_of::<UpdateExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(UpdateExpression < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(UpdateExpression < 'static >, operator) ==
+            24usize); assert!(std::mem::offset_of!(UpdateExpression < 'static >, prefix)
+            == 25usize); assert!(std::mem::offset_of!(UpdateExpression < 'static >,
+            argument) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<UnaryExpression<'static>>() == 32usize);
+        assert!(align_of::<UnaryExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(UnaryExpression < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(UnaryExpression < 'static >, operator) ==
+            24usize); assert!(std::mem::offset_of!(UnaryExpression < 'static >, argument)
+            == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<BinaryExpression<'static>>() == 48usize);
+        assert!(align_of::<BinaryExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(BinaryExpression < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(BinaryExpression < 'static >, left) == 0usize);
+            assert!(std::mem::offset_of!(BinaryExpression < 'static >, operator) ==
+            40usize); assert!(std::mem::offset_of!(BinaryExpression < 'static >, right)
+            == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<PrivateInExpression<'static>>() == 56usize);
+        assert!(align_of::<PrivateInExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(PrivateInExpression < 'static >, span) ==
+            40usize); assert!(std::mem::offset_of!(PrivateInExpression < 'static >, left)
+            == 16usize); assert!(std::mem::offset_of!(PrivateInExpression < 'static >,
+            operator) == 48usize); assert!(std::mem::offset_of!(PrivateInExpression <
+            'static >, right) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<LogicalExpression<'static>>() == 48usize);
+        assert!(align_of::<LogicalExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(LogicalExpression < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(LogicalExpression < 'static >, left)
+            == 0usize); assert!(std::mem::offset_of!(LogicalExpression < 'static >,
+            operator) == 40usize); assert!(std::mem::offset_of!(LogicalExpression <
+            'static >, right) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<ConditionalExpression<'static>>() == 56usize);
+        assert!(align_of::<ConditionalExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ConditionalExpression < 'static >, span) ==
+            48usize); assert!(std::mem::offset_of!(ConditionalExpression < 'static >,
+            test) == 0usize); assert!(std::mem::offset_of!(ConditionalExpression <
+            'static >, consequent) == 16usize);
+            assert!(std::mem::offset_of!(ConditionalExpression < 'static >, alternate) ==
+            32usize);
+        );
+    }
+    {
+        assert!(size_of::<AssignmentExpression<'static>>() == 48usize);
+        assert!(align_of::<AssignmentExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(AssignmentExpression < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(AssignmentExpression < 'static >,
+            operator) == 40usize); assert!(std::mem::offset_of!(AssignmentExpression <
+            'static >, left) == 0usize);
+            assert!(std::mem::offset_of!(AssignmentExpression < 'static >, right) ==
+            16usize);
+        );
+    }
+    {
+        assert!(size_of::<ArrayAssignmentTarget<'static>>() == 80usize);
+        assert!(align_of::<ArrayAssignmentTarget<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ArrayAssignmentTarget < 'static >, span) ==
+            56usize); assert!(std::mem::offset_of!(ArrayAssignmentTarget < 'static >,
+            elements) == 24usize); assert!(std::mem::offset_of!(ArrayAssignmentTarget <
+            'static >, rest) == 0usize);
+            assert!(std::mem::offset_of!(ArrayAssignmentTarget < 'static >,
+            trailing_comma) == 64usize);
+        );
+    }
+    {
+        assert!(size_of::<ObjectAssignmentTarget<'static>>() == 64usize);
+        assert!(align_of::<ObjectAssignmentTarget<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ObjectAssignmentTarget < 'static >, span) ==
+            56usize); assert!(std::mem::offset_of!(ObjectAssignmentTarget < 'static >,
+            properties) == 24usize); assert!(std::mem::offset_of!(ObjectAssignmentTarget
+            < 'static >, rest) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<AssignmentTargetRest<'static>>() == 24usize);
+        assert!(align_of::<AssignmentTargetRest<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(AssignmentTargetRest < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(AssignmentTargetRest < 'static >,
+            target) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<AssignmentTargetWithDefault<'static>>() == 40usize);
+        assert!(align_of::<AssignmentTargetWithDefault<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(AssignmentTargetWithDefault < 'static >, span)
+            == 32usize); assert!(std::mem::offset_of!(AssignmentTargetWithDefault <
+            'static >, binding) == 0usize);
+            assert!(std::mem::offset_of!(AssignmentTargetWithDefault < 'static >, init)
+            == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<AssignmentTargetPropertyIdentifier<'static>>() == 56usize);
+        assert!(align_of::<AssignmentTargetPropertyIdentifier<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier < 'static >,
+            span) == 48usize);
+            assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier < 'static >,
+            binding) == 16usize);
+            assert!(std::mem::offset_of!(AssignmentTargetPropertyIdentifier < 'static >,
+            init) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<AssignmentTargetPropertyProperty<'static>>() == 40usize);
+        assert!(align_of::<AssignmentTargetPropertyProperty<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty < 'static >,
+            span) == 32usize);
+            assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty < 'static >,
+            name) == 16usize);
+            assert!(std::mem::offset_of!(AssignmentTargetPropertyProperty < 'static >,
+            binding) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<SequenceExpression<'static>>() == 40usize);
+        assert!(align_of::<SequenceExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(SequenceExpression < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(SequenceExpression < 'static >,
+            expressions) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<Super>() == 8usize);
+        assert!(align_of::<Super>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(Super, span) == 0usize););
+    }
+    {
+        assert!(size_of::<AwaitExpression<'static>>() == 24usize);
+        assert!(align_of::<AwaitExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(AwaitExpression < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(AwaitExpression < 'static >, argument) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<ChainExpression<'static>>() == 24usize);
+        assert!(align_of::<ChainExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ChainExpression < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(ChainExpression < 'static >, expression) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<ParenthesizedExpression<'static>>() == 24usize);
+        assert!(align_of::<ParenthesizedExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ParenthesizedExpression < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(ParenthesizedExpression < 'static >,
+            expression) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<Directive<'static>>() == 48usize);
+        assert!(align_of::<Directive<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(Directive < 'static >, span) == 40usize);
+            assert!(std::mem::offset_of!(Directive < 'static >, expression) == 0usize);
+            assert!(std::mem::offset_of!(Directive < 'static >, directive) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<Hashbang<'static>>() == 24usize);
+        assert!(align_of::<Hashbang<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(Hashbang < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(Hashbang < 'static >, value) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<BlockStatement<'static>>() == 48usize);
+        assert!(align_of::<BlockStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(BlockStatement < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(BlockStatement < 'static >, body) == 0usize);
+            assert!(std::mem::offset_of!(BlockStatement < 'static >, scope_id) ==
+            40usize);
+        );
+    }
+    {
+        assert!(size_of::<VariableDeclaration<'static>>() == 48usize);
+        assert!(align_of::<VariableDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(VariableDeclaration < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(VariableDeclaration < 'static >, kind)
+            == 40usize); assert!(std::mem::offset_of!(VariableDeclaration < 'static >,
+            declarations) == 0usize); assert!(std::mem::offset_of!(VariableDeclaration <
+            'static >, declare) == 41usize);
+        );
+    }
+    {
+        assert!(size_of::<VariableDeclarator<'static>>() == 64usize);
+        assert!(align_of::<VariableDeclarator<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(VariableDeclarator < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(VariableDeclarator < 'static >, kind)
+            == 56usize); assert!(std::mem::offset_of!(VariableDeclarator < 'static >, id)
+            == 24usize); assert!(std::mem::offset_of!(VariableDeclarator < 'static >,
+            init) == 0usize); assert!(std::mem::offset_of!(VariableDeclarator < 'static
+            >, definite) == 57usize);
+        );
+    }
+    {
+        assert!(size_of::<UsingDeclaration<'static>>() == 48usize);
+        assert!(align_of::<UsingDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(UsingDeclaration < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(UsingDeclaration < 'static >, is_await) ==
+            40usize); assert!(std::mem::offset_of!(UsingDeclaration < 'static >,
+            declarations) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<EmptyStatement>() == 8usize);
+        assert!(align_of::<EmptyStatement>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(EmptyStatement, span) == 0usize););
+    }
+    {
+        assert!(size_of::<ExpressionStatement<'static>>() == 24usize);
+        assert!(align_of::<ExpressionStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ExpressionStatement < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(ExpressionStatement < 'static >,
+            expression) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<IfStatement<'static>>() == 56usize);
+        assert!(align_of::<IfStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(IfStatement < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(IfStatement < 'static >, test) == 0usize);
+            assert!(std::mem::offset_of!(IfStatement < 'static >, consequent) ==
+            16usize); assert!(std::mem::offset_of!(IfStatement < 'static >, alternate) ==
+            32usize);
+        );
+    }
+    {
+        assert!(size_of::<DoWhileStatement<'static>>() == 40usize);
+        assert!(align_of::<DoWhileStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(DoWhileStatement < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(DoWhileStatement < 'static >, body) == 16usize);
+            assert!(std::mem::offset_of!(DoWhileStatement < 'static >, test) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<WhileStatement<'static>>() == 40usize);
+        assert!(align_of::<WhileStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(WhileStatement < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(WhileStatement < 'static >, test) == 0usize);
+            assert!(std::mem::offset_of!(WhileStatement < 'static >, body) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<ForStatement<'static>>() == 80usize);
+        assert!(align_of::<ForStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ForStatement < 'static >, span) == 64usize);
+            assert!(std::mem::offset_of!(ForStatement < 'static >, init) == 32usize);
+            assert!(std::mem::offset_of!(ForStatement < 'static >, test) == 0usize);
+            assert!(std::mem::offset_of!(ForStatement < 'static >, update) == 16usize);
+            assert!(std::mem::offset_of!(ForStatement < 'static >, body) == 48usize);
+            assert!(std::mem::offset_of!(ForStatement < 'static >, scope_id) == 72usize);
+        );
+    }
+    {
+        assert!(size_of::<ForInStatement<'static>>() == 64usize);
+        assert!(align_of::<ForInStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ForInStatement < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(ForInStatement < 'static >, left) == 0usize);
+            assert!(std::mem::offset_of!(ForInStatement < 'static >, right) == 16usize);
+            assert!(std::mem::offset_of!(ForInStatement < 'static >, body) == 32usize);
+            assert!(std::mem::offset_of!(ForInStatement < 'static >, scope_id) ==
+            56usize);
+        );
+    }
+    {
+        assert!(size_of::<ForOfStatement<'static>>() == 64usize);
+        assert!(align_of::<ForOfStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ForOfStatement < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(ForOfStatement < 'static >, r#await) ==
+            60usize); assert!(std::mem::offset_of!(ForOfStatement < 'static >, left) ==
+            0usize); assert!(std::mem::offset_of!(ForOfStatement < 'static >, right) ==
+            16usize); assert!(std::mem::offset_of!(ForOfStatement < 'static >, body) ==
+            32usize); assert!(std::mem::offset_of!(ForOfStatement < 'static >, scope_id)
+            == 56usize);
+        );
+    }
+    {
+        assert!(size_of::<ContinueStatement<'static>>() == 32usize);
+        assert!(align_of::<ContinueStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ContinueStatement < 'static >, span) == 0usize);
+            assert!(std::mem::offset_of!(ContinueStatement < 'static >, label) ==
+            8usize);
+        );
+    }
+    {
+        assert!(size_of::<BreakStatement<'static>>() == 32usize);
+        assert!(align_of::<BreakStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(BreakStatement < 'static >, span) == 0usize);
+            assert!(std::mem::offset_of!(BreakStatement < 'static >, label) == 8usize);
+        );
+    }
+    {
+        assert!(size_of::<ReturnStatement<'static>>() == 24usize);
+        assert!(align_of::<ReturnStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ReturnStatement < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(ReturnStatement < 'static >, argument) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<WithStatement<'static>>() == 40usize);
+        assert!(align_of::<WithStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(WithStatement < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(WithStatement < 'static >, object) == 0usize);
+            assert!(std::mem::offset_of!(WithStatement < 'static >, body) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<SwitchStatement<'static>>() == 64usize);
+        assert!(align_of::<SwitchStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(SwitchStatement < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(SwitchStatement < 'static >, discriminant) ==
+            0usize); assert!(std::mem::offset_of!(SwitchStatement < 'static >, cases) ==
+            16usize); assert!(std::mem::offset_of!(SwitchStatement < 'static >, scope_id)
+            == 56usize);
+        );
+    }
+    {
+        assert!(size_of::<SwitchCase<'static>>() == 56usize);
+        assert!(align_of::<SwitchCase<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(SwitchCase < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(SwitchCase < 'static >, test) == 0usize);
+            assert!(std::mem::offset_of!(SwitchCase < 'static >, consequent) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<LabeledStatement<'static>>() == 48usize);
+        assert!(align_of::<LabeledStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(LabeledStatement < 'static >, span) == 40usize);
+            assert!(std::mem::offset_of!(LabeledStatement < 'static >, label) ==
+            16usize); assert!(std::mem::offset_of!(LabeledStatement < 'static >, body) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<ThrowStatement<'static>>() == 24usize);
+        assert!(align_of::<ThrowStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ThrowStatement < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(ThrowStatement < 'static >, argument) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<TryStatement<'static>>() == 32usize);
+        assert!(align_of::<TryStatement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TryStatement < 'static >, span) == 8usize);
+            assert!(std::mem::offset_of!(TryStatement < 'static >, block) == 0usize);
+            assert!(std::mem::offset_of!(TryStatement < 'static >, handler) == 16usize);
+            assert!(std::mem::offset_of!(TryStatement < 'static >, finalizer) ==
+            24usize);
+        );
+    }
+    {
+        assert!(size_of::<CatchClause<'static>>() == 64usize);
+        assert!(align_of::<CatchClause<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(CatchClause < 'static >, span) == 0usize);
+            assert!(std::mem::offset_of!(CatchClause < 'static >, param) == 16usize);
+            assert!(std::mem::offset_of!(CatchClause < 'static >, body) == 8usize);
+            assert!(std::mem::offset_of!(CatchClause < 'static >, scope_id) == 56usize);
+        );
+    }
+    {
+        assert!(size_of::<CatchParameter<'static>>() == 40usize);
+        assert!(align_of::<CatchParameter<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(CatchParameter < 'static >, span) == 0usize);
+            assert!(std::mem::offset_of!(CatchParameter < 'static >, pattern) == 8usize);
+        );
+    }
+    {
+        assert!(size_of::<DebuggerStatement>() == 8usize);
+        assert!(align_of::<DebuggerStatement>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(DebuggerStatement, span) == 0usize););
+    }
+    {
+        assert!(size_of::<BindingPattern<'static>>() == 32usize);
+        assert!(align_of::<BindingPattern<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(BindingPattern < 'static >, kind) == 0usize);
+            assert!(std::mem::offset_of!(BindingPattern < 'static >, type_annotation) ==
+            16usize); assert!(std::mem::offset_of!(BindingPattern < 'static >, optional)
+            == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<AssignmentPattern<'static>>() == 56usize);
+        assert!(align_of::<AssignmentPattern<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(AssignmentPattern < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(AssignmentPattern < 'static >, left)
+            == 24usize); assert!(std::mem::offset_of!(AssignmentPattern < 'static >,
+            right) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<ObjectPattern<'static>>() == 48usize);
+        assert!(align_of::<ObjectPattern<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ObjectPattern < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(ObjectPattern < 'static >, properties) ==
+            0usize); assert!(std::mem::offset_of!(ObjectPattern < 'static >, rest) ==
+            40usize);
+        );
+    }
+    {
+        assert!(size_of::<BindingProperty<'static>>() == 64usize);
+        assert!(align_of::<BindingProperty<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(BindingProperty < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(BindingProperty < 'static >, key) == 0usize);
+            assert!(std::mem::offset_of!(BindingProperty < 'static >, value) == 24usize);
+            assert!(std::mem::offset_of!(BindingProperty < 'static >, shorthand) ==
+            56usize); assert!(std::mem::offset_of!(BindingProperty < 'static >, computed)
+            == 57usize);
+        );
+    }
+    {
+        assert!(size_of::<ArrayPattern<'static>>() == 48usize);
+        assert!(align_of::<ArrayPattern<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ArrayPattern < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(ArrayPattern < 'static >, elements) == 0usize);
+            assert!(std::mem::offset_of!(ArrayPattern < 'static >, rest) == 40usize);
+        );
+    }
+    {
+        assert!(size_of::<BindingRestElement<'static>>() == 40usize);
+        assert!(align_of::<BindingRestElement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(BindingRestElement < 'static >, span) ==
+            0usize); assert!(std::mem::offset_of!(BindingRestElement < 'static >,
+            argument) == 8usize);
+        );
+    }
+    {
+        assert!(size_of::<Function<'static>>() == 120usize);
+        assert!(align_of::<Function<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(Function < 'static >, r#type) == 116usize);
+            assert!(std::mem::offset_of!(Function < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(Function < 'static >, id) == 0usize);
+            assert!(std::mem::offset_of!(Function < 'static >, generator) == 117usize);
+            assert!(std::mem::offset_of!(Function < 'static >, r#async) == 118usize);
+            assert!(std::mem::offset_of!(Function < 'static >, declare) == 119usize);
+            assert!(std::mem::offset_of!(Function < 'static >, type_parameters) ==
+            40usize); assert!(std::mem::offset_of!(Function < 'static >, this_param) ==
+            48usize); assert!(std::mem::offset_of!(Function < 'static >, params) ==
+            104usize); assert!(std::mem::offset_of!(Function < 'static >, return_type) ==
+            88usize); assert!(std::mem::offset_of!(Function < 'static >, body) ==
+            96usize); assert!(std::mem::offset_of!(Function < 'static >, scope_id) ==
+            112usize);
+        );
+    }
+    {
+        assert!(size_of::<FormalParameters<'static>>() == 56usize);
+        assert!(align_of::<FormalParameters<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(FormalParameters < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(FormalParameters < 'static >, kind) == 48usize);
+            assert!(std::mem::offset_of!(FormalParameters < 'static >, items) == 0usize);
+            assert!(std::mem::offset_of!(FormalParameters < 'static >, rest) == 40usize);
+        );
+    }
+    {
+        assert!(size_of::<FormalParameter<'static>>() == 80usize);
+        assert!(align_of::<FormalParameter<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(FormalParameter < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(FormalParameter < 'static >, decorators) ==
+            0usize); assert!(std::mem::offset_of!(FormalParameter < 'static >, pattern)
+            == 40usize); assert!(std::mem::offset_of!(FormalParameter < 'static >,
+            accessibility) == 72usize); assert!(std::mem::offset_of!(FormalParameter <
+            'static >, readonly) == 73usize);
+            assert!(std::mem::offset_of!(FormalParameter < 'static >, r#override) ==
+            74usize);
+        );
+    }
+    {
+        assert!(size_of::<FunctionBody<'static>>() == 72usize);
+        assert!(align_of::<FunctionBody<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(FunctionBody < 'static >, span) == 64usize);
+            assert!(std::mem::offset_of!(FunctionBody < 'static >, directives) ==
+            0usize); assert!(std::mem::offset_of!(FunctionBody < 'static >, statements)
+            == 32usize);
+        );
+    }
+    {
+        assert!(size_of::<ArrowFunctionExpression<'static>>() == 48usize);
+        assert!(align_of::<ArrowFunctionExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ArrowFunctionExpression < 'static >, span) ==
+            0usize); assert!(std::mem::offset_of!(ArrowFunctionExpression < 'static >,
+            expression) == 44usize); assert!(std::mem::offset_of!(ArrowFunctionExpression
+            < 'static >, r#async) == 45usize);
+            assert!(std::mem::offset_of!(ArrowFunctionExpression < 'static >,
+            type_parameters) == 8usize);
+            assert!(std::mem::offset_of!(ArrowFunctionExpression < 'static >, params) ==
+            24usize); assert!(std::mem::offset_of!(ArrowFunctionExpression < 'static >,
+            return_type) == 16usize);
+            assert!(std::mem::offset_of!(ArrowFunctionExpression < 'static >, body) ==
+            32usize); assert!(std::mem::offset_of!(ArrowFunctionExpression < 'static >,
+            scope_id) == 40usize);
+        );
+    }
+    {
+        assert!(size_of::<YieldExpression<'static>>() == 32usize);
+        assert!(align_of::<YieldExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(YieldExpression < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(YieldExpression < 'static >, delegate) ==
+            24usize); assert!(std::mem::offset_of!(YieldExpression < 'static >, argument)
+            == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<Class<'static>>() == 152usize);
+        assert!(align_of::<Class<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(Class < 'static >, r#type) == 148usize);
+            assert!(std::mem::offset_of!(Class < 'static >, span) == 112usize);
+            assert!(std::mem::offset_of!(Class < 'static >, decorators) == 64usize);
+            assert!(std::mem::offset_of!(Class < 'static >, id) == 0usize);
+            assert!(std::mem::offset_of!(Class < 'static >, type_parameters) ==
+            120usize); assert!(std::mem::offset_of!(Class < 'static >, super_class) ==
+            96usize); assert!(std::mem::offset_of!(Class < 'static >,
+            super_type_parameters) == 128usize); assert!(std::mem::offset_of!(Class <
+            'static >, implements) == 32usize); assert!(std::mem::offset_of!(Class <
+            'static >, body) == 136usize); assert!(std::mem::offset_of!(Class < 'static
+            >, r#abstract) == 149usize); assert!(std::mem::offset_of!(Class < 'static >,
+            declare) == 150usize); assert!(std::mem::offset_of!(Class < 'static >,
+            scope_id) == 144usize);
+        );
+    }
+    {
+        assert!(size_of::<ClassBody<'static>>() == 40usize);
+        assert!(align_of::<ClassBody<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ClassBody < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(ClassBody < 'static >, body) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<MethodDefinition<'static>>() == 72usize);
+        assert!(align_of::<MethodDefinition<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(MethodDefinition < 'static >, r#type) ==
+            66usize); assert!(std::mem::offset_of!(MethodDefinition < 'static >, span) ==
+            48usize); assert!(std::mem::offset_of!(MethodDefinition < 'static >,
+            decorators) == 0usize); assert!(std::mem::offset_of!(MethodDefinition <
+            'static >, key) == 32usize); assert!(std::mem::offset_of!(MethodDefinition <
+            'static >, value) == 56usize); assert!(std::mem::offset_of!(MethodDefinition
+            < 'static >, kind) == 64usize); assert!(std::mem::offset_of!(MethodDefinition
+            < 'static >, computed) == 67usize);
+            assert!(std::mem::offset_of!(MethodDefinition < 'static >, r#static) ==
+            68usize); assert!(std::mem::offset_of!(MethodDefinition < 'static >,
+            r#override) == 69usize); assert!(std::mem::offset_of!(MethodDefinition <
+            'static >, optional) == 70usize);
+            assert!(std::mem::offset_of!(MethodDefinition < 'static >, accessibility) ==
+            65usize);
+        );
+    }
+    {
+        assert!(size_of::<PropertyDefinition<'static>>() == 96usize);
+        assert!(align_of::<PropertyDefinition<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(PropertyDefinition < 'static >, r#type) ==
+            81usize); assert!(std::mem::offset_of!(PropertyDefinition < 'static >, span)
+            == 64usize); assert!(std::mem::offset_of!(PropertyDefinition < 'static >,
+            decorators) == 0usize); assert!(std::mem::offset_of!(PropertyDefinition <
+            'static >, key) == 32usize); assert!(std::mem::offset_of!(PropertyDefinition
+            < 'static >, value) == 48usize);
+            assert!(std::mem::offset_of!(PropertyDefinition < 'static >, computed) ==
+            82usize); assert!(std::mem::offset_of!(PropertyDefinition < 'static >,
+            r#static) == 83usize); assert!(std::mem::offset_of!(PropertyDefinition <
+            'static >, declare) == 84usize);
+            assert!(std::mem::offset_of!(PropertyDefinition < 'static >, r#override) ==
+            85usize); assert!(std::mem::offset_of!(PropertyDefinition < 'static >,
+            optional) == 86usize); assert!(std::mem::offset_of!(PropertyDefinition <
+            'static >, definite) == 87usize);
+            assert!(std::mem::offset_of!(PropertyDefinition < 'static >, readonly) ==
+            88usize); assert!(std::mem::offset_of!(PropertyDefinition < 'static >,
+            type_annotation) == 72usize); assert!(std::mem::offset_of!(PropertyDefinition
+            < 'static >, accessibility) == 80usize);
+        );
+    }
+    {
+        assert!(size_of::<PrivateIdentifier<'static>>() == 24usize);
+        assert!(align_of::<PrivateIdentifier<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(PrivateIdentifier < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(PrivateIdentifier < 'static >, name)
+            == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<StaticBlock<'static>>() == 48usize);
+        assert!(align_of::<StaticBlock<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(StaticBlock < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(StaticBlock < 'static >, body) == 0usize);
+            assert!(std::mem::offset_of!(StaticBlock < 'static >, scope_id) == 40usize);
+        );
+    }
+    {
+        assert!(size_of::<AccessorProperty<'static>>() == 80usize);
+        assert!(align_of::<AccessorProperty<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(AccessorProperty < 'static >, r#type) ==
+            72usize); assert!(std::mem::offset_of!(AccessorProperty < 'static >, span) ==
+            64usize); assert!(std::mem::offset_of!(AccessorProperty < 'static >,
+            decorators) == 0usize); assert!(std::mem::offset_of!(AccessorProperty <
+            'static >, key) == 32usize); assert!(std::mem::offset_of!(AccessorProperty <
+            'static >, value) == 48usize); assert!(std::mem::offset_of!(AccessorProperty
+            < 'static >, computed) == 73usize);
+            assert!(std::mem::offset_of!(AccessorProperty < 'static >, r#static) ==
+            74usize);
+        );
+    }
+    {
+        assert!(size_of::<ImportExpression<'static>>() == 56usize);
+        assert!(align_of::<ImportExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ImportExpression < 'static >, span) == 48usize);
+            assert!(std::mem::offset_of!(ImportExpression < 'static >, source) ==
+            0usize); assert!(std::mem::offset_of!(ImportExpression < 'static >,
+            arguments) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<ImportDeclaration<'static>>() == 136usize);
+        assert!(align_of::<ImportDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ImportDeclaration < 'static >, span) ==
+            24usize); assert!(std::mem::offset_of!(ImportDeclaration < 'static >,
+            specifiers) == 32usize); assert!(std::mem::offset_of!(ImportDeclaration <
+            'static >, source) == 0usize); assert!(std::mem::offset_of!(ImportDeclaration
+            < 'static >, with_clause) == 64usize);
+            assert!(std::mem::offset_of!(ImportDeclaration < 'static >, import_kind) ==
+            128usize);
+        );
+    }
+    {
+        assert!(size_of::<ImportSpecifier<'static>>() == 88usize);
+        assert!(align_of::<ImportSpecifier<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ImportSpecifier < 'static >, span) == 72usize);
+            assert!(std::mem::offset_of!(ImportSpecifier < 'static >, imported) ==
+            0usize); assert!(std::mem::offset_of!(ImportSpecifier < 'static >, local) ==
+            40usize); assert!(std::mem::offset_of!(ImportSpecifier < 'static >,
+            import_kind) == 80usize);
+        );
+    }
+    {
+        assert!(size_of::<ImportDefaultSpecifier<'static>>() == 40usize);
+        assert!(align_of::<ImportDefaultSpecifier<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ImportDefaultSpecifier < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(ImportDefaultSpecifier < 'static >,
+            local) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<ImportNamespaceSpecifier<'static>>() == 40usize);
+        assert!(align_of::<ImportNamespaceSpecifier<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ImportNamespaceSpecifier < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(ImportNamespaceSpecifier < 'static >,
+            local) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<WithClause<'static>>() == 64usize);
+        assert!(align_of::<WithClause<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(WithClause < 'static >, span) == 56usize);
+            assert!(std::mem::offset_of!(WithClause < 'static >, attributes_keyword) ==
+            0usize); assert!(std::mem::offset_of!(WithClause < 'static >, with_entries)
+            == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<ImportAttribute<'static>>() == 64usize);
+        assert!(align_of::<ImportAttribute<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ImportAttribute < 'static >, span) == 56usize);
+            assert!(std::mem::offset_of!(ImportAttribute < 'static >, key) == 0usize);
+            assert!(std::mem::offset_of!(ImportAttribute < 'static >, value) == 32usize);
+        );
+    }
+    {
+        assert!(size_of::<ExportNamedDeclaration<'static>>() == 152usize);
+        assert!(align_of::<ExportNamedDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ExportNamedDeclaration < 'static >, span) ==
+            48usize); assert!(std::mem::offset_of!(ExportNamedDeclaration < 'static >,
+            declaration) == 0usize); assert!(std::mem::offset_of!(ExportNamedDeclaration
+            < 'static >, specifiers) == 16usize);
+            assert!(std::mem::offset_of!(ExportNamedDeclaration < 'static >, source) ==
+            56usize); assert!(std::mem::offset_of!(ExportNamedDeclaration < 'static >,
+            export_kind) == 144usize);
+            assert!(std::mem::offset_of!(ExportNamedDeclaration < 'static >, with_clause)
+            == 80usize);
+        );
+    }
+    {
+        assert!(size_of::<ExportDefaultDeclaration<'static>>() == 64usize);
+        assert!(align_of::<ExportDefaultDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ExportDefaultDeclaration < 'static >, span) ==
+            56usize); assert!(std::mem::offset_of!(ExportDefaultDeclaration < 'static >,
+            declaration) == 40usize);
+            assert!(std::mem::offset_of!(ExportDefaultDeclaration < 'static >, exported)
+            == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<ExportAllDeclaration<'static>>() == 144usize);
+        assert!(align_of::<ExportAllDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ExportAllDeclaration < 'static >, span) ==
+            64usize); assert!(std::mem::offset_of!(ExportAllDeclaration < 'static >,
+            exported) == 0usize); assert!(std::mem::offset_of!(ExportAllDeclaration <
+            'static >, source) == 40usize);
+            assert!(std::mem::offset_of!(ExportAllDeclaration < 'static >, with_clause)
+            == 72usize); assert!(std::mem::offset_of!(ExportAllDeclaration < 'static >,
+            export_kind) == 136usize);
+        );
+    }
+    {
+        assert!(size_of::<ExportSpecifier<'static>>() == 96usize);
+        assert!(align_of::<ExportSpecifier<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(ExportSpecifier < 'static >, span) == 80usize);
+            assert!(std::mem::offset_of!(ExportSpecifier < 'static >, local) == 0usize);
+            assert!(std::mem::offset_of!(ExportSpecifier < 'static >, exported) ==
+            40usize); assert!(std::mem::offset_of!(ExportSpecifier < 'static >,
+            export_kind) == 88usize);
+        );
+    }
+    {
+        assert!(size_of::<TSThisParameter<'static>>() == 40usize);
+        assert!(align_of::<TSThisParameter<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSThisParameter < 'static >, span) == 24usize);
+            assert!(std::mem::offset_of!(TSThisParameter < 'static >, this) == 0usize);
+            assert!(std::mem::offset_of!(TSThisParameter < 'static >, type_annotation) ==
+            32usize);
+        );
+    }
+    {
+        assert!(size_of::<TSEnumDeclaration<'static>>() == 80usize);
+        assert!(align_of::<TSEnumDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSEnumDeclaration < 'static >, span) ==
+            64usize); assert!(std::mem::offset_of!(TSEnumDeclaration < 'static >, id) ==
+            0usize); assert!(std::mem::offset_of!(TSEnumDeclaration < 'static >, members)
+            == 32usize); assert!(std::mem::offset_of!(TSEnumDeclaration < 'static >,
+            r#const) == 76usize); assert!(std::mem::offset_of!(TSEnumDeclaration <
+            'static >, declare) == 77usize);
+            assert!(std::mem::offset_of!(TSEnumDeclaration < 'static >, scope_id) ==
+            72usize);
+        );
+    }
+    {
+        assert!(size_of::<TSEnumMember<'static>>() == 40usize);
+        assert!(align_of::<TSEnumMember<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSEnumMember < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TSEnumMember < 'static >, id) == 16usize);
+            assert!(std::mem::offset_of!(TSEnumMember < 'static >, initializer) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypeAnnotation<'static>>() == 24usize);
+        assert!(align_of::<TSTypeAnnotation<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeAnnotation < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSTypeAnnotation < 'static >, type_annotation)
+            == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSLiteralType<'static>>() == 24usize);
+        assert!(align_of::<TSLiteralType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSLiteralType < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSLiteralType < 'static >, literal) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSConditionalType<'static>>() == 80usize);
+        assert!(align_of::<TSConditionalType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSConditionalType < 'static >, span) ==
+            64usize); assert!(std::mem::offset_of!(TSConditionalType < 'static >,
+            check_type) == 0usize); assert!(std::mem::offset_of!(TSConditionalType <
+            'static >, extends_type) == 16usize);
+            assert!(std::mem::offset_of!(TSConditionalType < 'static >, true_type) ==
+            32usize); assert!(std::mem::offset_of!(TSConditionalType < 'static >,
+            false_type) == 48usize); assert!(std::mem::offset_of!(TSConditionalType <
+            'static >, scope_id) == 72usize);
+        );
+    }
+    {
+        assert!(size_of::<TSUnionType<'static>>() == 40usize);
+        assert!(align_of::<TSUnionType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSUnionType < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TSUnionType < 'static >, types) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSIntersectionType<'static>>() == 40usize);
+        assert!(align_of::<TSIntersectionType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSIntersectionType < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(TSIntersectionType < 'static >, types)
+            == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSParenthesizedType<'static>>() == 24usize);
+        assert!(align_of::<TSParenthesizedType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSParenthesizedType < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(TSParenthesizedType < 'static >,
+            type_annotation) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypeOperator<'static>>() == 32usize);
+        assert!(align_of::<TSTypeOperator<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeOperator < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSTypeOperator < 'static >, operator) ==
+            24usize); assert!(std::mem::offset_of!(TSTypeOperator < 'static >,
+            type_annotation) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSArrayType<'static>>() == 24usize);
+        assert!(align_of::<TSArrayType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSArrayType < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSArrayType < 'static >, element_type) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSIndexedAccessType<'static>>() == 40usize);
+        assert!(align_of::<TSIndexedAccessType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSIndexedAccessType < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(TSIndexedAccessType < 'static >,
+            object_type) == 0usize); assert!(std::mem::offset_of!(TSIndexedAccessType <
+            'static >, index_type) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTupleType<'static>>() == 40usize);
+        assert!(align_of::<TSTupleType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTupleType < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TSTupleType < 'static >, element_types) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSNamedTupleMember<'static>>() == 56usize);
+        assert!(align_of::<TSNamedTupleMember<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSNamedTupleMember < 'static >, span) ==
+            40usize); assert!(std::mem::offset_of!(TSNamedTupleMember < 'static >,
+            element_type) == 0usize); assert!(std::mem::offset_of!(TSNamedTupleMember <
+            'static >, label) == 16usize);
+            assert!(std::mem::offset_of!(TSNamedTupleMember < 'static >, optional) ==
+            48usize);
+        );
+    }
+    {
+        assert!(size_of::<TSOptionalType<'static>>() == 24usize);
+        assert!(align_of::<TSOptionalType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSOptionalType < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSOptionalType < 'static >, type_annotation) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSRestType<'static>>() == 24usize);
+        assert!(align_of::<TSRestType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSRestType < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSRestType < 'static >, type_annotation) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSAnyKeyword>() == 8usize);
+        assert!(align_of::<TSAnyKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSAnyKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSStringKeyword>() == 8usize);
+        assert!(align_of::<TSStringKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSStringKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSBooleanKeyword>() == 8usize);
+        assert!(align_of::<TSBooleanKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSBooleanKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSNumberKeyword>() == 8usize);
+        assert!(align_of::<TSNumberKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSNumberKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSNeverKeyword>() == 8usize);
+        assert!(align_of::<TSNeverKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSNeverKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSIntrinsicKeyword>() == 8usize);
+        assert!(align_of::<TSIntrinsicKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSIntrinsicKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSUnknownKeyword>() == 8usize);
+        assert!(align_of::<TSUnknownKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSUnknownKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSNullKeyword>() == 8usize);
+        assert!(align_of::<TSNullKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSNullKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSUndefinedKeyword>() == 8usize);
+        assert!(align_of::<TSUndefinedKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSUndefinedKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSVoidKeyword>() == 8usize);
+        assert!(align_of::<TSVoidKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSVoidKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSSymbolKeyword>() == 8usize);
+        assert!(align_of::<TSSymbolKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSSymbolKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSThisType>() == 8usize);
+        assert!(align_of::<TSThisType>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSThisType, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSObjectKeyword>() == 8usize);
+        assert!(align_of::<TSObjectKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSObjectKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSBigIntKeyword>() == 8usize);
+        assert!(align_of::<TSBigIntKeyword>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(TSBigIntKeyword, span) == 0usize););
+    }
+    {
+        assert!(size_of::<TSTypeReference<'static>>() == 32usize);
+        assert!(align_of::<TSTypeReference<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeReference < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSTypeReference < 'static >, type_name) ==
+            0usize); assert!(std::mem::offset_of!(TSTypeReference < 'static >,
+            type_parameters) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<TSQualifiedName<'static>>() == 48usize);
+        assert!(align_of::<TSQualifiedName<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSQualifiedName < 'static >, span) == 40usize);
+            assert!(std::mem::offset_of!(TSQualifiedName < 'static >, left) == 0usize);
+            assert!(std::mem::offset_of!(TSQualifiedName < 'static >, right) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypeParameterInstantiation<'static>>() == 40usize);
+        assert!(align_of::<TSTypeParameterInstantiation<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeParameterInstantiation < 'static >, span)
+            == 32usize); assert!(std::mem::offset_of!(TSTypeParameterInstantiation <
+            'static >, params) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypeParameter<'static>>() == 80usize);
+        assert!(align_of::<TSTypeParameter<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeParameter < 'static >, span) == 64usize);
+            assert!(std::mem::offset_of!(TSTypeParameter < 'static >, name) == 0usize);
+            assert!(std::mem::offset_of!(TSTypeParameter < 'static >, constraint) ==
+            32usize); assert!(std::mem::offset_of!(TSTypeParameter < 'static >, default)
+            == 48usize); assert!(std::mem::offset_of!(TSTypeParameter < 'static >, r#in)
+            == 72usize); assert!(std::mem::offset_of!(TSTypeParameter < 'static >, out)
+            == 73usize); assert!(std::mem::offset_of!(TSTypeParameter < 'static >,
+            r#const) == 74usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypeParameterDeclaration<'static>>() == 40usize);
+        assert!(align_of::<TSTypeParameterDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeParameterDeclaration < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(TSTypeParameterDeclaration < 'static
+            >, params) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypeAliasDeclaration<'static>>() == 72usize);
+        assert!(align_of::<TSTypeAliasDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeAliasDeclaration < 'static >, span) ==
+            48usize); assert!(std::mem::offset_of!(TSTypeAliasDeclaration < 'static >,
+            id) == 16usize); assert!(std::mem::offset_of!(TSTypeAliasDeclaration <
+            'static >, type_parameters) == 56usize);
+            assert!(std::mem::offset_of!(TSTypeAliasDeclaration < 'static >,
+            type_annotation) == 0usize);
+            assert!(std::mem::offset_of!(TSTypeAliasDeclaration < 'static >, declare) ==
+            68usize); assert!(std::mem::offset_of!(TSTypeAliasDeclaration < 'static >,
+            scope_id) == 64usize);
+        );
+    }
+    {
+        assert!(size_of::<TSClassImplements<'static>>() == 32usize);
+        assert!(align_of::<TSClassImplements<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSClassImplements < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(TSClassImplements < 'static >,
+            expression) == 0usize); assert!(std::mem::offset_of!(TSClassImplements <
+            'static >, type_parameters) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<TSInterfaceDeclaration<'static>>() == 96usize);
+        assert!(align_of::<TSInterfaceDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSInterfaceDeclaration < 'static >, span) ==
+            40usize); assert!(std::mem::offset_of!(TSInterfaceDeclaration < 'static >,
+            id) == 0usize); assert!(std::mem::offset_of!(TSInterfaceDeclaration < 'static
+            >, extends) == 48usize); assert!(std::mem::offset_of!(TSInterfaceDeclaration
+            < 'static >, type_parameters) == 80usize);
+            assert!(std::mem::offset_of!(TSInterfaceDeclaration < 'static >, body) ==
+            32usize); assert!(std::mem::offset_of!(TSInterfaceDeclaration < 'static >,
+            declare) == 92usize); assert!(std::mem::offset_of!(TSInterfaceDeclaration <
+            'static >, scope_id) == 88usize);
+        );
+    }
+    {
+        assert!(size_of::<TSInterfaceBody<'static>>() == 40usize);
+        assert!(align_of::<TSInterfaceBody<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSInterfaceBody < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TSInterfaceBody < 'static >, body) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSPropertySignature<'static>>() == 40usize);
+        assert!(align_of::<TSPropertySignature<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSPropertySignature < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(TSPropertySignature < 'static >,
+            computed) == 32usize); assert!(std::mem::offset_of!(TSPropertySignature <
+            'static >, optional) == 33usize);
+            assert!(std::mem::offset_of!(TSPropertySignature < 'static >, readonly) ==
+            34usize); assert!(std::mem::offset_of!(TSPropertySignature < 'static >, key)
+            == 0usize); assert!(std::mem::offset_of!(TSPropertySignature < 'static >,
+            type_annotation) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<TSIndexSignature<'static>>() == 56usize);
+        assert!(align_of::<TSIndexSignature<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSIndexSignature < 'static >, span) == 40usize);
+            assert!(std::mem::offset_of!(TSIndexSignature < 'static >, parameters) ==
+            0usize); assert!(std::mem::offset_of!(TSIndexSignature < 'static >,
+            type_annotation) == 32usize); assert!(std::mem::offset_of!(TSIndexSignature <
+            'static >, readonly) == 48usize);
+        );
+    }
+    {
+        assert!(size_of::<TSCallSignatureDeclaration<'static>>() == 72usize);
+        assert!(align_of::<TSCallSignatureDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSCallSignatureDeclaration < 'static >, span) ==
+            8usize); assert!(std::mem::offset_of!(TSCallSignatureDeclaration < 'static >,
+            this_param) == 16usize);
+            assert!(std::mem::offset_of!(TSCallSignatureDeclaration < 'static >, params)
+            == 0usize); assert!(std::mem::offset_of!(TSCallSignatureDeclaration < 'static
+            >, return_type) == 56usize);
+            assert!(std::mem::offset_of!(TSCallSignatureDeclaration < 'static >,
+            type_parameters) == 64usize);
+        );
+    }
+    {
+        assert!(size_of::<TSMethodSignature<'static>>() == 96usize);
+        assert!(align_of::<TSMethodSignature<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSMethodSignature < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(TSMethodSignature < 'static >, key) ==
+            0usize); assert!(std::mem::offset_of!(TSMethodSignature < 'static >,
+            computed) == 93usize); assert!(std::mem::offset_of!(TSMethodSignature <
+            'static >, optional) == 94usize);
+            assert!(std::mem::offset_of!(TSMethodSignature < 'static >, kind) ==
+            92usize); assert!(std::mem::offset_of!(TSMethodSignature < 'static >,
+            this_param) == 24usize); assert!(std::mem::offset_of!(TSMethodSignature <
+            'static >, params) == 80usize);
+            assert!(std::mem::offset_of!(TSMethodSignature < 'static >, return_type) ==
+            64usize); assert!(std::mem::offset_of!(TSMethodSignature < 'static >,
+            type_parameters) == 72usize); assert!(std::mem::offset_of!(TSMethodSignature
+            < 'static >, scope_id) == 88usize);
+        );
+    }
+    {
+        assert!(size_of::<TSConstructSignatureDeclaration<'static>>() == 40usize);
+        assert!(align_of::<TSConstructSignatureDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSConstructSignatureDeclaration < 'static >,
+            span) == 8usize);
+            assert!(std::mem::offset_of!(TSConstructSignatureDeclaration < 'static >,
+            params) == 0usize);
+            assert!(std::mem::offset_of!(TSConstructSignatureDeclaration < 'static >,
+            return_type) == 16usize);
+            assert!(std::mem::offset_of!(TSConstructSignatureDeclaration < 'static >,
+            type_parameters) == 24usize);
+            assert!(std::mem::offset_of!(TSConstructSignatureDeclaration < 'static >,
+            scope_id) == 32usize);
+        );
+    }
+    {
+        assert!(size_of::<TSIndexSignatureName<'static>>() == 32usize);
+        assert!(align_of::<TSIndexSignatureName<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSIndexSignatureName < 'static >, span) ==
+            24usize); assert!(std::mem::offset_of!(TSIndexSignatureName < 'static >,
+            name) == 0usize); assert!(std::mem::offset_of!(TSIndexSignatureName < 'static
+            >, type_annotation) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<TSInterfaceHeritage<'static>>() == 32usize);
+        assert!(align_of::<TSInterfaceHeritage<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSInterfaceHeritage < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(TSInterfaceHeritage < 'static >,
+            expression) == 0usize); assert!(std::mem::offset_of!(TSInterfaceHeritage <
+            'static >, type_parameters) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypePredicate<'static>>() == 40usize);
+        assert!(align_of::<TSTypePredicate<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypePredicate < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSTypePredicate < 'static >, parameter_name) ==
+            0usize); assert!(std::mem::offset_of!(TSTypePredicate < 'static >, asserts)
+            == 32usize); assert!(std::mem::offset_of!(TSTypePredicate < 'static >,
+            type_annotation) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<TSModuleDeclaration<'static>>() == 64usize);
+        assert!(align_of::<TSModuleDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSModuleDeclaration < 'static >, span) ==
+            48usize); assert!(std::mem::offset_of!(TSModuleDeclaration < 'static >, id)
+            == 0usize); assert!(std::mem::offset_of!(TSModuleDeclaration < 'static >,
+            body) == 32usize); assert!(std::mem::offset_of!(TSModuleDeclaration < 'static
+            >, kind) == 61usize); assert!(std::mem::offset_of!(TSModuleDeclaration <
+            'static >, declare) == 60usize);
+            assert!(std::mem::offset_of!(TSModuleDeclaration < 'static >, scope_id) ==
+            56usize);
+        );
+    }
+    {
+        assert!(size_of::<TSModuleBlock<'static>>() == 72usize);
+        assert!(align_of::<TSModuleBlock<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSModuleBlock < 'static >, span) == 64usize);
+            assert!(std::mem::offset_of!(TSModuleBlock < 'static >, directives) ==
+            0usize); assert!(std::mem::offset_of!(TSModuleBlock < 'static >, body) ==
+            32usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypeLiteral<'static>>() == 40usize);
+        assert!(align_of::<TSTypeLiteral<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeLiteral < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TSTypeLiteral < 'static >, members) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSInferType<'static>>() == 16usize);
+        assert!(align_of::<TSInferType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSInferType < 'static >, span) == 8usize);
+            assert!(std::mem::offset_of!(TSInferType < 'static >, type_parameter) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypeQuery<'static>>() == 32usize);
+        assert!(align_of::<TSTypeQuery<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeQuery < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSTypeQuery < 'static >, expr_name) == 0usize);
+            assert!(std::mem::offset_of!(TSTypeQuery < 'static >, type_parameters) ==
+            24usize);
+        );
+    }
+    {
+        assert!(size_of::<TSImportType<'static>>() == 96usize);
+        assert!(align_of::<TSImportType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSImportType < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TSImportType < 'static >, is_type_of) ==
+            88usize); assert!(std::mem::offset_of!(TSImportType < 'static >, parameter)
+            == 16usize); assert!(std::mem::offset_of!(TSImportType < 'static >,
+            qualifier) == 0usize); assert!(std::mem::offset_of!(TSImportType < 'static >,
+            attributes) == 40usize); assert!(std::mem::offset_of!(TSImportType < 'static
+            >, type_parameters) == 80usize);
+        );
+    }
+    {
+        assert!(size_of::<TSImportAttributes<'static>>() == 40usize);
+        assert!(align_of::<TSImportAttributes<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSImportAttributes < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(TSImportAttributes < 'static >,
+            elements) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSImportAttribute<'static>>() == 56usize);
+        assert!(align_of::<TSImportAttribute<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSImportAttribute < 'static >, span) ==
+            48usize); assert!(std::mem::offset_of!(TSImportAttribute < 'static >, name)
+            == 0usize); assert!(std::mem::offset_of!(TSImportAttribute < 'static >,
+            value) == 32usize);
+        );
+    }
+    {
+        assert!(size_of::<TSFunctionType<'static>>() == 72usize);
+        assert!(align_of::<TSFunctionType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSFunctionType < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(TSFunctionType < 'static >, this_param) ==
+            24usize); assert!(std::mem::offset_of!(TSFunctionType < 'static >, params) ==
+            0usize); assert!(std::mem::offset_of!(TSFunctionType < 'static >,
+            return_type) == 8usize); assert!(std::mem::offset_of!(TSFunctionType <
+            'static >, type_parameters) == 64usize);
+        );
+    }
+    {
+        assert!(size_of::<TSConstructorType<'static>>() == 40usize);
+        assert!(align_of::<TSConstructorType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSConstructorType < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(TSConstructorType < 'static >,
+            r#abstract) == 32usize); assert!(std::mem::offset_of!(TSConstructorType <
+            'static >, params) == 0usize); assert!(std::mem::offset_of!(TSConstructorType
+            < 'static >, return_type) == 8usize);
+            assert!(std::mem::offset_of!(TSConstructorType < 'static >, type_parameters)
+            == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<TSMappedType<'static>>() == 56usize);
+        assert!(align_of::<TSMappedType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSMappedType < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TSMappedType < 'static >, type_parameter) ==
+            40usize); assert!(std::mem::offset_of!(TSMappedType < 'static >, name_type)
+            == 0usize); assert!(std::mem::offset_of!(TSMappedType < 'static >,
+            type_annotation) == 16usize); assert!(std::mem::offset_of!(TSMappedType <
+            'static >, optional) == 52usize); assert!(std::mem::offset_of!(TSMappedType <
+            'static >, readonly) == 53usize); assert!(std::mem::offset_of!(TSMappedType <
+            'static >, scope_id) == 48usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTemplateLiteralType<'static>>() == 72usize);
+        assert!(align_of::<TSTemplateLiteralType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTemplateLiteralType < 'static >, span) ==
+            64usize); assert!(std::mem::offset_of!(TSTemplateLiteralType < 'static >,
+            quasis) == 0usize); assert!(std::mem::offset_of!(TSTemplateLiteralType <
+            'static >, types) == 32usize);
+        );
+    }
+    {
+        assert!(size_of::<TSAsExpression<'static>>() == 40usize);
+        assert!(align_of::<TSAsExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSAsExpression < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TSAsExpression < 'static >, expression) ==
+            16usize); assert!(std::mem::offset_of!(TSAsExpression < 'static >,
+            type_annotation) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSSatisfiesExpression<'static>>() == 40usize);
+        assert!(align_of::<TSSatisfiesExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSSatisfiesExpression < 'static >, span) ==
+            32usize); assert!(std::mem::offset_of!(TSSatisfiesExpression < 'static >,
+            expression) == 16usize); assert!(std::mem::offset_of!(TSSatisfiesExpression <
+            'static >, type_annotation) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSTypeAssertion<'static>>() == 40usize);
+        assert!(align_of::<TSTypeAssertion<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSTypeAssertion < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(TSTypeAssertion < 'static >, expression) ==
+            16usize); assert!(std::mem::offset_of!(TSTypeAssertion < 'static >,
+            type_annotation) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSImportEqualsDeclaration<'static>>() == 64usize);
+        assert!(align_of::<TSImportEqualsDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSImportEqualsDeclaration < 'static >, span) ==
+            48usize); assert!(std::mem::offset_of!(TSImportEqualsDeclaration < 'static >,
+            id) == 16usize); assert!(std::mem::offset_of!(TSImportEqualsDeclaration <
+            'static >, module_reference) == 0usize);
+            assert!(std::mem::offset_of!(TSImportEqualsDeclaration < 'static >,
+            import_kind) == 56usize);
+        );
+    }
+    {
+        assert!(size_of::<TSExternalModuleReference<'static>>() == 32usize);
+        assert!(align_of::<TSExternalModuleReference<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSExternalModuleReference < 'static >, span) ==
+            24usize); assert!(std::mem::offset_of!(TSExternalModuleReference < 'static >,
+            expression) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSNonNullExpression<'static>>() == 24usize);
+        assert!(align_of::<TSNonNullExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSNonNullExpression < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(TSNonNullExpression < 'static >,
+            expression) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<Decorator<'static>>() == 24usize);
+        assert!(align_of::<Decorator<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(Decorator < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(Decorator < 'static >, expression) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSExportAssignment<'static>>() == 24usize);
+        assert!(align_of::<TSExportAssignment<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSExportAssignment < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(TSExportAssignment < 'static >,
+            expression) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSNamespaceExportDeclaration<'static>>() == 32usize);
+        assert!(align_of::<TSNamespaceExportDeclaration<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSNamespaceExportDeclaration < 'static >, span)
+            == 24usize); assert!(std::mem::offset_of!(TSNamespaceExportDeclaration <
+            'static >, id) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<TSInstantiationExpression<'static>>() == 32usize);
+        assert!(align_of::<TSInstantiationExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(TSInstantiationExpression < 'static >, span) ==
+            24usize); assert!(std::mem::offset_of!(TSInstantiationExpression < 'static >,
+            expression) == 0usize);
+            assert!(std::mem::offset_of!(TSInstantiationExpression < 'static >,
+            type_parameters) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<JSDocNullableType<'static>>() == 32usize);
+        assert!(align_of::<JSDocNullableType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSDocNullableType < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(JSDocNullableType < 'static >,
+            type_annotation) == 0usize); assert!(std::mem::offset_of!(JSDocNullableType <
+            'static >, postfix) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<JSDocNonNullableType<'static>>() == 32usize);
+        assert!(align_of::<JSDocNonNullableType<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSDocNonNullableType < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(JSDocNonNullableType < 'static >,
+            type_annotation) == 0usize);
+            assert!(std::mem::offset_of!(JSDocNonNullableType < 'static >, postfix) ==
+            24usize);
+        );
+    }
+    {
+        assert!(size_of::<JSDocUnknownType>() == 8usize);
+        assert!(align_of::<JSDocUnknownType>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(JSDocUnknownType, span) == 0usize););
+    }
+    {
+        assert!(size_of::<JSXElement<'static>>() == 56usize);
+        assert!(align_of::<JSXElement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXElement < 'static >, span) == 40usize);
+            assert!(std::mem::offset_of!(JSXElement < 'static >, opening_element) ==
+            0usize); assert!(std::mem::offset_of!(JSXElement < 'static >,
+            closing_element) == 48usize); assert!(std::mem::offset_of!(JSXElement <
+            'static >, children) == 8usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXOpeningElement<'static>>() == 72usize);
+        assert!(align_of::<JSXOpeningElement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXOpeningElement < 'static >, span) ==
+            48usize); assert!(std::mem::offset_of!(JSXOpeningElement < 'static >,
+            self_closing) == 64usize); assert!(std::mem::offset_of!(JSXOpeningElement <
+            'static >, name) == 0usize); assert!(std::mem::offset_of!(JSXOpeningElement <
+            'static >, attributes) == 16usize);
+            assert!(std::mem::offset_of!(JSXOpeningElement < 'static >, type_parameters)
+            == 56usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXClosingElement<'static>>() == 24usize);
+        assert!(align_of::<JSXClosingElement<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXClosingElement < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(JSXClosingElement < 'static >, name)
+            == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXFragment<'static>>() == 56usize);
+        assert!(align_of::<JSXFragment<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXFragment < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(JSXFragment < 'static >, opening_fragment) ==
+            40usize); assert!(std::mem::offset_of!(JSXFragment < 'static >,
+            closing_fragment) == 48usize); assert!(std::mem::offset_of!(JSXFragment <
+            'static >, children) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXOpeningFragment>() == 8usize);
+        assert!(align_of::<JSXOpeningFragment>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(JSXOpeningFragment, span) == 0usize););
+    }
+    {
+        assert!(size_of::<JSXClosingFragment>() == 8usize);
+        assert!(align_of::<JSXClosingFragment>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(JSXClosingFragment, span) == 0usize););
+    }
+    {
+        assert!(size_of::<JSXNamespacedName<'static>>() == 56usize);
+        assert!(align_of::<JSXNamespacedName<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXNamespacedName < 'static >, span) ==
+            48usize); assert!(std::mem::offset_of!(JSXNamespacedName < 'static >,
+            namespace) == 0usize); assert!(std::mem::offset_of!(JSXNamespacedName <
+            'static >, property) == 24usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXMemberExpression<'static>>() == 48usize);
+        assert!(align_of::<JSXMemberExpression<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXMemberExpression < 'static >, span) ==
+            40usize); assert!(std::mem::offset_of!(JSXMemberExpression < 'static >,
+            object) == 0usize); assert!(std::mem::offset_of!(JSXMemberExpression <
+            'static >, property) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXExpressionContainer<'static>>() == 24usize);
+        assert!(align_of::<JSXExpressionContainer<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXExpressionContainer < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(JSXExpressionContainer < 'static >,
+            expression) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXEmptyExpression>() == 8usize);
+        assert!(align_of::<JSXEmptyExpression>() == 4usize);
+        wrap!(assert!(std::mem::offset_of!(JSXEmptyExpression, span) == 0usize););
+    }
+    {
+        assert!(size_of::<JSXAttribute<'static>>() == 40usize);
+        assert!(align_of::<JSXAttribute<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXAttribute < 'static >, span) == 32usize);
+            assert!(std::mem::offset_of!(JSXAttribute < 'static >, name) == 0usize);
+            assert!(std::mem::offset_of!(JSXAttribute < 'static >, value) == 16usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXSpreadAttribute<'static>>() == 24usize);
+        assert!(align_of::<JSXSpreadAttribute<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXSpreadAttribute < 'static >, span) ==
+            16usize); assert!(std::mem::offset_of!(JSXSpreadAttribute < 'static >,
+            argument) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXIdentifier<'static>>() == 24usize);
+        assert!(align_of::<JSXIdentifier<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXIdentifier < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(JSXIdentifier < 'static >, name) == 0usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXSpreadChild<'static>>() == 24usize);
+        assert!(align_of::<JSXSpreadChild<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXSpreadChild < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(JSXSpreadChild < 'static >, expression) ==
+            0usize);
+        );
+    }
+    {
+        assert!(size_of::<JSXText<'static>>() == 24usize);
+        assert!(align_of::<JSXText<'static>>() == 8usize);
+        wrap!(
+            assert!(std::mem::offset_of!(JSXText < 'static >, span) == 16usize);
+            assert!(std::mem::offset_of!(JSXText < 'static >, value) == 0usize);
+        );
+    }
+};
diff --git a/crates/oxc_ast/src/lib.rs b/crates/oxc_ast/src/lib.rs
index 13f0efb7ba4ba..c3e4673c42ec1 100644
--- a/crates/oxc_ast/src/lib.rs
+++ b/crates/oxc_ast/src/lib.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::wildcard_imports)]
+#![allow(clippy::inconsistent_struct_constructor)]
 // TODO: I'm not sure if it is a but or intentional but clippy needs this allowed both on this
 // module and the generated one.
 #![allow(clippy::self_named_module_files)]
@@ -24,7 +25,6 @@
 //! [`AssignmentTarget`]: ast::AssignmentTarget
 //! [`oxc_parser`]: <https://docs.rs/oxc_parser>
 //! [`Parser`]: <https://docs.rs/oxc_parser/latest/oxc_parser/struct.Parser.html>
-
 #[cfg(feature = "serialize")]
 mod serialize;
 
@@ -39,6 +39,8 @@ mod trivia;
 mod generated {
     #[cfg(test)]
     pub mod assert_layouts;
+    // TODO: remove me; don't merge to upstream!!
+    pub mod assert_repr_rust_layout;
     pub mod ast_builder;
     pub mod ast_kind;
     pub mod span;
diff --git a/crates/oxc_ast_macros/Cargo.toml b/crates/oxc_ast_macros/Cargo.toml
index 5286f5812c24a..966084a110b80 100644
--- a/crates/oxc_ast_macros/Cargo.toml
+++ b/crates/oxc_ast_macros/Cargo.toml
@@ -24,3 +24,5 @@ doctest    = false
 quote = { workspace = true }
 syn = { workspace = true, features = ["full"] }
 proc-macro2 = { workspace = true }
+lazy_static = { workspace = true }
+rustc-hash  = { workspace = true }
diff --git a/crates/oxc_ast_macros/src/generated/ast_field_order_data.rs b/crates/oxc_ast_macros/src/generated/ast_field_order_data.rs
new file mode 100644
index 0000000000000..a1ee8f9280d18
--- /dev/null
+++ b/crates/oxc_ast_macros/src/generated/ast_field_order_data.rs
@@ -0,0 +1,405 @@
+// Auto-generated code, DO NOT EDIT DIRECTLY!
+// To edit this generated file you have to edit `tasks/ast_codegen/src/generators/ast_field_order.rs`
+
+use lazy_static::lazy_static;
+use rustc_hash::FxHashMap;
+
+pub fn get(ident: &str) -> Option<&[u8]> {
+    #[cfg(not(any(target_pointer_width = "64", target_pointer_width = "32")))]
+    std::compile_error!("Platforms with pointer width other than 64 or 32 bit are not supported");
+    #[cfg(target_pointer_width = "64")]
+    lazy_static! {
+        static ref DATA: FxHashMap<&'static str, &'static [u8]> = FxHashMap::from_iter([
+            ("BooleanLiteral", &[0u8, 1u8][..]),
+            ("NullLiteral", &[0u8][..]),
+            ("NumericLiteral", &[1u8, 2u8, 0u8, 3u8][..]),
+            ("BigIntLiteral", &[1u8, 0u8, 2u8][..]),
+            ("RegExpLiteral", &[1u8, 2u8, 0u8][..]),
+            ("RegExp", &[0u8, 1u8][..]),
+            ("StringLiteral", &[1u8, 0u8][..]),
+            ("Program", &[3u8, 4u8, 2u8, 0u8, 1u8, 5u8][..]),
+            ("IdentifierName", &[1u8, 0u8][..]),
+            ("IdentifierReference", &[1u8, 0u8, 2u8, 3u8][..]),
+            ("BindingIdentifier", &[1u8, 0u8, 2u8][..]),
+            ("LabelIdentifier", &[1u8, 0u8][..]),
+            ("ThisExpression", &[0u8][..]),
+            ("ArrayExpression", &[2u8, 0u8, 1u8][..]),
+            ("Elision", &[0u8][..]),
+            ("ObjectExpression", &[2u8, 0u8, 1u8][..]),
+            ("ObjectProperty", &[3u8, 4u8, 0u8, 1u8, 2u8, 5u8, 6u8, 7u8][..]),
+            ("TemplateLiteral", &[2u8, 0u8, 1u8][..]),
+            ("TaggedTemplateExpression", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("TemplateElement", &[1u8, 2u8, 0u8][..]),
+            ("TemplateElementValue", &[0u8, 1u8][..]),
+            ("ComputedMemberExpression", &[2u8, 0u8, 1u8, 3u8][..]),
+            ("StaticMemberExpression", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("PrivateFieldExpression", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("CallExpression", &[2u8, 0u8, 1u8, 3u8, 4u8][..]),
+            ("NewExpression", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("MetaProperty", &[2u8, 0u8, 1u8][..]),
+            ("SpreadElement", &[1u8, 0u8][..]),
+            ("UpdateExpression", &[1u8, 2u8, 3u8, 0u8][..]),
+            ("UnaryExpression", &[1u8, 2u8, 0u8][..]),
+            ("BinaryExpression", &[2u8, 0u8, 3u8, 1u8][..]),
+            ("PrivateInExpression", &[2u8, 0u8, 3u8, 1u8][..]),
+            ("LogicalExpression", &[2u8, 0u8, 3u8, 1u8][..]),
+            ("ConditionalExpression", &[3u8, 0u8, 1u8, 2u8][..]),
+            ("AssignmentExpression", &[2u8, 3u8, 0u8, 1u8][..]),
+            ("ArrayAssignmentTarget", &[3u8, 0u8, 1u8, 2u8][..]),
+            ("ObjectAssignmentTarget", &[2u8, 0u8, 1u8][..]),
+            ("AssignmentTargetRest", &[1u8, 0u8][..]),
+            ("AssignmentTargetWithDefault", &[2u8, 0u8, 1u8][..]),
+            ("AssignmentTargetPropertyIdentifier", &[2u8, 0u8, 1u8][..]),
+            ("AssignmentTargetPropertyProperty", &[2u8, 0u8, 1u8][..]),
+            ("SequenceExpression", &[1u8, 0u8][..]),
+            ("Super", &[0u8][..]),
+            ("AwaitExpression", &[1u8, 0u8][..]),
+            ("ChainExpression", &[1u8, 0u8][..]),
+            ("ParenthesizedExpression", &[1u8, 0u8][..]),
+            ("Directive", &[2u8, 0u8, 1u8][..]),
+            ("Hashbang", &[1u8, 0u8][..]),
+            ("BlockStatement", &[1u8, 0u8, 2u8][..]),
+            ("VariableDeclaration", &[1u8, 2u8, 0u8, 3u8][..]),
+            ("VariableDeclarator", &[2u8, 3u8, 0u8, 1u8, 4u8][..]),
+            ("UsingDeclaration", &[1u8, 2u8, 0u8][..]),
+            ("EmptyStatement", &[0u8][..]),
+            ("ExpressionStatement", &[1u8, 0u8][..]),
+            ("IfStatement", &[3u8, 0u8, 1u8, 2u8][..]),
+            ("DoWhileStatement", &[2u8, 0u8, 1u8][..]),
+            ("WhileStatement", &[2u8, 0u8, 1u8][..]),
+            ("ForStatement", &[4u8, 0u8, 1u8, 2u8, 3u8, 5u8][..]),
+            ("ForInStatement", &[3u8, 0u8, 1u8, 2u8, 4u8][..]),
+            ("ForOfStatement", &[3u8, 5u8, 0u8, 1u8, 2u8, 4u8][..]),
+            ("ContinueStatement", &[1u8, 0u8][..]),
+            ("BreakStatement", &[1u8, 0u8][..]),
+            ("ReturnStatement", &[1u8, 0u8][..]),
+            ("WithStatement", &[2u8, 0u8, 1u8][..]),
+            ("SwitchStatement", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("SwitchCase", &[2u8, 1u8, 0u8][..]),
+            ("LabeledStatement", &[2u8, 0u8, 1u8][..]),
+            ("ThrowStatement", &[1u8, 0u8][..]),
+            ("TryStatement", &[0u8, 1u8, 2u8, 3u8][..]),
+            ("CatchClause", &[1u8, 0u8, 2u8, 3u8][..]),
+            ("CatchParameter", &[1u8, 0u8][..]),
+            ("DebuggerStatement", &[0u8][..]),
+            ("BindingPattern", &[0u8, 1u8, 2u8][..]),
+            ("AssignmentPattern", &[2u8, 0u8, 1u8][..]),
+            ("ObjectPattern", &[1u8, 0u8, 2u8][..]),
+            ("BindingProperty", &[2u8, 1u8, 0u8, 3u8, 4u8][..]),
+            ("ArrayPattern", &[1u8, 0u8, 2u8][..]),
+            ("BindingRestElement", &[1u8, 0u8][..]),
+            ("Function", &[8u8, 2u8, 1u8, 9u8, 10u8, 11u8, 3u8, 0u8, 4u8, 5u8, 6u8, 7u8][..]),
+            ("FormalParameters", &[1u8, 3u8, 0u8, 2u8][..]),
+            ("FormalParameter", &[2u8, 0u8, 1u8, 3u8, 4u8, 5u8][..]),
+            ("FunctionBody", &[2u8, 0u8, 1u8][..]),
+            ("ArrowFunctionExpression", &[0u8, 6u8, 7u8, 1u8, 2u8, 3u8, 4u8, 5u8][..]),
+            ("YieldExpression", &[1u8, 2u8, 0u8][..]),
+            ("Class", &[9u8, 4u8, 0u8, 1u8, 5u8, 3u8, 6u8, 2u8, 7u8, 10u8, 11u8, 8u8][..]),
+            ("ClassBody", &[1u8, 0u8][..]),
+            ("MethodDefinition", &[4u8, 2u8, 0u8, 1u8, 3u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8][..]),
+            (
+                "PropertyDefinition",
+                &[5u8, 3u8, 0u8, 1u8, 2u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8, 4u8, 13u8][..]
+            ),
+            ("PrivateIdentifier", &[1u8, 0u8][..]),
+            ("StaticBlock", &[1u8, 0u8, 2u8][..]),
+            ("AccessorProperty", &[4u8, 3u8, 0u8, 1u8, 2u8, 5u8, 6u8][..]),
+            ("ImportExpression", &[2u8, 1u8, 0u8][..]),
+            ("ImportDeclaration", &[3u8, 1u8, 2u8, 0u8, 4u8][..]),
+            ("ImportSpecifier", &[2u8, 0u8, 1u8, 3u8][..]),
+            ("ImportDefaultSpecifier", &[1u8, 0u8][..]),
+            ("ImportNamespaceSpecifier", &[1u8, 0u8][..]),
+            ("WithClause", &[2u8, 1u8, 0u8][..]),
+            ("ImportAttribute", &[2u8, 0u8, 1u8][..]),
+            ("ExportNamedDeclaration", &[4u8, 3u8, 1u8, 2u8, 5u8, 0u8][..]),
+            ("ExportDefaultDeclaration", &[2u8, 1u8, 0u8][..]),
+            ("ExportAllDeclaration", &[3u8, 1u8, 2u8, 0u8, 4u8][..]),
+            ("ExportSpecifier", &[2u8, 0u8, 1u8, 3u8][..]),
+            ("TSThisParameter", &[1u8, 0u8, 2u8][..]),
+            ("TSEnumDeclaration", &[2u8, 0u8, 1u8, 4u8, 5u8, 3u8][..]),
+            ("TSEnumMember", &[2u8, 0u8, 1u8][..]),
+            ("TSTypeAnnotation", &[1u8, 0u8][..]),
+            ("TSLiteralType", &[1u8, 0u8][..]),
+            ("TSConditionalType", &[4u8, 0u8, 1u8, 2u8, 3u8, 5u8][..]),
+            ("TSUnionType", &[1u8, 0u8][..]),
+            ("TSIntersectionType", &[1u8, 0u8][..]),
+            ("TSParenthesizedType", &[1u8, 0u8][..]),
+            ("TSTypeOperator", &[1u8, 2u8, 0u8][..]),
+            ("TSArrayType", &[1u8, 0u8][..]),
+            ("TSIndexedAccessType", &[2u8, 0u8, 1u8][..]),
+            ("TSTupleType", &[1u8, 0u8][..]),
+            ("TSNamedTupleMember", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("TSOptionalType", &[1u8, 0u8][..]),
+            ("TSRestType", &[1u8, 0u8][..]),
+            ("TSAnyKeyword", &[0u8][..]),
+            ("TSStringKeyword", &[0u8][..]),
+            ("TSBooleanKeyword", &[0u8][..]),
+            ("TSNumberKeyword", &[0u8][..]),
+            ("TSNeverKeyword", &[0u8][..]),
+            ("TSIntrinsicKeyword", &[0u8][..]),
+            ("TSUnknownKeyword", &[0u8][..]),
+            ("TSNullKeyword", &[0u8][..]),
+            ("TSUndefinedKeyword", &[0u8][..]),
+            ("TSVoidKeyword", &[0u8][..]),
+            ("TSSymbolKeyword", &[0u8][..]),
+            ("TSThisType", &[0u8][..]),
+            ("TSObjectKeyword", &[0u8][..]),
+            ("TSBigIntKeyword", &[0u8][..]),
+            ("TSTypeReference", &[1u8, 0u8, 2u8][..]),
+            ("TSQualifiedName", &[2u8, 1u8, 0u8][..]),
+            ("TSTypeParameterInstantiation", &[1u8, 0u8][..]),
+            ("TSTypeParameter", &[3u8, 0u8, 1u8, 2u8, 4u8, 5u8, 6u8][..]),
+            ("TSTypeParameterDeclaration", &[1u8, 0u8][..]),
+            ("TSTypeAliasDeclaration", &[2u8, 0u8, 3u8, 1u8, 5u8, 4u8][..]),
+            ("TSClassImplements", &[1u8, 0u8, 2u8][..]),
+            ("TSInterfaceDeclaration", &[2u8, 0u8, 1u8, 3u8, 4u8, 6u8, 5u8][..]),
+            ("TSInterfaceBody", &[1u8, 0u8][..]),
+            ("TSPropertySignature", &[1u8, 3u8, 4u8, 5u8, 0u8, 2u8][..]),
+            ("TSIndexSignature", &[1u8, 0u8, 2u8, 3u8][..]),
+            ("TSCallSignatureDeclaration", &[1u8, 0u8, 2u8, 3u8, 4u8][..]),
+            ("TSMethodSignature", &[2u8, 1u8, 7u8, 8u8, 9u8, 0u8, 3u8, 4u8, 5u8, 6u8][..]),
+            ("TSConstructSignatureDeclaration", &[0u8, 1u8, 2u8, 3u8, 4u8][..]),
+            ("TSIndexSignatureName", &[1u8, 0u8, 2u8][..]),
+            ("TSInterfaceHeritage", &[1u8, 0u8, 2u8][..]),
+            ("TSTypePredicate", &[1u8, 0u8, 3u8, 2u8][..]),
+            ("TSModuleDeclaration", &[2u8, 0u8, 1u8, 4u8, 5u8, 3u8][..]),
+            ("TSModuleBlock", &[2u8, 0u8, 1u8][..]),
+            ("TSTypeLiteral", &[1u8, 0u8][..]),
+            ("TSInferType", &[0u8, 1u8][..]),
+            ("TSTypeQuery", &[1u8, 0u8, 2u8][..]),
+            ("TSImportType", &[3u8, 5u8, 1u8, 2u8, 0u8, 4u8][..]),
+            ("TSImportAttributes", &[1u8, 0u8][..]),
+            ("TSImportAttribute", &[2u8, 0u8, 1u8][..]),
+            ("TSFunctionType", &[1u8, 0u8, 2u8, 3u8, 4u8][..]),
+            ("TSConstructorType", &[0u8, 4u8, 1u8, 2u8, 3u8][..]),
+            ("TSMappedType", &[2u8, 3u8, 0u8, 1u8, 5u8, 6u8, 4u8][..]),
+            ("TSTemplateLiteralType", &[2u8, 0u8, 1u8][..]),
+            ("TSAsExpression", &[2u8, 0u8, 1u8][..]),
+            ("TSSatisfiesExpression", &[2u8, 0u8, 1u8][..]),
+            ("TSTypeAssertion", &[2u8, 0u8, 1u8][..]),
+            ("TSImportEqualsDeclaration", &[2u8, 0u8, 1u8, 3u8][..]),
+            ("TSExternalModuleReference", &[1u8, 0u8][..]),
+            ("TSNonNullExpression", &[1u8, 0u8][..]),
+            ("Decorator", &[1u8, 0u8][..]),
+            ("TSExportAssignment", &[1u8, 0u8][..]),
+            ("TSNamespaceExportDeclaration", &[1u8, 0u8][..]),
+            ("TSInstantiationExpression", &[1u8, 0u8, 2u8][..]),
+            ("JSDocNullableType", &[1u8, 0u8, 2u8][..]),
+            ("JSDocNonNullableType", &[1u8, 0u8, 2u8][..]),
+            ("JSDocUnknownType", &[0u8][..]),
+            ("JSXElement", &[1u8, 2u8, 3u8, 0u8][..]),
+            ("JSXOpeningElement", &[2u8, 4u8, 1u8, 0u8, 3u8][..]),
+            ("JSXClosingElement", &[1u8, 0u8][..]),
+            ("JSXFragment", &[1u8, 2u8, 3u8, 0u8][..]),
+            ("JSXOpeningFragment", &[0u8][..]),
+            ("JSXClosingFragment", &[0u8][..]),
+            ("JSXNamespacedName", &[2u8, 0u8, 1u8][..]),
+            ("JSXMemberExpression", &[2u8, 1u8, 0u8][..]),
+            ("JSXExpressionContainer", &[1u8, 0u8][..]),
+            ("JSXEmptyExpression", &[0u8][..]),
+            ("JSXAttribute", &[2u8, 0u8, 1u8][..]),
+            ("JSXSpreadAttribute", &[1u8, 0u8][..]),
+            ("JSXIdentifier", &[1u8, 0u8][..]),
+            ("JSXSpreadChild", &[1u8, 0u8][..]),
+            ("JSXText", &[1u8, 0u8][..])
+        ]);
+    }
+    #[cfg(target_pointer_width = "32")]
+    lazy_static! {
+        static ref DATA: FxHashMap<&'static str, &'static [u8]> = FxHashMap::from_iter([
+            ("BooleanLiteral", &[0u8, 1u8][..]),
+            ("NullLiteral", &[0u8][..]),
+            ("NumericLiteral", &[1u8, 2u8, 0u8, 3u8][..]),
+            ("BigIntLiteral", &[1u8, 0u8, 2u8][..]),
+            ("RegExpLiteral", &[1u8, 2u8, 0u8][..]),
+            ("RegExp", &[0u8, 1u8][..]),
+            ("StringLiteral", &[1u8, 0u8][..]),
+            ("Program", &[3u8, 4u8, 2u8, 0u8, 1u8, 5u8][..]),
+            ("IdentifierName", &[1u8, 0u8][..]),
+            ("IdentifierReference", &[1u8, 0u8, 2u8, 3u8][..]),
+            ("BindingIdentifier", &[1u8, 0u8, 2u8][..]),
+            ("LabelIdentifier", &[1u8, 0u8][..]),
+            ("ThisExpression", &[0u8][..]),
+            ("ArrayExpression", &[2u8, 0u8, 1u8][..]),
+            ("Elision", &[0u8][..]),
+            ("ObjectExpression", &[2u8, 0u8, 1u8][..]),
+            ("ObjectProperty", &[3u8, 4u8, 0u8, 1u8, 2u8, 5u8, 6u8, 7u8][..]),
+            ("TemplateLiteral", &[2u8, 0u8, 1u8][..]),
+            ("TaggedTemplateExpression", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("TemplateElement", &[1u8, 2u8, 0u8][..]),
+            ("TemplateElementValue", &[0u8, 1u8][..]),
+            ("ComputedMemberExpression", &[2u8, 0u8, 1u8, 3u8][..]),
+            ("StaticMemberExpression", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("PrivateFieldExpression", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("CallExpression", &[2u8, 0u8, 1u8, 3u8, 4u8][..]),
+            ("NewExpression", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("MetaProperty", &[2u8, 0u8, 1u8][..]),
+            ("SpreadElement", &[1u8, 0u8][..]),
+            ("UpdateExpression", &[1u8, 2u8, 3u8, 0u8][..]),
+            ("UnaryExpression", &[1u8, 2u8, 0u8][..]),
+            ("BinaryExpression", &[2u8, 0u8, 3u8, 1u8][..]),
+            ("PrivateInExpression", &[2u8, 0u8, 3u8, 1u8][..]),
+            ("LogicalExpression", &[2u8, 0u8, 3u8, 1u8][..]),
+            ("ConditionalExpression", &[3u8, 0u8, 1u8, 2u8][..]),
+            ("AssignmentExpression", &[2u8, 3u8, 0u8, 1u8][..]),
+            ("ArrayAssignmentTarget", &[3u8, 0u8, 1u8, 2u8][..]),
+            ("ObjectAssignmentTarget", &[2u8, 0u8, 1u8][..]),
+            ("AssignmentTargetRest", &[1u8, 0u8][..]),
+            ("AssignmentTargetWithDefault", &[2u8, 0u8, 1u8][..]),
+            ("AssignmentTargetPropertyIdentifier", &[2u8, 0u8, 1u8][..]),
+            ("AssignmentTargetPropertyProperty", &[2u8, 0u8, 1u8][..]),
+            ("SequenceExpression", &[1u8, 0u8][..]),
+            ("Super", &[0u8][..]),
+            ("AwaitExpression", &[1u8, 0u8][..]),
+            ("ChainExpression", &[1u8, 0u8][..]),
+            ("ParenthesizedExpression", &[1u8, 0u8][..]),
+            ("Directive", &[2u8, 0u8, 1u8][..]),
+            ("Hashbang", &[1u8, 0u8][..]),
+            ("BlockStatement", &[1u8, 0u8, 2u8][..]),
+            ("VariableDeclaration", &[1u8, 2u8, 0u8, 3u8][..]),
+            ("VariableDeclarator", &[2u8, 3u8, 0u8, 1u8, 4u8][..]),
+            ("UsingDeclaration", &[1u8, 2u8, 0u8][..]),
+            ("EmptyStatement", &[0u8][..]),
+            ("ExpressionStatement", &[1u8, 0u8][..]),
+            ("IfStatement", &[3u8, 0u8, 1u8, 2u8][..]),
+            ("DoWhileStatement", &[2u8, 0u8, 1u8][..]),
+            ("WhileStatement", &[2u8, 0u8, 1u8][..]),
+            ("ForStatement", &[4u8, 0u8, 1u8, 2u8, 3u8, 5u8][..]),
+            ("ForInStatement", &[3u8, 0u8, 1u8, 2u8, 4u8][..]),
+            ("ForOfStatement", &[3u8, 5u8, 0u8, 1u8, 2u8, 4u8][..]),
+            ("ContinueStatement", &[1u8, 0u8][..]),
+            ("BreakStatement", &[1u8, 0u8][..]),
+            ("ReturnStatement", &[1u8, 0u8][..]),
+            ("WithStatement", &[2u8, 0u8, 1u8][..]),
+            ("SwitchStatement", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("SwitchCase", &[2u8, 1u8, 0u8][..]),
+            ("LabeledStatement", &[2u8, 0u8, 1u8][..]),
+            ("ThrowStatement", &[1u8, 0u8][..]),
+            ("TryStatement", &[0u8, 1u8, 2u8, 3u8][..]),
+            ("CatchClause", &[1u8, 0u8, 2u8, 3u8][..]),
+            ("CatchParameter", &[1u8, 0u8][..]),
+            ("DebuggerStatement", &[0u8][..]),
+            ("BindingPattern", &[0u8, 1u8, 2u8][..]),
+            ("AssignmentPattern", &[2u8, 0u8, 1u8][..]),
+            ("ObjectPattern", &[1u8, 0u8, 2u8][..]),
+            ("BindingProperty", &[2u8, 1u8, 0u8, 3u8, 4u8][..]),
+            ("ArrayPattern", &[1u8, 0u8, 2u8][..]),
+            ("BindingRestElement", &[1u8, 0u8][..]),
+            ("Function", &[8u8, 2u8, 1u8, 9u8, 10u8, 11u8, 3u8, 0u8, 4u8, 5u8, 6u8, 7u8][..]),
+            ("FormalParameters", &[1u8, 3u8, 0u8, 2u8][..]),
+            ("FormalParameter", &[2u8, 0u8, 1u8, 3u8, 4u8, 5u8][..]),
+            ("FunctionBody", &[2u8, 0u8, 1u8][..]),
+            ("ArrowFunctionExpression", &[0u8, 6u8, 7u8, 1u8, 2u8, 3u8, 4u8, 5u8][..]),
+            ("YieldExpression", &[1u8, 2u8, 0u8][..]),
+            ("Class", &[9u8, 4u8, 0u8, 1u8, 5u8, 3u8, 6u8, 2u8, 7u8, 10u8, 11u8, 8u8][..]),
+            ("ClassBody", &[1u8, 0u8][..]),
+            ("MethodDefinition", &[4u8, 2u8, 0u8, 1u8, 3u8, 5u8, 6u8, 7u8, 8u8, 9u8, 10u8][..]),
+            (
+                "PropertyDefinition",
+                &[5u8, 3u8, 0u8, 1u8, 2u8, 6u8, 7u8, 8u8, 9u8, 10u8, 11u8, 12u8, 4u8, 13u8][..]
+            ),
+            ("PrivateIdentifier", &[1u8, 0u8][..]),
+            ("StaticBlock", &[1u8, 0u8, 2u8][..]),
+            ("AccessorProperty", &[4u8, 3u8, 0u8, 1u8, 2u8, 5u8, 6u8][..]),
+            ("ImportExpression", &[2u8, 1u8, 0u8][..]),
+            ("ImportDeclaration", &[3u8, 1u8, 2u8, 0u8, 4u8][..]),
+            ("ImportSpecifier", &[2u8, 0u8, 1u8, 3u8][..]),
+            ("ImportDefaultSpecifier", &[1u8, 0u8][..]),
+            ("ImportNamespaceSpecifier", &[1u8, 0u8][..]),
+            ("WithClause", &[2u8, 1u8, 0u8][..]),
+            ("ImportAttribute", &[2u8, 0u8, 1u8][..]),
+            ("ExportNamedDeclaration", &[4u8, 3u8, 1u8, 2u8, 5u8, 0u8][..]),
+            ("ExportDefaultDeclaration", &[2u8, 1u8, 0u8][..]),
+            ("ExportAllDeclaration", &[3u8, 1u8, 2u8, 0u8, 4u8][..]),
+            ("ExportSpecifier", &[2u8, 0u8, 1u8, 3u8][..]),
+            ("TSThisParameter", &[1u8, 0u8, 2u8][..]),
+            ("TSEnumDeclaration", &[2u8, 0u8, 1u8, 4u8, 5u8, 3u8][..]),
+            ("TSEnumMember", &[2u8, 0u8, 1u8][..]),
+            ("TSTypeAnnotation", &[1u8, 0u8][..]),
+            ("TSLiteralType", &[1u8, 0u8][..]),
+            ("TSConditionalType", &[4u8, 0u8, 1u8, 2u8, 3u8, 5u8][..]),
+            ("TSUnionType", &[1u8, 0u8][..]),
+            ("TSIntersectionType", &[1u8, 0u8][..]),
+            ("TSParenthesizedType", &[1u8, 0u8][..]),
+            ("TSTypeOperator", &[1u8, 2u8, 0u8][..]),
+            ("TSArrayType", &[1u8, 0u8][..]),
+            ("TSIndexedAccessType", &[2u8, 0u8, 1u8][..]),
+            ("TSTupleType", &[1u8, 0u8][..]),
+            ("TSNamedTupleMember", &[2u8, 1u8, 0u8, 3u8][..]),
+            ("TSOptionalType", &[1u8, 0u8][..]),
+            ("TSRestType", &[1u8, 0u8][..]),
+            ("TSAnyKeyword", &[0u8][..]),
+            ("TSStringKeyword", &[0u8][..]),
+            ("TSBooleanKeyword", &[0u8][..]),
+            ("TSNumberKeyword", &[0u8][..]),
+            ("TSNeverKeyword", &[0u8][..]),
+            ("TSIntrinsicKeyword", &[0u8][..]),
+            ("TSUnknownKeyword", &[0u8][..]),
+            ("TSNullKeyword", &[0u8][..]),
+            ("TSUndefinedKeyword", &[0u8][..]),
+            ("TSVoidKeyword", &[0u8][..]),
+            ("TSSymbolKeyword", &[0u8][..]),
+            ("TSThisType", &[0u8][..]),
+            ("TSObjectKeyword", &[0u8][..]),
+            ("TSBigIntKeyword", &[0u8][..]),
+            ("TSTypeReference", &[1u8, 0u8, 2u8][..]),
+            ("TSQualifiedName", &[2u8, 1u8, 0u8][..]),
+            ("TSTypeParameterInstantiation", &[1u8, 0u8][..]),
+            ("TSTypeParameter", &[3u8, 0u8, 1u8, 2u8, 4u8, 5u8, 6u8][..]),
+            ("TSTypeParameterDeclaration", &[1u8, 0u8][..]),
+            ("TSTypeAliasDeclaration", &[2u8, 0u8, 3u8, 1u8, 5u8, 4u8][..]),
+            ("TSClassImplements", &[1u8, 0u8, 2u8][..]),
+            ("TSInterfaceDeclaration", &[2u8, 0u8, 1u8, 3u8, 4u8, 6u8, 5u8][..]),
+            ("TSInterfaceBody", &[1u8, 0u8][..]),
+            ("TSPropertySignature", &[1u8, 3u8, 4u8, 5u8, 0u8, 2u8][..]),
+            ("TSIndexSignature", &[1u8, 0u8, 2u8, 3u8][..]),
+            ("TSCallSignatureDeclaration", &[1u8, 0u8, 2u8, 3u8, 4u8][..]),
+            ("TSMethodSignature", &[2u8, 1u8, 7u8, 8u8, 9u8, 0u8, 3u8, 4u8, 5u8, 6u8][..]),
+            ("TSConstructSignatureDeclaration", &[0u8, 1u8, 2u8, 3u8, 4u8][..]),
+            ("TSIndexSignatureName", &[1u8, 0u8, 2u8][..]),
+            ("TSInterfaceHeritage", &[1u8, 0u8, 2u8][..]),
+            ("TSTypePredicate", &[1u8, 0u8, 3u8, 2u8][..]),
+            ("TSModuleDeclaration", &[2u8, 0u8, 1u8, 4u8, 5u8, 3u8][..]),
+            ("TSModuleBlock", &[2u8, 0u8, 1u8][..]),
+            ("TSTypeLiteral", &[1u8, 0u8][..]),
+            ("TSInferType", &[0u8, 1u8][..]),
+            ("TSTypeQuery", &[1u8, 0u8, 2u8][..]),
+            ("TSImportType", &[3u8, 5u8, 1u8, 2u8, 0u8, 4u8][..]),
+            ("TSImportAttributes", &[1u8, 0u8][..]),
+            ("TSImportAttribute", &[2u8, 0u8, 1u8][..]),
+            ("TSFunctionType", &[1u8, 0u8, 2u8, 3u8, 4u8][..]),
+            ("TSConstructorType", &[0u8, 4u8, 1u8, 2u8, 3u8][..]),
+            ("TSMappedType", &[2u8, 3u8, 0u8, 1u8, 5u8, 6u8, 4u8][..]),
+            ("TSTemplateLiteralType", &[2u8, 0u8, 1u8][..]),
+            ("TSAsExpression", &[2u8, 0u8, 1u8][..]),
+            ("TSSatisfiesExpression", &[2u8, 0u8, 1u8][..]),
+            ("TSTypeAssertion", &[2u8, 0u8, 1u8][..]),
+            ("TSImportEqualsDeclaration", &[2u8, 0u8, 1u8, 3u8][..]),
+            ("TSExternalModuleReference", &[1u8, 0u8][..]),
+            ("TSNonNullExpression", &[1u8, 0u8][..]),
+            ("Decorator", &[1u8, 0u8][..]),
+            ("TSExportAssignment", &[1u8, 0u8][..]),
+            ("TSNamespaceExportDeclaration", &[1u8, 0u8][..]),
+            ("TSInstantiationExpression", &[1u8, 0u8, 2u8][..]),
+            ("JSDocNullableType", &[1u8, 0u8, 2u8][..]),
+            ("JSDocNonNullableType", &[1u8, 0u8, 2u8][..]),
+            ("JSDocUnknownType", &[0u8][..]),
+            ("JSXElement", &[1u8, 2u8, 3u8, 0u8][..]),
+            ("JSXOpeningElement", &[2u8, 4u8, 1u8, 0u8, 3u8][..]),
+            ("JSXClosingElement", &[1u8, 0u8][..]),
+            ("JSXFragment", &[1u8, 2u8, 3u8, 0u8][..]),
+            ("JSXOpeningFragment", &[0u8][..]),
+            ("JSXClosingFragment", &[0u8][..]),
+            ("JSXNamespacedName", &[2u8, 0u8, 1u8][..]),
+            ("JSXMemberExpression", &[2u8, 1u8, 0u8][..]),
+            ("JSXExpressionContainer", &[1u8, 0u8][..]),
+            ("JSXEmptyExpression", &[0u8][..]),
+            ("JSXAttribute", &[2u8, 0u8, 1u8][..]),
+            ("JSXSpreadAttribute", &[1u8, 0u8][..]),
+            ("JSXIdentifier", &[1u8, 0u8][..]),
+            ("JSXSpreadChild", &[1u8, 0u8][..]),
+            ("JSXText", &[1u8, 0u8][..])
+        ]);
+    }
+    DATA.get(ident).copied()
+}
diff --git a/crates/oxc_ast_macros/src/lib.rs b/crates/oxc_ast_macros/src/lib.rs
index 6b4220cdd8c6a..280d64cac08ad 100644
--- a/crates/oxc_ast_macros/src/lib.rs
+++ b/crates/oxc_ast_macros/src/lib.rs
@@ -1,6 +1,12 @@
+mod reorder_fields;
+mod generated {
+    pub mod ast_field_order_data;
+}
+
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
+use reorder_fields::reorder_fields;
 
 /// returns `#[repr(C, u8)]` if `enum_` has any non-unit variant,
 /// Otherwise it would return `#[repr(u8)]`.
@@ -25,10 +31,16 @@ fn enum_repr(enum_: &syn::ItemEnum) -> TokenStream2 {
 #[allow(clippy::missing_panics_doc)]
 pub fn ast(_args: TokenStream, input: TokenStream) -> TokenStream {
     let input = syn::parse_macro_input!(input as syn::Item);
-
-    let repr = match input {
-        syn::Item::Enum(ref enum_) => enum_repr(enum_),
-        syn::Item::Struct(_) => quote!(#[repr(C)]),
+    let (repr, item) = match input {
+        syn::Item::Enum(enum_) => (enum_repr(&enum_), syn::Item::Enum(enum_)),
+        syn::Item::Struct(mut struct_) => {
+            let id = struct_.ident.to_string();
+            // if we have field ordering data for this type use it to reorder.
+            if let Some(data) = generated::ast_field_order_data::get(id.as_str()) {
+                reorder_fields(&mut struct_, data);
+            };
+            (quote!(#[repr(C)]), syn::Item::Struct(struct_))
+        }
 
         _ => {
             unreachable!()
@@ -38,7 +50,7 @@ pub fn ast(_args: TokenStream, input: TokenStream) -> TokenStream {
     let expanded = quote! {
         #[derive(::oxc_ast_macros::Ast)]
         #repr
-        #input
+        #item
     };
     TokenStream::from(expanded)
 }
diff --git a/crates/oxc_ast_macros/src/reorder_fields.rs b/crates/oxc_ast_macros/src/reorder_fields.rs
new file mode 100644
index 0000000000000..2165ce854e850
--- /dev/null
+++ b/crates/oxc_ast_macros/src/reorder_fields.rs
@@ -0,0 +1,58 @@
+use proc_macro2::TokenStream;
+use quote::format_ident;
+use syn::{Field, Fields, FieldsNamed, FieldsUnnamed, ItemStruct};
+
+const DUMMY: &str = "DUMMY";
+
+#[inline]
+pub fn reorder_fields(ty: &mut ItemStruct, data: &[u8]) {
+    let (Fields::Named(FieldsNamed { named: fields, .. })
+    | Fields::Unnamed(FieldsUnnamed { unnamed: fields, .. })) = &mut ty.fields
+    else {
+        debug_assert!(false, "Entered unreachable code!");
+        // SAFETY: We don't generate any ordering data for empty structs, And the debug assertions
+        // are on in CI runs; The debug assertion above would ensure any possible mistake gets caught
+        // by tests early on in the PR's life span. This allows us to avoid a branch here.
+        unsafe { std::hint::unreachable_unchecked() }
+    };
+
+    // TODO: We can replace this with uninitialized memory, It might be faster if we use one byte
+    // to check if a field is placeholder or not and keep the rest of the bytes uninitialized as we
+    // never read them. I'm not sure if it is safe with a mutable reference or not but I believe it
+    // would be safe with exclusive ownership of the field.
+    let mut pick = Field {
+        attrs: Vec::default(),
+        vis: syn::Visibility::Inherited,
+        mutability: syn::FieldMutability::None,
+        ident: Some(format_ident!("{DUMMY}")),
+        colon_token: None,
+        ty: syn::Type::Verbatim(TokenStream::default()),
+    };
+    // TODO: use bit array here?
+    let mut is_ordered = vec![false; fields.len()];
+    let mut target;
+    // Best case O(n), Worst case O(2n)
+    for i in 0..fields.len() {
+        if is_ordered[i] {
+            continue;
+        }
+
+        let field = &mut fields[i];
+        // `pick` the first unordered field
+        pick = std::mem::replace(field, pick);
+        // capture its ideal position
+        target = data[i];
+
+        // while we have something in our `pick`
+        while pick.ident.as_ref().is_some_and(|it| it != DUMMY) {
+            // select the slot of target position
+            let field = &mut fields[target as usize];
+            // put the picked field in the target slot and pick the previous item
+            pick = std::mem::replace(field, pick);
+            // mark the field as ordered
+            is_ordered[target as usize] = true;
+            // capture the ideal position of our new pick
+            target = data[target as usize];
+        }
+    }
+}
diff --git a/tasks/ast_codegen/src/generators/ast_field_order.rs b/tasks/ast_codegen/src/generators/ast_field_order.rs
new file mode 100644
index 0000000000000..c44ebde54da86
--- /dev/null
+++ b/tasks/ast_codegen/src/generators/ast_field_order.rs
@@ -0,0 +1,90 @@
+use itertools::Itertools;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::ItemStruct;
+
+use crate::{layout::Layout, output, schema::RType, CodegenCtx, Generator, GeneratorOutput};
+
+use super::{define_generator, generated_header};
+
+define_generator! {
+    pub struct AstFieldOrder;
+}
+
+impl Generator for AstFieldOrder {
+    fn name(&self) -> &'static str {
+        stringify!(AstFieldOrder)
+    }
+
+    fn generate(&mut self, ctx: &CodegenCtx) -> GeneratorOutput {
+        let orders_64 = ctx
+            .ty_table
+            .iter()
+            .filter(|ty| matches!(&*ty.borrow(), RType::Struct(s) if !s.item.fields.is_empty()))
+            .map(|ty| {
+                let RType::Struct(ty) = &*ty.borrow() else { unreachable!() };
+                generate_orders(&ty.item, &ty.meta.layout_64)
+            });
+        let orders_32 = ctx
+            .ty_table
+            .iter()
+            .filter(|ty| matches!(&*ty.borrow(), RType::Struct(s) if !s.item.fields.is_empty()))
+            .map(|ty| {
+                let RType::Struct(ty) = &*ty.borrow() else { unreachable!() };
+                generate_orders(&ty.item, &ty.meta.layout_64)
+            });
+        let header = generated_header!();
+        GeneratorOutput::Stream((
+            output(crate::AST_MACROS_CRATE, "ast_field_order_data.rs"),
+            quote! {
+                #header
+                use lazy_static::lazy_static;
+                use rustc_hash::FxHashMap;
+
+                endl!();
+
+                pub fn get(ident: &str) -> Option<&[u8]> {
+
+                    #[cfg(not(any(target_pointer_width = "64", target_pointer_width = "32")))]
+                    std::compile_error!(
+                        "Platforms with pointer width other than 64 or 32 bit are not supported"
+                    );
+                    #[cfg(target_pointer_width = "64")]
+                    lazy_static! {
+                        static ref DATA: FxHashMap<&'static str, &'static [u8]> =
+                            FxHashMap::from_iter([#(#orders_64),*]);
+                    }
+                    #[cfg(target_pointer_width = "32")]
+                    lazy_static! {
+                        static ref DATA: FxHashMap<&'static str, &'static [u8]> =
+                            FxHashMap::from_iter([#(#orders_32),*]);
+                    }
+
+
+                    DATA.get(ident).copied()
+                }
+            },
+        ))
+    }
+}
+
+fn generate_orders(ty: &ItemStruct, layout: &Layout) -> Option<TokenStream> {
+    let ident = &ty.ident.to_string();
+    let Layout::Layout(layout) = layout else { panic!("Layout isn't determined yet!") };
+    let offsets = layout.offsets();
+    if let Some(offsets) = offsets {
+        let orders = offsets
+            .iter()
+            .zip(ty.fields.iter().enumerate())
+            .sorted_by(|a, b| Ord::cmp(a.0, b.0))
+            .map(|(_, fi)| fi)
+            .enumerate()
+            .sorted_by(|a, b| Ord::cmp(&a.1 .0, &b.1 .0))
+            .map(|it| {
+                u8::try_from(it.0).expect("We have no AST type with enough fields to exhaust `u8`.")
+            });
+        Some(quote!((#ident, &[#(#orders),*][..])))
+    } else {
+        None
+    }
+}
diff --git a/tasks/ast_codegen/src/generators/mod.rs b/tasks/ast_codegen/src/generators/mod.rs
index c8476221c53e9..9c76688272b30 100644
--- a/tasks/ast_codegen/src/generators/mod.rs
+++ b/tasks/ast_codegen/src/generators/mod.rs
@@ -1,5 +1,6 @@
 mod assert_layouts;
 mod ast_builder;
+mod ast_field_order;
 mod ast_kind;
 mod impl_get_span;
 mod visit;
@@ -42,6 +43,7 @@ pub(crate) use insert;
 
 pub use assert_layouts::AssertLayouts;
 pub use ast_builder::AstBuilderGenerator;
+pub use ast_field_order::AstFieldOrder;
 pub use ast_kind::AstKindGenerator;
 pub use impl_get_span::ImplGetSpanGenerator;
 pub use visit::{VisitGenerator, VisitMutGenerator};
diff --git a/tasks/ast_codegen/src/main.rs b/tasks/ast_codegen/src/main.rs
index 997a0c3b3b155..1c0b7ff22395e 100644
--- a/tasks/ast_codegen/src/main.rs
+++ b/tasks/ast_codegen/src/main.rs
@@ -1,5 +1,4 @@
 const AST_CRATE: &str = "crates/oxc_ast";
-#[allow(dead_code)]
 const AST_MACROS_CRATE: &str = "crates/oxc_ast_macros";
 
 mod defs;
@@ -22,7 +21,7 @@ use syn::parse_file;
 
 use defs::TypeDef;
 use generators::{
-    AssertLayouts, AstBuilderGenerator, AstKindGenerator, Generator, VisitGenerator,
+    AssertLayouts, AstBuilderGenerator, AstFieldOrder, AstKindGenerator, Generator, VisitGenerator,
     VisitMutGenerator,
 };
 use schema::{Module, REnum, RStruct, RType, Schema};
@@ -265,6 +264,7 @@ fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
         .pass(CalcLayout)
         .pass(BuildSchema)
         .gen(AssertLayouts)
+        .gen(AstFieldOrder)
         .gen(AstKindGenerator)
         .gen(AstBuilderGenerator)
         .gen(ImplGetSpanGenerator)
diff --git a/tasks/ast_codegen/src/passes/calc_layout.rs b/tasks/ast_codegen/src/passes/calc_layout.rs
index b9b8e3200821a..bd9a2d9fc7aba 100644
--- a/tasks/ast_codegen/src/passes/calc_layout.rs
+++ b/tasks/ast_codegen/src/passes/calc_layout.rs
@@ -164,7 +164,16 @@ fn calc_struct_layout(ty: &mut RStruct, ctx: &CodegenCtx) -> Result<PlatformLayo
     fn with_padding(
         layouts: &[KnownLayout],
     ) -> std::result::Result<KnownLayout, std::alloc::LayoutError> {
-        let layouts = layouts.iter().enumerate();
+        // reorder fields
+        let layouts = layouts.iter().enumerate().sorted_by(|a, b| {
+            let (ia, a) = a;
+            let (ib, b) = b;
+            if b.size() == a.size() {
+                Ord::cmp(&ia, &ib)
+            } else {
+                Ord::cmp(&b.size(), &a.size())
+            }
+        });
         let mut offsets = vec![0; layouts.len()];
         let mut output = std::alloc::Layout::from_size_align(0, 1)?;
         let mut niches = 0;