diff --git a/crates/oxc_ast/src/generated/assert_layouts.rs b/crates/oxc_ast/src/generated/assert_layouts.rs
index b39e5050a7b643..b2f9d5bca78965 100644
--- a/crates/oxc_ast/src/generated/assert_layouts.rs
+++ b/crates/oxc_ast/src/generated/assert_layouts.rs
@@ -1139,12 +1139,12 @@ const _: () = {
     assert!(offset_of!(NumericLiteral, span) == 0usize);
     assert!(offset_of!(NumericLiteral, value) == 8usize);
     assert!(offset_of!(NumericLiteral, raw) == 16usize);
-    assert!(offset_of!(NumericLiteral, base) == 32usize);
+    assert!(offset_of!(NumericLiteral, base) == 24usize);
     assert!(size_of::<BigIntLiteral>() == 20usize);
     assert!(align_of::<BigIntLiteral>() == 4usize);
     assert!(offset_of!(BigIntLiteral, span) == 0usize);
     assert!(offset_of!(BigIntLiteral, raw) == 8usize);
-    assert!(offset_of!(BigIntLiteral, base) == 24usize);
+    assert!(offset_of!(BigIntLiteral, base) == 16usize);
     assert!(size_of::<RegExpLiteral>() == 20usize);
     assert!(align_of::<RegExpLiteral>() == 4usize);
     assert!(offset_of!(RegExpLiteral, span) == 0usize);
@@ -1153,7 +1153,7 @@ const _: () = {
     assert!(size_of::<RegExp>() == 12usize);
     assert!(align_of::<RegExp>() == 4usize);
     assert!(offset_of!(RegExp, pattern) == 0usize);
-    assert!(offset_of!(RegExp, flags) == 16usize);
+    assert!(offset_of!(RegExp, flags) == 8usize);
     assert!(size_of::<EmptyObject>() == 0usize);
     assert!(align_of::<EmptyObject>() == 1usize);
     assert!(size_of::<StringLiteral>() == 16usize);
@@ -1164,10 +1164,10 @@ const _: () = {
     assert!(align_of::<Program>() == 4usize);
     assert!(offset_of!(Program, span) == 0usize);
     assert!(offset_of!(Program, source_type) == 8usize);
-    assert!(offset_of!(Program, hashbang) == 16usize);
-    assert!(offset_of!(Program, directives) == 40usize);
-    assert!(offset_of!(Program, body) == 72usize);
-    assert!(offset_of!(Program, scope_id) == 104usize);
+    assert!(offset_of!(Program, hashbang) == 12usize);
+    assert!(offset_of!(Program, directives) == 28usize);
+    assert!(offset_of!(Program, body) == 44usize);
+    assert!(offset_of!(Program, scope_id) == 60usize);
     assert!(size_of::<Expression>() == 8usize);
     assert!(align_of::<Expression>() == 4usize);
     assert!(size_of::<IdentifierName>() == 16usize);
@@ -1178,13 +1178,13 @@ const _: () = {
     assert!(align_of::<IdentifierReference>() == 4usize);
     assert!(offset_of!(IdentifierReference, span) == 0usize);
     assert!(offset_of!(IdentifierReference, name) == 8usize);
-    assert!(offset_of!(IdentifierReference, reference_id) == 24usize);
-    assert!(offset_of!(IdentifierReference, reference_flag) == 28usize);
+    assert!(offset_of!(IdentifierReference, reference_id) == 16usize);
+    assert!(offset_of!(IdentifierReference, reference_flag) == 20usize);
     assert!(size_of::<BindingIdentifier>() == 20usize);
     assert!(align_of::<BindingIdentifier>() == 4usize);
     assert!(offset_of!(BindingIdentifier, span) == 0usize);
     assert!(offset_of!(BindingIdentifier, name) == 8usize);
-    assert!(offset_of!(BindingIdentifier, symbol_id) == 24usize);
+    assert!(offset_of!(BindingIdentifier, symbol_id) == 16usize);
     assert!(size_of::<LabelIdentifier>() == 16usize);
     assert!(align_of::<LabelIdentifier>() == 4usize);
     assert!(offset_of!(LabelIdentifier, span) == 0usize);
@@ -1196,7 +1196,7 @@ const _: () = {
     assert!(align_of::<ArrayExpression>() == 4usize);
     assert!(offset_of!(ArrayExpression, span) == 0usize);
     assert!(offset_of!(ArrayExpression, elements) == 8usize);
-    assert!(offset_of!(ArrayExpression, trailing_comma) == 40usize);
+    assert!(offset_of!(ArrayExpression, trailing_comma) == 24usize);
     assert!(size_of::<ArrayExpressionElement>() == 12usize);
     assert!(align_of::<ArrayExpressionElement>() == 4usize);
     assert!(size_of::<Elision>() == 8usize);
@@ -1206,19 +1206,19 @@ const _: () = {
     assert!(align_of::<ObjectExpression>() == 4usize);
     assert!(offset_of!(ObjectExpression, span) == 0usize);
     assert!(offset_of!(ObjectExpression, properties) == 8usize);
-    assert!(offset_of!(ObjectExpression, trailing_comma) == 40usize);
+    assert!(offset_of!(ObjectExpression, trailing_comma) == 24usize);
     assert!(size_of::<ObjectPropertyKind>() == 8usize);
     assert!(align_of::<ObjectPropertyKind>() == 4usize);
     assert!(size_of::<ObjectProperty>() == 40usize);
     assert!(align_of::<ObjectProperty>() == 4usize);
     assert!(offset_of!(ObjectProperty, span) == 0usize);
     assert!(offset_of!(ObjectProperty, kind) == 8usize);
-    assert!(offset_of!(ObjectProperty, key) == 16usize);
-    assert!(offset_of!(ObjectProperty, value) == 32usize);
-    assert!(offset_of!(ObjectProperty, init) == 48usize);
-    assert!(offset_of!(ObjectProperty, method) == 64usize);
-    assert!(offset_of!(ObjectProperty, shorthand) == 65usize);
-    assert!(offset_of!(ObjectProperty, computed) == 66usize);
+    assert!(offset_of!(ObjectProperty, key) == 12usize);
+    assert!(offset_of!(ObjectProperty, value) == 20usize);
+    assert!(offset_of!(ObjectProperty, init) == 28usize);
+    assert!(offset_of!(ObjectProperty, method) == 36usize);
+    assert!(offset_of!(ObjectProperty, shorthand) == 37usize);
+    assert!(offset_of!(ObjectProperty, computed) == 38usize);
     assert!(size_of::<PropertyKey>() == 8usize);
     assert!(align_of::<PropertyKey>() == 4usize);
     assert!(size_of::<PropertyKind>() == 1usize);
@@ -1227,60 +1227,60 @@ const _: () = {
     assert!(align_of::<TemplateLiteral>() == 4usize);
     assert!(offset_of!(TemplateLiteral, span) == 0usize);
     assert!(offset_of!(TemplateLiteral, quasis) == 8usize);
-    assert!(offset_of!(TemplateLiteral, expressions) == 40usize);
+    assert!(offset_of!(TemplateLiteral, expressions) == 24usize);
     assert!(size_of::<TaggedTemplateExpression>() == 60usize);
     assert!(align_of::<TaggedTemplateExpression>() == 4usize);
     assert!(offset_of!(TaggedTemplateExpression, span) == 0usize);
     assert!(offset_of!(TaggedTemplateExpression, tag) == 8usize);
-    assert!(offset_of!(TaggedTemplateExpression, quasi) == 24usize);
-    assert!(offset_of!(TaggedTemplateExpression, type_parameters) == 96usize);
+    assert!(offset_of!(TaggedTemplateExpression, quasi) == 16usize);
+    assert!(offset_of!(TaggedTemplateExpression, type_parameters) == 56usize);
     assert!(size_of::<TemplateElement>() == 28usize);
     assert!(align_of::<TemplateElement>() == 4usize);
     assert!(offset_of!(TemplateElement, span) == 0usize);
     assert!(offset_of!(TemplateElement, tail) == 8usize);
-    assert!(offset_of!(TemplateElement, value) == 16usize);
+    assert!(offset_of!(TemplateElement, value) == 12usize);
     assert!(size_of::<TemplateElementValue>() == 16usize);
     assert!(align_of::<TemplateElementValue>() == 4usize);
     assert!(offset_of!(TemplateElementValue, raw) == 0usize);
-    assert!(offset_of!(TemplateElementValue, cooked) == 16usize);
+    assert!(offset_of!(TemplateElementValue, cooked) == 8usize);
     assert!(size_of::<MemberExpression>() == 8usize);
     assert!(align_of::<MemberExpression>() == 4usize);
     assert!(size_of::<ComputedMemberExpression>() == 28usize);
     assert!(align_of::<ComputedMemberExpression>() == 4usize);
     assert!(offset_of!(ComputedMemberExpression, span) == 0usize);
     assert!(offset_of!(ComputedMemberExpression, object) == 8usize);
-    assert!(offset_of!(ComputedMemberExpression, expression) == 24usize);
-    assert!(offset_of!(ComputedMemberExpression, optional) == 40usize);
+    assert!(offset_of!(ComputedMemberExpression, expression) == 16usize);
+    assert!(offset_of!(ComputedMemberExpression, optional) == 24usize);
     assert!(size_of::<StaticMemberExpression>() == 36usize);
     assert!(align_of::<StaticMemberExpression>() == 4usize);
     assert!(offset_of!(StaticMemberExpression, span) == 0usize);
     assert!(offset_of!(StaticMemberExpression, object) == 8usize);
-    assert!(offset_of!(StaticMemberExpression, property) == 24usize);
-    assert!(offset_of!(StaticMemberExpression, optional) == 48usize);
+    assert!(offset_of!(StaticMemberExpression, property) == 16usize);
+    assert!(offset_of!(StaticMemberExpression, optional) == 32usize);
     assert!(size_of::<PrivateFieldExpression>() == 36usize);
     assert!(align_of::<PrivateFieldExpression>() == 4usize);
     assert!(offset_of!(PrivateFieldExpression, span) == 0usize);
     assert!(offset_of!(PrivateFieldExpression, object) == 8usize);
-    assert!(offset_of!(PrivateFieldExpression, field) == 24usize);
-    assert!(offset_of!(PrivateFieldExpression, optional) == 48usize);
+    assert!(offset_of!(PrivateFieldExpression, field) == 16usize);
+    assert!(offset_of!(PrivateFieldExpression, optional) == 32usize);
     assert!(size_of::<CallExpression>() == 40usize);
     assert!(align_of::<CallExpression>() == 4usize);
     assert!(offset_of!(CallExpression, span) == 0usize);
     assert!(offset_of!(CallExpression, arguments) == 8usize);
-    assert!(offset_of!(CallExpression, callee) == 40usize);
-    assert!(offset_of!(CallExpression, type_parameters) == 56usize);
-    assert!(offset_of!(CallExpression, optional) == 64usize);
+    assert!(offset_of!(CallExpression, callee) == 24usize);
+    assert!(offset_of!(CallExpression, type_parameters) == 32usize);
+    assert!(offset_of!(CallExpression, optional) == 36usize);
     assert!(size_of::<NewExpression>() == 36usize);
     assert!(align_of::<NewExpression>() == 4usize);
     assert!(offset_of!(NewExpression, span) == 0usize);
     assert!(offset_of!(NewExpression, callee) == 8usize);
-    assert!(offset_of!(NewExpression, arguments) == 24usize);
-    assert!(offset_of!(NewExpression, type_parameters) == 56usize);
+    assert!(offset_of!(NewExpression, arguments) == 16usize);
+    assert!(offset_of!(NewExpression, type_parameters) == 32usize);
     assert!(size_of::<MetaProperty>() == 40usize);
     assert!(align_of::<MetaProperty>() == 4usize);
     assert!(offset_of!(MetaProperty, span) == 0usize);
     assert!(offset_of!(MetaProperty, meta) == 8usize);
-    assert!(offset_of!(MetaProperty, property) == 32usize);
+    assert!(offset_of!(MetaProperty, property) == 24usize);
     assert!(size_of::<SpreadElement>() == 16usize);
     assert!(align_of::<SpreadElement>() == 4usize);
     assert!(offset_of!(SpreadElement, span) == 0usize);
@@ -1292,42 +1292,42 @@ const _: () = {
     assert!(offset_of!(UpdateExpression, span) == 0usize);
     assert!(offset_of!(UpdateExpression, operator) == 8usize);
     assert!(offset_of!(UpdateExpression, prefix) == 9usize);
-    assert!(offset_of!(UpdateExpression, argument) == 16usize);
+    assert!(offset_of!(UpdateExpression, argument) == 12usize);
     assert!(size_of::<UnaryExpression>() == 20usize);
     assert!(align_of::<UnaryExpression>() == 4usize);
     assert!(offset_of!(UnaryExpression, span) == 0usize);
     assert!(offset_of!(UnaryExpression, operator) == 8usize);
-    assert!(offset_of!(UnaryExpression, argument) == 16usize);
+    assert!(offset_of!(UnaryExpression, argument) == 12usize);
     assert!(size_of::<BinaryExpression>() == 28usize);
     assert!(align_of::<BinaryExpression>() == 4usize);
     assert!(offset_of!(BinaryExpression, span) == 0usize);
     assert!(offset_of!(BinaryExpression, left) == 8usize);
-    assert!(offset_of!(BinaryExpression, operator) == 24usize);
-    assert!(offset_of!(BinaryExpression, right) == 32usize);
+    assert!(offset_of!(BinaryExpression, operator) == 16usize);
+    assert!(offset_of!(BinaryExpression, right) == 20usize);
     assert!(size_of::<PrivateInExpression>() == 36usize);
     assert!(align_of::<PrivateInExpression>() == 4usize);
     assert!(offset_of!(PrivateInExpression, span) == 0usize);
     assert!(offset_of!(PrivateInExpression, left) == 8usize);
-    assert!(offset_of!(PrivateInExpression, operator) == 32usize);
-    assert!(offset_of!(PrivateInExpression, right) == 40usize);
+    assert!(offset_of!(PrivateInExpression, operator) == 24usize);
+    assert!(offset_of!(PrivateInExpression, right) == 28usize);
     assert!(size_of::<LogicalExpression>() == 28usize);
     assert!(align_of::<LogicalExpression>() == 4usize);
     assert!(offset_of!(LogicalExpression, span) == 0usize);
     assert!(offset_of!(LogicalExpression, left) == 8usize);
-    assert!(offset_of!(LogicalExpression, operator) == 24usize);
-    assert!(offset_of!(LogicalExpression, right) == 32usize);
+    assert!(offset_of!(LogicalExpression, operator) == 16usize);
+    assert!(offset_of!(LogicalExpression, right) == 20usize);
     assert!(size_of::<ConditionalExpression>() == 32usize);
     assert!(align_of::<ConditionalExpression>() == 4usize);
     assert!(offset_of!(ConditionalExpression, span) == 0usize);
     assert!(offset_of!(ConditionalExpression, test) == 8usize);
-    assert!(offset_of!(ConditionalExpression, consequent) == 24usize);
-    assert!(offset_of!(ConditionalExpression, alternate) == 40usize);
+    assert!(offset_of!(ConditionalExpression, consequent) == 16usize);
+    assert!(offset_of!(ConditionalExpression, alternate) == 24usize);
     assert!(size_of::<AssignmentExpression>() == 28usize);
     assert!(align_of::<AssignmentExpression>() == 4usize);
     assert!(offset_of!(AssignmentExpression, span) == 0usize);
     assert!(offset_of!(AssignmentExpression, operator) == 8usize);
-    assert!(offset_of!(AssignmentExpression, left) == 16usize);
-    assert!(offset_of!(AssignmentExpression, right) == 32usize);
+    assert!(offset_of!(AssignmentExpression, left) == 12usize);
+    assert!(offset_of!(AssignmentExpression, right) == 20usize);
     assert!(size_of::<AssignmentTarget>() == 8usize);
     assert!(align_of::<AssignmentTarget>() == 4usize);
     assert!(size_of::<SimpleAssignmentTarget>() == 8usize);
@@ -1338,13 +1338,13 @@ const _: () = {
     assert!(align_of::<ArrayAssignmentTarget>() == 4usize);
     assert!(offset_of!(ArrayAssignmentTarget, span) == 0usize);
     assert!(offset_of!(ArrayAssignmentTarget, elements) == 8usize);
-    assert!(offset_of!(ArrayAssignmentTarget, rest) == 40usize);
-    assert!(offset_of!(ArrayAssignmentTarget, trailing_comma) == 64usize);
+    assert!(offset_of!(ArrayAssignmentTarget, rest) == 24usize);
+    assert!(offset_of!(ArrayAssignmentTarget, trailing_comma) == 40usize);
     assert!(size_of::<ObjectAssignmentTarget>() == 40usize);
     assert!(align_of::<ObjectAssignmentTarget>() == 4usize);
     assert!(offset_of!(ObjectAssignmentTarget, span) == 0usize);
     assert!(offset_of!(ObjectAssignmentTarget, properties) == 8usize);
-    assert!(offset_of!(ObjectAssignmentTarget, rest) == 40usize);
+    assert!(offset_of!(ObjectAssignmentTarget, rest) == 24usize);
     assert!(size_of::<AssignmentTargetRest>() == 16usize);
     assert!(align_of::<AssignmentTargetRest>() == 4usize);
     assert!(offset_of!(AssignmentTargetRest, span) == 0usize);
@@ -1355,19 +1355,19 @@ const _: () = {
     assert!(align_of::<AssignmentTargetWithDefault>() == 4usize);
     assert!(offset_of!(AssignmentTargetWithDefault, span) == 0usize);
     assert!(offset_of!(AssignmentTargetWithDefault, binding) == 8usize);
-    assert!(offset_of!(AssignmentTargetWithDefault, init) == 24usize);
+    assert!(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!(offset_of!(AssignmentTargetPropertyIdentifier, span) == 0usize);
     assert!(offset_of!(AssignmentTargetPropertyIdentifier, binding) == 8usize);
-    assert!(offset_of!(AssignmentTargetPropertyIdentifier, init) == 40usize);
+    assert!(offset_of!(AssignmentTargetPropertyIdentifier, init) == 32usize);
     assert!(size_of::<AssignmentTargetPropertyProperty>() == 24usize);
     assert!(align_of::<AssignmentTargetPropertyProperty>() == 4usize);
     assert!(offset_of!(AssignmentTargetPropertyProperty, span) == 0usize);
     assert!(offset_of!(AssignmentTargetPropertyProperty, name) == 8usize);
-    assert!(offset_of!(AssignmentTargetPropertyProperty, binding) == 24usize);
+    assert!(offset_of!(AssignmentTargetPropertyProperty, binding) == 16usize);
     assert!(size_of::<SequenceExpression>() == 24usize);
     assert!(align_of::<SequenceExpression>() == 4usize);
     assert!(offset_of!(SequenceExpression, span) == 0usize);
@@ -1395,7 +1395,7 @@ const _: () = {
     assert!(align_of::<Directive>() == 4usize);
     assert!(offset_of!(Directive, span) == 0usize);
     assert!(offset_of!(Directive, expression) == 8usize);
-    assert!(offset_of!(Directive, directive) == 32usize);
+    assert!(offset_of!(Directive, directive) == 24usize);
     assert!(size_of::<Hashbang>() == 16usize);
     assert!(align_of::<Hashbang>() == 4usize);
     assert!(offset_of!(Hashbang, span) == 0usize);
@@ -1404,29 +1404,29 @@ const _: () = {
     assert!(align_of::<BlockStatement>() == 4usize);
     assert!(offset_of!(BlockStatement, span) == 0usize);
     assert!(offset_of!(BlockStatement, body) == 8usize);
-    assert!(offset_of!(BlockStatement, scope_id) == 40usize);
+    assert!(offset_of!(BlockStatement, scope_id) == 24usize);
     assert!(size_of::<Declaration>() == 8usize);
     assert!(align_of::<Declaration>() == 4usize);
     assert!(size_of::<VariableDeclaration>() == 32usize);
     assert!(align_of::<VariableDeclaration>() == 4usize);
     assert!(offset_of!(VariableDeclaration, span) == 0usize);
     assert!(offset_of!(VariableDeclaration, kind) == 8usize);
-    assert!(offset_of!(VariableDeclaration, declarations) == 16usize);
-    assert!(offset_of!(VariableDeclaration, declare) == 48usize);
+    assert!(offset_of!(VariableDeclaration, declarations) == 12usize);
+    assert!(offset_of!(VariableDeclaration, declare) == 28usize);
     assert!(size_of::<VariableDeclarationKind>() == 1usize);
     assert!(align_of::<VariableDeclarationKind>() == 1usize);
     assert!(size_of::<VariableDeclarator>() == 40usize);
     assert!(align_of::<VariableDeclarator>() == 4usize);
     assert!(offset_of!(VariableDeclarator, span) == 0usize);
     assert!(offset_of!(VariableDeclarator, kind) == 8usize);
-    assert!(offset_of!(VariableDeclarator, id) == 16usize);
-    assert!(offset_of!(VariableDeclarator, init) == 48usize);
-    assert!(offset_of!(VariableDeclarator, definite) == 64usize);
+    assert!(offset_of!(VariableDeclarator, id) == 12usize);
+    assert!(offset_of!(VariableDeclarator, init) == 28usize);
+    assert!(offset_of!(VariableDeclarator, definite) == 36usize);
     assert!(size_of::<UsingDeclaration>() == 28usize);
     assert!(align_of::<UsingDeclaration>() == 4usize);
     assert!(offset_of!(UsingDeclaration, span) == 0usize);
     assert!(offset_of!(UsingDeclaration, is_await) == 8usize);
-    assert!(offset_of!(UsingDeclaration, declarations) == 16usize);
+    assert!(offset_of!(UsingDeclaration, declarations) == 12usize);
     assert!(size_of::<EmptyStatement>() == 8usize);
     assert!(align_of::<EmptyStatement>() == 4usize);
     assert!(offset_of!(EmptyStatement, span) == 0usize);
@@ -1438,45 +1438,45 @@ const _: () = {
     assert!(align_of::<IfStatement>() == 4usize);
     assert!(offset_of!(IfStatement, span) == 0usize);
     assert!(offset_of!(IfStatement, test) == 8usize);
-    assert!(offset_of!(IfStatement, consequent) == 24usize);
-    assert!(offset_of!(IfStatement, alternate) == 40usize);
+    assert!(offset_of!(IfStatement, consequent) == 16usize);
+    assert!(offset_of!(IfStatement, alternate) == 24usize);
     assert!(size_of::<DoWhileStatement>() == 24usize);
     assert!(align_of::<DoWhileStatement>() == 4usize);
     assert!(offset_of!(DoWhileStatement, span) == 0usize);
     assert!(offset_of!(DoWhileStatement, body) == 8usize);
-    assert!(offset_of!(DoWhileStatement, test) == 24usize);
+    assert!(offset_of!(DoWhileStatement, test) == 16usize);
     assert!(size_of::<WhileStatement>() == 24usize);
     assert!(align_of::<WhileStatement>() == 4usize);
     assert!(offset_of!(WhileStatement, span) == 0usize);
     assert!(offset_of!(WhileStatement, test) == 8usize);
-    assert!(offset_of!(WhileStatement, body) == 24usize);
+    assert!(offset_of!(WhileStatement, body) == 16usize);
     assert!(size_of::<ForStatement>() == 44usize);
     assert!(align_of::<ForStatement>() == 4usize);
     assert!(offset_of!(ForStatement, span) == 0usize);
     assert!(offset_of!(ForStatement, init) == 8usize);
-    assert!(offset_of!(ForStatement, test) == 24usize);
-    assert!(offset_of!(ForStatement, update) == 40usize);
-    assert!(offset_of!(ForStatement, body) == 56usize);
-    assert!(offset_of!(ForStatement, scope_id) == 72usize);
+    assert!(offset_of!(ForStatement, test) == 16usize);
+    assert!(offset_of!(ForStatement, update) == 24usize);
+    assert!(offset_of!(ForStatement, body) == 32usize);
+    assert!(offset_of!(ForStatement, scope_id) == 40usize);
     assert!(size_of::<ForStatementInit>() == 8usize);
     assert!(align_of::<ForStatementInit>() == 4usize);
     assert!(size_of::<ForInStatement>() == 36usize);
     assert!(align_of::<ForInStatement>() == 4usize);
     assert!(offset_of!(ForInStatement, span) == 0usize);
     assert!(offset_of!(ForInStatement, left) == 8usize);
-    assert!(offset_of!(ForInStatement, right) == 24usize);
-    assert!(offset_of!(ForInStatement, body) == 40usize);
-    assert!(offset_of!(ForInStatement, scope_id) == 56usize);
+    assert!(offset_of!(ForInStatement, right) == 16usize);
+    assert!(offset_of!(ForInStatement, body) == 24usize);
+    assert!(offset_of!(ForInStatement, scope_id) == 32usize);
     assert!(size_of::<ForStatementLeft>() == 8usize);
     assert!(align_of::<ForStatementLeft>() == 4usize);
     assert!(size_of::<ForOfStatement>() == 40usize);
     assert!(align_of::<ForOfStatement>() == 4usize);
     assert!(offset_of!(ForOfStatement, span) == 0usize);
     assert!(offset_of!(ForOfStatement, r#await) == 8usize);
-    assert!(offset_of!(ForOfStatement, left) == 16usize);
-    assert!(offset_of!(ForOfStatement, right) == 32usize);
-    assert!(offset_of!(ForOfStatement, body) == 48usize);
-    assert!(offset_of!(ForOfStatement, scope_id) == 64usize);
+    assert!(offset_of!(ForOfStatement, left) == 12usize);
+    assert!(offset_of!(ForOfStatement, right) == 20usize);
+    assert!(offset_of!(ForOfStatement, body) == 28usize);
+    assert!(offset_of!(ForOfStatement, scope_id) == 36usize);
     assert!(size_of::<ContinueStatement>() == 24usize);
     assert!(align_of::<ContinueStatement>() == 4usize);
     assert!(offset_of!(ContinueStatement, span) == 0usize);
@@ -1493,23 +1493,23 @@ const _: () = {
     assert!(align_of::<WithStatement>() == 4usize);
     assert!(offset_of!(WithStatement, span) == 0usize);
     assert!(offset_of!(WithStatement, object) == 8usize);
-    assert!(offset_of!(WithStatement, body) == 24usize);
+    assert!(offset_of!(WithStatement, body) == 16usize);
     assert!(size_of::<SwitchStatement>() == 36usize);
     assert!(align_of::<SwitchStatement>() == 4usize);
     assert!(offset_of!(SwitchStatement, span) == 0usize);
     assert!(offset_of!(SwitchStatement, discriminant) == 8usize);
-    assert!(offset_of!(SwitchStatement, cases) == 24usize);
-    assert!(offset_of!(SwitchStatement, scope_id) == 56usize);
+    assert!(offset_of!(SwitchStatement, cases) == 16usize);
+    assert!(offset_of!(SwitchStatement, scope_id) == 32usize);
     assert!(size_of::<SwitchCase>() == 32usize);
     assert!(align_of::<SwitchCase>() == 4usize);
     assert!(offset_of!(SwitchCase, span) == 0usize);
     assert!(offset_of!(SwitchCase, test) == 8usize);
-    assert!(offset_of!(SwitchCase, consequent) == 24usize);
+    assert!(offset_of!(SwitchCase, consequent) == 16usize);
     assert!(size_of::<LabeledStatement>() == 32usize);
     assert!(align_of::<LabeledStatement>() == 4usize);
     assert!(offset_of!(LabeledStatement, span) == 0usize);
     assert!(offset_of!(LabeledStatement, label) == 8usize);
-    assert!(offset_of!(LabeledStatement, body) == 32usize);
+    assert!(offset_of!(LabeledStatement, body) == 24usize);
     assert!(size_of::<ThrowStatement>() == 16usize);
     assert!(align_of::<ThrowStatement>() == 4usize);
     assert!(offset_of!(ThrowStatement, span) == 0usize);
@@ -1518,14 +1518,14 @@ const _: () = {
     assert!(align_of::<TryStatement>() == 4usize);
     assert!(offset_of!(TryStatement, span) == 0usize);
     assert!(offset_of!(TryStatement, block) == 8usize);
-    assert!(offset_of!(TryStatement, handler) == 16usize);
-    assert!(offset_of!(TryStatement, finalizer) == 24usize);
+    assert!(offset_of!(TryStatement, handler) == 12usize);
+    assert!(offset_of!(TryStatement, finalizer) == 16usize);
     assert!(size_of::<CatchClause>() == 40usize);
     assert!(align_of::<CatchClause>() == 4usize);
     assert!(offset_of!(CatchClause, span) == 0usize);
     assert!(offset_of!(CatchClause, param) == 8usize);
-    assert!(offset_of!(CatchClause, body) == 48usize);
-    assert!(offset_of!(CatchClause, scope_id) == 56usize);
+    assert!(offset_of!(CatchClause, body) == 32usize);
+    assert!(offset_of!(CatchClause, scope_id) == 36usize);
     assert!(size_of::<CatchParameter>() == 24usize);
     assert!(align_of::<CatchParameter>() == 4usize);
     assert!(offset_of!(CatchParameter, span) == 0usize);
@@ -1536,32 +1536,32 @@ const _: () = {
     assert!(size_of::<BindingPattern>() == 16usize);
     assert!(align_of::<BindingPattern>() == 4usize);
     assert!(offset_of!(BindingPattern, kind) == 0usize);
-    assert!(offset_of!(BindingPattern, type_annotation) == 16usize);
-    assert!(offset_of!(BindingPattern, optional) == 24usize);
+    assert!(offset_of!(BindingPattern, type_annotation) == 8usize);
+    assert!(offset_of!(BindingPattern, optional) == 12usize);
     assert!(size_of::<BindingPatternKind>() == 8usize);
     assert!(align_of::<BindingPatternKind>() == 4usize);
     assert!(size_of::<AssignmentPattern>() == 32usize);
     assert!(align_of::<AssignmentPattern>() == 4usize);
     assert!(offset_of!(AssignmentPattern, span) == 0usize);
     assert!(offset_of!(AssignmentPattern, left) == 8usize);
-    assert!(offset_of!(AssignmentPattern, right) == 40usize);
+    assert!(offset_of!(AssignmentPattern, right) == 24usize);
     assert!(size_of::<ObjectPattern>() == 28usize);
     assert!(align_of::<ObjectPattern>() == 4usize);
     assert!(offset_of!(ObjectPattern, span) == 0usize);
     assert!(offset_of!(ObjectPattern, properties) == 8usize);
-    assert!(offset_of!(ObjectPattern, rest) == 40usize);
+    assert!(offset_of!(ObjectPattern, rest) == 24usize);
     assert!(size_of::<BindingProperty>() == 36usize);
     assert!(align_of::<BindingProperty>() == 4usize);
     assert!(offset_of!(BindingProperty, span) == 0usize);
     assert!(offset_of!(BindingProperty, key) == 8usize);
-    assert!(offset_of!(BindingProperty, value) == 24usize);
-    assert!(offset_of!(BindingProperty, shorthand) == 56usize);
-    assert!(offset_of!(BindingProperty, computed) == 57usize);
+    assert!(offset_of!(BindingProperty, value) == 16usize);
+    assert!(offset_of!(BindingProperty, shorthand) == 32usize);
+    assert!(offset_of!(BindingProperty, computed) == 33usize);
     assert!(size_of::<ArrayPattern>() == 28usize);
     assert!(align_of::<ArrayPattern>() == 4usize);
     assert!(offset_of!(ArrayPattern, span) == 0usize);
     assert!(offset_of!(ArrayPattern, elements) == 8usize);
-    assert!(offset_of!(ArrayPattern, rest) == 40usize);
+    assert!(offset_of!(ArrayPattern, rest) == 24usize);
     assert!(size_of::<BindingRestElement>() == 24usize);
     assert!(align_of::<BindingRestElement>() == 4usize);
     assert!(offset_of!(BindingRestElement, span) == 0usize);
@@ -1570,68 +1570,68 @@ const _: () = {
     assert!(align_of::<Function>() == 4usize);
     assert!(offset_of!(Function, r#type) == 0usize);
     assert!(offset_of!(Function, span) == 4usize);
-    assert!(offset_of!(Function, id) == 16usize);
-    assert!(offset_of!(Function, generator) == 48usize);
-    assert!(offset_of!(Function, r#async) == 49usize);
-    assert!(offset_of!(Function, declare) == 50usize);
-    assert!(offset_of!(Function, type_parameters) == 56usize);
-    assert!(offset_of!(Function, this_param) == 64usize);
-    assert!(offset_of!(Function, params) == 104usize);
-    assert!(offset_of!(Function, return_type) == 112usize);
-    assert!(offset_of!(Function, body) == 120usize);
-    assert!(offset_of!(Function, scope_id) == 128usize);
+    assert!(offset_of!(Function, id) == 12usize);
+    assert!(offset_of!(Function, generator) == 32usize);
+    assert!(offset_of!(Function, r#async) == 33usize);
+    assert!(offset_of!(Function, declare) == 34usize);
+    assert!(offset_of!(Function, type_parameters) == 36usize);
+    assert!(offset_of!(Function, this_param) == 40usize);
+    assert!(offset_of!(Function, params) == 68usize);
+    assert!(offset_of!(Function, return_type) == 72usize);
+    assert!(offset_of!(Function, body) == 76usize);
+    assert!(offset_of!(Function, scope_id) == 80usize);
     assert!(size_of::<FunctionType>() == 1usize);
     assert!(align_of::<FunctionType>() == 1usize);
     assert!(size_of::<FormalParameters>() == 32usize);
     assert!(align_of::<FormalParameters>() == 4usize);
     assert!(offset_of!(FormalParameters, span) == 0usize);
     assert!(offset_of!(FormalParameters, kind) == 8usize);
-    assert!(offset_of!(FormalParameters, items) == 16usize);
-    assert!(offset_of!(FormalParameters, rest) == 48usize);
+    assert!(offset_of!(FormalParameters, items) == 12usize);
+    assert!(offset_of!(FormalParameters, rest) == 28usize);
     assert!(size_of::<FormalParameter>() == 44usize);
     assert!(align_of::<FormalParameter>() == 4usize);
     assert!(offset_of!(FormalParameter, span) == 0usize);
     assert!(offset_of!(FormalParameter, decorators) == 8usize);
-    assert!(offset_of!(FormalParameter, pattern) == 40usize);
-    assert!(offset_of!(FormalParameter, accessibility) == 72usize);
-    assert!(offset_of!(FormalParameter, readonly) == 73usize);
-    assert!(offset_of!(FormalParameter, r#override) == 74usize);
+    assert!(offset_of!(FormalParameter, pattern) == 24usize);
+    assert!(offset_of!(FormalParameter, accessibility) == 40usize);
+    assert!(offset_of!(FormalParameter, readonly) == 41usize);
+    assert!(offset_of!(FormalParameter, r#override) == 42usize);
     assert!(size_of::<FormalParameterKind>() == 1usize);
     assert!(align_of::<FormalParameterKind>() == 1usize);
     assert!(size_of::<FunctionBody>() == 40usize);
     assert!(align_of::<FunctionBody>() == 4usize);
     assert!(offset_of!(FunctionBody, span) == 0usize);
     assert!(offset_of!(FunctionBody, directives) == 8usize);
-    assert!(offset_of!(FunctionBody, statements) == 40usize);
+    assert!(offset_of!(FunctionBody, statements) == 24usize);
     assert!(size_of::<ArrowFunctionExpression>() == 32usize);
     assert!(align_of::<ArrowFunctionExpression>() == 4usize);
     assert!(offset_of!(ArrowFunctionExpression, span) == 0usize);
     assert!(offset_of!(ArrowFunctionExpression, expression) == 8usize);
     assert!(offset_of!(ArrowFunctionExpression, r#async) == 9usize);
-    assert!(offset_of!(ArrowFunctionExpression, type_parameters) == 16usize);
-    assert!(offset_of!(ArrowFunctionExpression, params) == 24usize);
-    assert!(offset_of!(ArrowFunctionExpression, return_type) == 32usize);
-    assert!(offset_of!(ArrowFunctionExpression, body) == 40usize);
-    assert!(offset_of!(ArrowFunctionExpression, scope_id) == 48usize);
+    assert!(offset_of!(ArrowFunctionExpression, type_parameters) == 12usize);
+    assert!(offset_of!(ArrowFunctionExpression, params) == 16usize);
+    assert!(offset_of!(ArrowFunctionExpression, return_type) == 20usize);
+    assert!(offset_of!(ArrowFunctionExpression, body) == 24usize);
+    assert!(offset_of!(ArrowFunctionExpression, scope_id) == 28usize);
     assert!(size_of::<YieldExpression>() == 20usize);
     assert!(align_of::<YieldExpression>() == 4usize);
     assert!(offset_of!(YieldExpression, span) == 0usize);
     assert!(offset_of!(YieldExpression, delegate) == 8usize);
-    assert!(offset_of!(YieldExpression, argument) == 16usize);
+    assert!(offset_of!(YieldExpression, argument) == 12usize);
     assert!(size_of::<Class>() == 92usize);
     assert!(align_of::<Class>() == 4usize);
     assert!(offset_of!(Class, r#type) == 0usize);
     assert!(offset_of!(Class, span) == 4usize);
-    assert!(offset_of!(Class, decorators) == 16usize);
-    assert!(offset_of!(Class, id) == 48usize);
-    assert!(offset_of!(Class, type_parameters) == 80usize);
-    assert!(offset_of!(Class, super_class) == 88usize);
-    assert!(offset_of!(Class, super_type_parameters) == 104usize);
-    assert!(offset_of!(Class, implements) == 112usize);
-    assert!(offset_of!(Class, body) == 144usize);
-    assert!(offset_of!(Class, r#abstract) == 152usize);
-    assert!(offset_of!(Class, declare) == 153usize);
-    assert!(offset_of!(Class, scope_id) == 156usize);
+    assert!(offset_of!(Class, decorators) == 12usize);
+    assert!(offset_of!(Class, id) == 28usize);
+    assert!(offset_of!(Class, type_parameters) == 48usize);
+    assert!(offset_of!(Class, super_class) == 52usize);
+    assert!(offset_of!(Class, super_type_parameters) == 60usize);
+    assert!(offset_of!(Class, implements) == 64usize);
+    assert!(offset_of!(Class, body) == 80usize);
+    assert!(offset_of!(Class, r#abstract) == 84usize);
+    assert!(offset_of!(Class, declare) == 85usize);
+    assert!(offset_of!(Class, scope_id) == 88usize);
     assert!(size_of::<ClassType>() == 1usize);
     assert!(align_of::<ClassType>() == 1usize);
     assert!(size_of::<ClassBody>() == 24usize);
@@ -1644,33 +1644,33 @@ const _: () = {
     assert!(align_of::<MethodDefinition>() == 4usize);
     assert!(offset_of!(MethodDefinition, r#type) == 0usize);
     assert!(offset_of!(MethodDefinition, span) == 4usize);
-    assert!(offset_of!(MethodDefinition, decorators) == 16usize);
-    assert!(offset_of!(MethodDefinition, key) == 48usize);
-    assert!(offset_of!(MethodDefinition, value) == 64usize);
-    assert!(offset_of!(MethodDefinition, kind) == 72usize);
-    assert!(offset_of!(MethodDefinition, computed) == 73usize);
-    assert!(offset_of!(MethodDefinition, r#static) == 74usize);
-    assert!(offset_of!(MethodDefinition, r#override) == 75usize);
-    assert!(offset_of!(MethodDefinition, optional) == 76usize);
-    assert!(offset_of!(MethodDefinition, accessibility) == 77usize);
+    assert!(offset_of!(MethodDefinition, decorators) == 12usize);
+    assert!(offset_of!(MethodDefinition, key) == 28usize);
+    assert!(offset_of!(MethodDefinition, value) == 36usize);
+    assert!(offset_of!(MethodDefinition, kind) == 40usize);
+    assert!(offset_of!(MethodDefinition, computed) == 41usize);
+    assert!(offset_of!(MethodDefinition, r#static) == 42usize);
+    assert!(offset_of!(MethodDefinition, r#override) == 43usize);
+    assert!(offset_of!(MethodDefinition, optional) == 44usize);
+    assert!(offset_of!(MethodDefinition, accessibility) == 45usize);
     assert!(size_of::<MethodDefinitionType>() == 1usize);
     assert!(align_of::<MethodDefinitionType>() == 1usize);
     assert!(size_of::<PropertyDefinition>() == 60usize);
     assert!(align_of::<PropertyDefinition>() == 4usize);
     assert!(offset_of!(PropertyDefinition, r#type) == 0usize);
     assert!(offset_of!(PropertyDefinition, span) == 4usize);
-    assert!(offset_of!(PropertyDefinition, decorators) == 16usize);
-    assert!(offset_of!(PropertyDefinition, key) == 48usize);
-    assert!(offset_of!(PropertyDefinition, value) == 64usize);
-    assert!(offset_of!(PropertyDefinition, computed) == 80usize);
-    assert!(offset_of!(PropertyDefinition, r#static) == 81usize);
-    assert!(offset_of!(PropertyDefinition, declare) == 82usize);
-    assert!(offset_of!(PropertyDefinition, r#override) == 83usize);
-    assert!(offset_of!(PropertyDefinition, optional) == 84usize);
-    assert!(offset_of!(PropertyDefinition, definite) == 85usize);
-    assert!(offset_of!(PropertyDefinition, readonly) == 86usize);
-    assert!(offset_of!(PropertyDefinition, type_annotation) == 88usize);
-    assert!(offset_of!(PropertyDefinition, accessibility) == 96usize);
+    assert!(offset_of!(PropertyDefinition, decorators) == 12usize);
+    assert!(offset_of!(PropertyDefinition, key) == 28usize);
+    assert!(offset_of!(PropertyDefinition, value) == 36usize);
+    assert!(offset_of!(PropertyDefinition, computed) == 44usize);
+    assert!(offset_of!(PropertyDefinition, r#static) == 45usize);
+    assert!(offset_of!(PropertyDefinition, declare) == 46usize);
+    assert!(offset_of!(PropertyDefinition, r#override) == 47usize);
+    assert!(offset_of!(PropertyDefinition, optional) == 48usize);
+    assert!(offset_of!(PropertyDefinition, definite) == 49usize);
+    assert!(offset_of!(PropertyDefinition, readonly) == 50usize);
+    assert!(offset_of!(PropertyDefinition, type_annotation) == 52usize);
+    assert!(offset_of!(PropertyDefinition, accessibility) == 56usize);
     assert!(size_of::<PropertyDefinitionType>() == 1usize);
     assert!(align_of::<PropertyDefinitionType>() == 1usize);
     assert!(size_of::<MethodDefinitionKind>() == 1usize);
@@ -1683,7 +1683,7 @@ const _: () = {
     assert!(align_of::<StaticBlock>() == 4usize);
     assert!(offset_of!(StaticBlock, span) == 0usize);
     assert!(offset_of!(StaticBlock, body) == 8usize);
-    assert!(offset_of!(StaticBlock, scope_id) == 40usize);
+    assert!(offset_of!(StaticBlock, scope_id) == 24usize);
     assert!(size_of::<ModuleDeclaration>() == 8usize);
     assert!(align_of::<ModuleDeclaration>() == 4usize);
     assert!(size_of::<AccessorPropertyType>() == 1usize);
@@ -1692,31 +1692,31 @@ const _: () = {
     assert!(align_of::<AccessorProperty>() == 4usize);
     assert!(offset_of!(AccessorProperty, r#type) == 0usize);
     assert!(offset_of!(AccessorProperty, span) == 4usize);
-    assert!(offset_of!(AccessorProperty, decorators) == 16usize);
-    assert!(offset_of!(AccessorProperty, key) == 48usize);
-    assert!(offset_of!(AccessorProperty, value) == 64usize);
-    assert!(offset_of!(AccessorProperty, computed) == 80usize);
-    assert!(offset_of!(AccessorProperty, r#static) == 81usize);
+    assert!(offset_of!(AccessorProperty, decorators) == 12usize);
+    assert!(offset_of!(AccessorProperty, key) == 28usize);
+    assert!(offset_of!(AccessorProperty, value) == 36usize);
+    assert!(offset_of!(AccessorProperty, computed) == 44usize);
+    assert!(offset_of!(AccessorProperty, r#static) == 45usize);
     assert!(size_of::<ImportExpression>() == 32usize);
     assert!(align_of::<ImportExpression>() == 4usize);
     assert!(offset_of!(ImportExpression, span) == 0usize);
     assert!(offset_of!(ImportExpression, source) == 8usize);
-    assert!(offset_of!(ImportExpression, arguments) == 24usize);
+    assert!(offset_of!(ImportExpression, arguments) == 16usize);
     assert!(size_of::<ImportDeclaration>() == 84usize);
     assert!(align_of::<ImportDeclaration>() == 4usize);
     assert!(offset_of!(ImportDeclaration, span) == 0usize);
     assert!(offset_of!(ImportDeclaration, specifiers) == 8usize);
-    assert!(offset_of!(ImportDeclaration, source) == 40usize);
-    assert!(offset_of!(ImportDeclaration, with_clause) == 64usize);
-    assert!(offset_of!(ImportDeclaration, import_kind) == 128usize);
+    assert!(offset_of!(ImportDeclaration, source) == 24usize);
+    assert!(offset_of!(ImportDeclaration, with_clause) == 40usize);
+    assert!(offset_of!(ImportDeclaration, import_kind) == 80usize);
     assert!(size_of::<ImportDeclarationSpecifier>() == 8usize);
     assert!(align_of::<ImportDeclarationSpecifier>() == 4usize);
     assert!(size_of::<ImportSpecifier>() == 60usize);
     assert!(align_of::<ImportSpecifier>() == 4usize);
     assert!(offset_of!(ImportSpecifier, span) == 0usize);
     assert!(offset_of!(ImportSpecifier, imported) == 8usize);
-    assert!(offset_of!(ImportSpecifier, local) == 48usize);
-    assert!(offset_of!(ImportSpecifier, import_kind) == 80usize);
+    assert!(offset_of!(ImportSpecifier, local) == 36usize);
+    assert!(offset_of!(ImportSpecifier, import_kind) == 56usize);
     assert!(size_of::<ImportDefaultSpecifier>() == 28usize);
     assert!(align_of::<ImportDefaultSpecifier>() == 4usize);
     assert!(offset_of!(ImportDefaultSpecifier, span) == 0usize);
@@ -1729,40 +1729,40 @@ const _: () = {
     assert!(align_of::<WithClause>() == 4usize);
     assert!(offset_of!(WithClause, span) == 0usize);
     assert!(offset_of!(WithClause, attributes_keyword) == 8usize);
-    assert!(offset_of!(WithClause, with_entries) == 32usize);
+    assert!(offset_of!(WithClause, with_entries) == 24usize);
     assert!(size_of::<ImportAttribute>() == 44usize);
     assert!(align_of::<ImportAttribute>() == 4usize);
     assert!(offset_of!(ImportAttribute, span) == 0usize);
     assert!(offset_of!(ImportAttribute, key) == 8usize);
-    assert!(offset_of!(ImportAttribute, value) == 40usize);
+    assert!(offset_of!(ImportAttribute, value) == 28usize);
     assert!(size_of::<ImportAttributeKey>() == 20usize);
     assert!(align_of::<ImportAttributeKey>() == 4usize);
     assert!(size_of::<ExportNamedDeclaration>() == 92usize);
     assert!(align_of::<ExportNamedDeclaration>() == 4usize);
     assert!(offset_of!(ExportNamedDeclaration, span) == 0usize);
     assert!(offset_of!(ExportNamedDeclaration, declaration) == 8usize);
-    assert!(offset_of!(ExportNamedDeclaration, specifiers) == 24usize);
-    assert!(offset_of!(ExportNamedDeclaration, source) == 56usize);
-    assert!(offset_of!(ExportNamedDeclaration, export_kind) == 80usize);
-    assert!(offset_of!(ExportNamedDeclaration, with_clause) == 88usize);
+    assert!(offset_of!(ExportNamedDeclaration, specifiers) == 16usize);
+    assert!(offset_of!(ExportNamedDeclaration, source) == 32usize);
+    assert!(offset_of!(ExportNamedDeclaration, export_kind) == 48usize);
+    assert!(offset_of!(ExportNamedDeclaration, with_clause) == 52usize);
     assert!(size_of::<ExportDefaultDeclaration>() == 44usize);
     assert!(align_of::<ExportDefaultDeclaration>() == 4usize);
     assert!(offset_of!(ExportDefaultDeclaration, span) == 0usize);
     assert!(offset_of!(ExportDefaultDeclaration, declaration) == 8usize);
-    assert!(offset_of!(ExportDefaultDeclaration, exported) == 24usize);
+    assert!(offset_of!(ExportDefaultDeclaration, exported) == 16usize);
     assert!(size_of::<ExportAllDeclaration>() == 96usize);
     assert!(align_of::<ExportAllDeclaration>() == 4usize);
     assert!(offset_of!(ExportAllDeclaration, span) == 0usize);
     assert!(offset_of!(ExportAllDeclaration, exported) == 8usize);
-    assert!(offset_of!(ExportAllDeclaration, source) == 48usize);
-    assert!(offset_of!(ExportAllDeclaration, with_clause) == 72usize);
-    assert!(offset_of!(ExportAllDeclaration, export_kind) == 136usize);
+    assert!(offset_of!(ExportAllDeclaration, source) == 36usize);
+    assert!(offset_of!(ExportAllDeclaration, with_clause) == 52usize);
+    assert!(offset_of!(ExportAllDeclaration, export_kind) == 92usize);
     assert!(size_of::<ExportSpecifier>() == 68usize);
     assert!(align_of::<ExportSpecifier>() == 4usize);
     assert!(offset_of!(ExportSpecifier, span) == 0usize);
     assert!(offset_of!(ExportSpecifier, local) == 8usize);
-    assert!(offset_of!(ExportSpecifier, exported) == 48usize);
-    assert!(offset_of!(ExportSpecifier, export_kind) == 88usize);
+    assert!(offset_of!(ExportSpecifier, exported) == 36usize);
+    assert!(offset_of!(ExportSpecifier, export_kind) == 64usize);
     assert!(size_of::<ExportDefaultDeclarationKind>() == 8usize);
     assert!(align_of::<ExportDefaultDeclarationKind>() == 4usize);
     assert!(size_of::<ModuleExportName>() == 28usize);
@@ -1771,20 +1771,20 @@ const _: () = {
     assert!(align_of::<TSThisParameter>() == 4usize);
     assert!(offset_of!(TSThisParameter, span) == 0usize);
     assert!(offset_of!(TSThisParameter, this) == 8usize);
-    assert!(offset_of!(TSThisParameter, type_annotation) == 32usize);
+    assert!(offset_of!(TSThisParameter, type_annotation) == 24usize);
     assert!(size_of::<TSEnumDeclaration>() == 52usize);
     assert!(align_of::<TSEnumDeclaration>() == 4usize);
     assert!(offset_of!(TSEnumDeclaration, span) == 0usize);
     assert!(offset_of!(TSEnumDeclaration, id) == 8usize);
-    assert!(offset_of!(TSEnumDeclaration, members) == 40usize);
-    assert!(offset_of!(TSEnumDeclaration, r#const) == 72usize);
-    assert!(offset_of!(TSEnumDeclaration, declare) == 73usize);
-    assert!(offset_of!(TSEnumDeclaration, scope_id) == 76usize);
+    assert!(offset_of!(TSEnumDeclaration, members) == 28usize);
+    assert!(offset_of!(TSEnumDeclaration, r#const) == 44usize);
+    assert!(offset_of!(TSEnumDeclaration, declare) == 45usize);
+    assert!(offset_of!(TSEnumDeclaration, scope_id) == 48usize);
     assert!(size_of::<TSEnumMember>() == 24usize);
     assert!(align_of::<TSEnumMember>() == 4usize);
     assert!(offset_of!(TSEnumMember, span) == 0usize);
     assert!(offset_of!(TSEnumMember, id) == 8usize);
-    assert!(offset_of!(TSEnumMember, initializer) == 24usize);
+    assert!(offset_of!(TSEnumMember, initializer) == 16usize);
     assert!(size_of::<TSEnumMemberName>() == 8usize);
     assert!(align_of::<TSEnumMemberName>() == 4usize);
     assert!(size_of::<TSTypeAnnotation>() == 16usize);
@@ -1803,10 +1803,10 @@ const _: () = {
     assert!(align_of::<TSConditionalType>() == 4usize);
     assert!(offset_of!(TSConditionalType, span) == 0usize);
     assert!(offset_of!(TSConditionalType, check_type) == 8usize);
-    assert!(offset_of!(TSConditionalType, extends_type) == 24usize);
-    assert!(offset_of!(TSConditionalType, true_type) == 40usize);
-    assert!(offset_of!(TSConditionalType, false_type) == 56usize);
-    assert!(offset_of!(TSConditionalType, scope_id) == 72usize);
+    assert!(offset_of!(TSConditionalType, extends_type) == 16usize);
+    assert!(offset_of!(TSConditionalType, true_type) == 24usize);
+    assert!(offset_of!(TSConditionalType, false_type) == 32usize);
+    assert!(offset_of!(TSConditionalType, scope_id) == 40usize);
     assert!(size_of::<TSUnionType>() == 24usize);
     assert!(align_of::<TSUnionType>() == 4usize);
     assert!(offset_of!(TSUnionType, span) == 0usize);
@@ -1823,7 +1823,7 @@ const _: () = {
     assert!(align_of::<TSTypeOperator>() == 4usize);
     assert!(offset_of!(TSTypeOperator, span) == 0usize);
     assert!(offset_of!(TSTypeOperator, operator) == 8usize);
-    assert!(offset_of!(TSTypeOperator, type_annotation) == 16usize);
+    assert!(offset_of!(TSTypeOperator, type_annotation) == 12usize);
     assert!(size_of::<TSTypeOperatorOperator>() == 1usize);
     assert!(align_of::<TSTypeOperatorOperator>() == 1usize);
     assert!(size_of::<TSArrayType>() == 16usize);
@@ -1834,7 +1834,7 @@ const _: () = {
     assert!(align_of::<TSIndexedAccessType>() == 4usize);
     assert!(offset_of!(TSIndexedAccessType, span) == 0usize);
     assert!(offset_of!(TSIndexedAccessType, object_type) == 8usize);
-    assert!(offset_of!(TSIndexedAccessType, index_type) == 24usize);
+    assert!(offset_of!(TSIndexedAccessType, index_type) == 16usize);
     assert!(size_of::<TSTupleType>() == 24usize);
     assert!(align_of::<TSTupleType>() == 4usize);
     assert!(offset_of!(TSTupleType, span) == 0usize);
@@ -1843,8 +1843,8 @@ const _: () = {
     assert!(align_of::<TSNamedTupleMember>() == 4usize);
     assert!(offset_of!(TSNamedTupleMember, span) == 0usize);
     assert!(offset_of!(TSNamedTupleMember, element_type) == 8usize);
-    assert!(offset_of!(TSNamedTupleMember, label) == 24usize);
-    assert!(offset_of!(TSNamedTupleMember, optional) == 48usize);
+    assert!(offset_of!(TSNamedTupleMember, label) == 16usize);
+    assert!(offset_of!(TSNamedTupleMember, optional) == 32usize);
     assert!(size_of::<TSOptionalType>() == 16usize);
     assert!(align_of::<TSOptionalType>() == 4usize);
     assert!(offset_of!(TSOptionalType, span) == 0usize);
@@ -1901,14 +1901,14 @@ const _: () = {
     assert!(align_of::<TSTypeReference>() == 4usize);
     assert!(offset_of!(TSTypeReference, span) == 0usize);
     assert!(offset_of!(TSTypeReference, type_name) == 8usize);
-    assert!(offset_of!(TSTypeReference, type_parameters) == 24usize);
+    assert!(offset_of!(TSTypeReference, type_parameters) == 16usize);
     assert!(size_of::<TSTypeName>() == 8usize);
     assert!(align_of::<TSTypeName>() == 4usize);
     assert!(size_of::<TSQualifiedName>() == 32usize);
     assert!(align_of::<TSQualifiedName>() == 4usize);
     assert!(offset_of!(TSQualifiedName, span) == 0usize);
     assert!(offset_of!(TSQualifiedName, left) == 8usize);
-    assert!(offset_of!(TSQualifiedName, right) == 24usize);
+    assert!(offset_of!(TSQualifiedName, right) == 16usize);
     assert!(size_of::<TSTypeParameterInstantiation>() == 24usize);
     assert!(align_of::<TSTypeParameterInstantiation>() == 4usize);
     assert!(offset_of!(TSTypeParameterInstantiation, span) == 0usize);
@@ -1917,11 +1917,11 @@ const _: () = {
     assert!(align_of::<TSTypeParameter>() == 4usize);
     assert!(offset_of!(TSTypeParameter, span) == 0usize);
     assert!(offset_of!(TSTypeParameter, name) == 8usize);
-    assert!(offset_of!(TSTypeParameter, constraint) == 40usize);
-    assert!(offset_of!(TSTypeParameter, default) == 56usize);
-    assert!(offset_of!(TSTypeParameter, r#in) == 72usize);
-    assert!(offset_of!(TSTypeParameter, out) == 73usize);
-    assert!(offset_of!(TSTypeParameter, r#const) == 74usize);
+    assert!(offset_of!(TSTypeParameter, constraint) == 28usize);
+    assert!(offset_of!(TSTypeParameter, default) == 36usize);
+    assert!(offset_of!(TSTypeParameter, r#in) == 44usize);
+    assert!(offset_of!(TSTypeParameter, out) == 45usize);
+    assert!(offset_of!(TSTypeParameter, r#const) == 46usize);
     assert!(size_of::<TSTypeParameterDeclaration>() == 24usize);
     assert!(align_of::<TSTypeParameterDeclaration>() == 4usize);
     assert!(offset_of!(TSTypeParameterDeclaration, span) == 0usize);
@@ -1930,26 +1930,26 @@ const _: () = {
     assert!(align_of::<TSTypeAliasDeclaration>() == 4usize);
     assert!(offset_of!(TSTypeAliasDeclaration, span) == 0usize);
     assert!(offset_of!(TSTypeAliasDeclaration, id) == 8usize);
-    assert!(offset_of!(TSTypeAliasDeclaration, type_parameters) == 40usize);
-    assert!(offset_of!(TSTypeAliasDeclaration, type_annotation) == 48usize);
-    assert!(offset_of!(TSTypeAliasDeclaration, declare) == 64usize);
-    assert!(offset_of!(TSTypeAliasDeclaration, scope_id) == 68usize);
+    assert!(offset_of!(TSTypeAliasDeclaration, type_parameters) == 28usize);
+    assert!(offset_of!(TSTypeAliasDeclaration, type_annotation) == 32usize);
+    assert!(offset_of!(TSTypeAliasDeclaration, declare) == 40usize);
+    assert!(offset_of!(TSTypeAliasDeclaration, scope_id) == 44usize);
     assert!(size_of::<TSAccessibility>() == 1usize);
     assert!(align_of::<TSAccessibility>() == 1usize);
     assert!(size_of::<TSClassImplements>() == 20usize);
     assert!(align_of::<TSClassImplements>() == 4usize);
     assert!(offset_of!(TSClassImplements, span) == 0usize);
     assert!(offset_of!(TSClassImplements, expression) == 8usize);
-    assert!(offset_of!(TSClassImplements, type_parameters) == 24usize);
+    assert!(offset_of!(TSClassImplements, type_parameters) == 16usize);
     assert!(size_of::<TSInterfaceDeclaration>() == 60usize);
     assert!(align_of::<TSInterfaceDeclaration>() == 4usize);
     assert!(offset_of!(TSInterfaceDeclaration, span) == 0usize);
     assert!(offset_of!(TSInterfaceDeclaration, id) == 8usize);
-    assert!(offset_of!(TSInterfaceDeclaration, extends) == 40usize);
-    assert!(offset_of!(TSInterfaceDeclaration, type_parameters) == 72usize);
-    assert!(offset_of!(TSInterfaceDeclaration, body) == 80usize);
-    assert!(offset_of!(TSInterfaceDeclaration, declare) == 88usize);
-    assert!(offset_of!(TSInterfaceDeclaration, scope_id) == 92usize);
+    assert!(offset_of!(TSInterfaceDeclaration, extends) == 28usize);
+    assert!(offset_of!(TSInterfaceDeclaration, type_parameters) == 44usize);
+    assert!(offset_of!(TSInterfaceDeclaration, body) == 48usize);
+    assert!(offset_of!(TSInterfaceDeclaration, declare) == 52usize);
+    assert!(offset_of!(TSInterfaceDeclaration, scope_id) == 56usize);
     assert!(size_of::<TSInterfaceBody>() == 24usize);
     assert!(align_of::<TSInterfaceBody>() == 4usize);
     assert!(offset_of!(TSInterfaceBody, span) == 0usize);
@@ -1960,70 +1960,70 @@ const _: () = {
     assert!(offset_of!(TSPropertySignature, computed) == 8usize);
     assert!(offset_of!(TSPropertySignature, optional) == 9usize);
     assert!(offset_of!(TSPropertySignature, readonly) == 10usize);
-    assert!(offset_of!(TSPropertySignature, key) == 16usize);
-    assert!(offset_of!(TSPropertySignature, type_annotation) == 32usize);
+    assert!(offset_of!(TSPropertySignature, key) == 12usize);
+    assert!(offset_of!(TSPropertySignature, type_annotation) == 20usize);
     assert!(size_of::<TSSignature>() == 8usize);
     assert!(align_of::<TSSignature>() == 4usize);
     assert!(size_of::<TSIndexSignature>() == 32usize);
     assert!(align_of::<TSIndexSignature>() == 4usize);
     assert!(offset_of!(TSIndexSignature, span) == 0usize);
     assert!(offset_of!(TSIndexSignature, parameters) == 8usize);
-    assert!(offset_of!(TSIndexSignature, type_annotation) == 40usize);
-    assert!(offset_of!(TSIndexSignature, readonly) == 48usize);
+    assert!(offset_of!(TSIndexSignature, type_annotation) == 24usize);
+    assert!(offset_of!(TSIndexSignature, readonly) == 28usize);
     assert!(size_of::<TSCallSignatureDeclaration>() == 48usize);
     assert!(align_of::<TSCallSignatureDeclaration>() == 4usize);
     assert!(offset_of!(TSCallSignatureDeclaration, span) == 0usize);
     assert!(offset_of!(TSCallSignatureDeclaration, this_param) == 8usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, params) == 48usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, return_type) == 56usize);
-    assert!(offset_of!(TSCallSignatureDeclaration, type_parameters) == 64usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, params) == 36usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, return_type) == 40usize);
+    assert!(offset_of!(TSCallSignatureDeclaration, type_parameters) == 44usize);
     assert!(size_of::<TSMethodSignatureKind>() == 1usize);
     assert!(align_of::<TSMethodSignatureKind>() == 1usize);
     assert!(size_of::<TSMethodSignature>() == 64usize);
     assert!(align_of::<TSMethodSignature>() == 4usize);
     assert!(offset_of!(TSMethodSignature, span) == 0usize);
     assert!(offset_of!(TSMethodSignature, key) == 8usize);
-    assert!(offset_of!(TSMethodSignature, computed) == 24usize);
-    assert!(offset_of!(TSMethodSignature, optional) == 25usize);
-    assert!(offset_of!(TSMethodSignature, kind) == 26usize);
-    assert!(offset_of!(TSMethodSignature, this_param) == 32usize);
-    assert!(offset_of!(TSMethodSignature, params) == 72usize);
-    assert!(offset_of!(TSMethodSignature, return_type) == 80usize);
-    assert!(offset_of!(TSMethodSignature, type_parameters) == 88usize);
-    assert!(offset_of!(TSMethodSignature, scope_id) == 96usize);
+    assert!(offset_of!(TSMethodSignature, computed) == 16usize);
+    assert!(offset_of!(TSMethodSignature, optional) == 17usize);
+    assert!(offset_of!(TSMethodSignature, kind) == 18usize);
+    assert!(offset_of!(TSMethodSignature, this_param) == 20usize);
+    assert!(offset_of!(TSMethodSignature, params) == 48usize);
+    assert!(offset_of!(TSMethodSignature, return_type) == 52usize);
+    assert!(offset_of!(TSMethodSignature, type_parameters) == 56usize);
+    assert!(offset_of!(TSMethodSignature, scope_id) == 60usize);
     assert!(size_of::<TSConstructSignatureDeclaration>() == 24usize);
     assert!(align_of::<TSConstructSignatureDeclaration>() == 4usize);
     assert!(offset_of!(TSConstructSignatureDeclaration, span) == 0usize);
     assert!(offset_of!(TSConstructSignatureDeclaration, params) == 8usize);
-    assert!(offset_of!(TSConstructSignatureDeclaration, return_type) == 16usize);
-    assert!(offset_of!(TSConstructSignatureDeclaration, type_parameters) == 24usize);
-    assert!(offset_of!(TSConstructSignatureDeclaration, scope_id) == 32usize);
+    assert!(offset_of!(TSConstructSignatureDeclaration, return_type) == 12usize);
+    assert!(offset_of!(TSConstructSignatureDeclaration, type_parameters) == 16usize);
+    assert!(offset_of!(TSConstructSignatureDeclaration, scope_id) == 20usize);
     assert!(size_of::<TSIndexSignatureName>() == 20usize);
     assert!(align_of::<TSIndexSignatureName>() == 4usize);
     assert!(offset_of!(TSIndexSignatureName, span) == 0usize);
     assert!(offset_of!(TSIndexSignatureName, name) == 8usize);
-    assert!(offset_of!(TSIndexSignatureName, type_annotation) == 24usize);
+    assert!(offset_of!(TSIndexSignatureName, type_annotation) == 16usize);
     assert!(size_of::<TSInterfaceHeritage>() == 20usize);
     assert!(align_of::<TSInterfaceHeritage>() == 4usize);
     assert!(offset_of!(TSInterfaceHeritage, span) == 0usize);
     assert!(offset_of!(TSInterfaceHeritage, expression) == 8usize);
-    assert!(offset_of!(TSInterfaceHeritage, type_parameters) == 24usize);
+    assert!(offset_of!(TSInterfaceHeritage, type_parameters) == 16usize);
     assert!(size_of::<TSTypePredicate>() == 28usize);
     assert!(align_of::<TSTypePredicate>() == 4usize);
     assert!(offset_of!(TSTypePredicate, span) == 0usize);
     assert!(offset_of!(TSTypePredicate, parameter_name) == 8usize);
-    assert!(offset_of!(TSTypePredicate, asserts) == 24usize);
-    assert!(offset_of!(TSTypePredicate, type_annotation) == 32usize);
+    assert!(offset_of!(TSTypePredicate, asserts) == 20usize);
+    assert!(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!(offset_of!(TSModuleDeclaration, span) == 0usize);
     assert!(offset_of!(TSModuleDeclaration, id) == 8usize);
-    assert!(offset_of!(TSModuleDeclaration, body) == 40usize);
-    assert!(offset_of!(TSModuleDeclaration, kind) == 56usize);
-    assert!(offset_of!(TSModuleDeclaration, declare) == 57usize);
-    assert!(offset_of!(TSModuleDeclaration, scope_id) == 60usize);
+    assert!(offset_of!(TSModuleDeclaration, body) == 28usize);
+    assert!(offset_of!(TSModuleDeclaration, kind) == 36usize);
+    assert!(offset_of!(TSModuleDeclaration, declare) == 37usize);
+    assert!(offset_of!(TSModuleDeclaration, scope_id) == 40usize);
     assert!(size_of::<TSModuleDeclarationKind>() == 1usize);
     assert!(align_of::<TSModuleDeclarationKind>() == 1usize);
     assert!(size_of::<TSModuleDeclarationName>() == 20usize);
@@ -2034,7 +2034,7 @@ const _: () = {
     assert!(align_of::<TSModuleBlock>() == 4usize);
     assert!(offset_of!(TSModuleBlock, span) == 0usize);
     assert!(offset_of!(TSModuleBlock, directives) == 8usize);
-    assert!(offset_of!(TSModuleBlock, body) == 40usize);
+    assert!(offset_of!(TSModuleBlock, body) == 24usize);
     assert!(size_of::<TSTypeLiteral>() == 24usize);
     assert!(align_of::<TSTypeLiteral>() == 4usize);
     assert!(offset_of!(TSTypeLiteral, span) == 0usize);
@@ -2047,17 +2047,17 @@ const _: () = {
     assert!(align_of::<TSTypeQuery>() == 4usize);
     assert!(offset_of!(TSTypeQuery, span) == 0usize);
     assert!(offset_of!(TSTypeQuery, expr_name) == 8usize);
-    assert!(offset_of!(TSTypeQuery, type_parameters) == 24usize);
+    assert!(offset_of!(TSTypeQuery, type_parameters) == 16usize);
     assert!(size_of::<TSTypeQueryExprName>() == 8usize);
     assert!(align_of::<TSTypeQueryExprName>() == 4usize);
     assert!(size_of::<TSImportType>() == 56usize);
     assert!(align_of::<TSImportType>() == 4usize);
     assert!(offset_of!(TSImportType, span) == 0usize);
     assert!(offset_of!(TSImportType, is_type_of) == 8usize);
-    assert!(offset_of!(TSImportType, parameter) == 16usize);
-    assert!(offset_of!(TSImportType, qualifier) == 32usize);
-    assert!(offset_of!(TSImportType, attributes) == 48usize);
-    assert!(offset_of!(TSImportType, type_parameters) == 88usize);
+    assert!(offset_of!(TSImportType, parameter) == 12usize);
+    assert!(offset_of!(TSImportType, qualifier) == 20usize);
+    assert!(offset_of!(TSImportType, attributes) == 28usize);
+    assert!(offset_of!(TSImportType, type_parameters) == 52usize);
     assert!(size_of::<TSImportAttributes>() == 24usize);
     assert!(align_of::<TSImportAttributes>() == 4usize);
     assert!(offset_of!(TSImportAttributes, span) == 0usize);
@@ -2066,60 +2066,60 @@ const _: () = {
     assert!(align_of::<TSImportAttribute>() == 4usize);
     assert!(offset_of!(TSImportAttribute, span) == 0usize);
     assert!(offset_of!(TSImportAttribute, name) == 8usize);
-    assert!(offset_of!(TSImportAttribute, value) == 40usize);
+    assert!(offset_of!(TSImportAttribute, value) == 28usize);
     assert!(size_of::<TSImportAttributeName>() == 20usize);
     assert!(align_of::<TSImportAttributeName>() == 4usize);
     assert!(size_of::<TSFunctionType>() == 48usize);
     assert!(align_of::<TSFunctionType>() == 4usize);
     assert!(offset_of!(TSFunctionType, span) == 0usize);
     assert!(offset_of!(TSFunctionType, this_param) == 8usize);
-    assert!(offset_of!(TSFunctionType, params) == 48usize);
-    assert!(offset_of!(TSFunctionType, return_type) == 56usize);
-    assert!(offset_of!(TSFunctionType, type_parameters) == 64usize);
+    assert!(offset_of!(TSFunctionType, params) == 36usize);
+    assert!(offset_of!(TSFunctionType, return_type) == 40usize);
+    assert!(offset_of!(TSFunctionType, type_parameters) == 44usize);
     assert!(size_of::<TSConstructorType>() == 24usize);
     assert!(align_of::<TSConstructorType>() == 4usize);
     assert!(offset_of!(TSConstructorType, span) == 0usize);
     assert!(offset_of!(TSConstructorType, r#abstract) == 8usize);
-    assert!(offset_of!(TSConstructorType, params) == 16usize);
-    assert!(offset_of!(TSConstructorType, return_type) == 24usize);
-    assert!(offset_of!(TSConstructorType, type_parameters) == 32usize);
+    assert!(offset_of!(TSConstructorType, params) == 12usize);
+    assert!(offset_of!(TSConstructorType, return_type) == 16usize);
+    assert!(offset_of!(TSConstructorType, type_parameters) == 20usize);
     assert!(size_of::<TSMappedType>() == 36usize);
     assert!(align_of::<TSMappedType>() == 4usize);
     assert!(offset_of!(TSMappedType, span) == 0usize);
     assert!(offset_of!(TSMappedType, type_parameter) == 8usize);
-    assert!(offset_of!(TSMappedType, name_type) == 16usize);
-    assert!(offset_of!(TSMappedType, type_annotation) == 32usize);
-    assert!(offset_of!(TSMappedType, optional) == 48usize);
-    assert!(offset_of!(TSMappedType, readonly) == 49usize);
-    assert!(offset_of!(TSMappedType, scope_id) == 52usize);
+    assert!(offset_of!(TSMappedType, name_type) == 12usize);
+    assert!(offset_of!(TSMappedType, type_annotation) == 20usize);
+    assert!(offset_of!(TSMappedType, optional) == 28usize);
+    assert!(offset_of!(TSMappedType, readonly) == 29usize);
+    assert!(offset_of!(TSMappedType, scope_id) == 32usize);
     assert!(size_of::<TSMappedTypeModifierOperator>() == 1usize);
     assert!(align_of::<TSMappedTypeModifierOperator>() == 1usize);
     assert!(size_of::<TSTemplateLiteralType>() == 40usize);
     assert!(align_of::<TSTemplateLiteralType>() == 4usize);
     assert!(offset_of!(TSTemplateLiteralType, span) == 0usize);
     assert!(offset_of!(TSTemplateLiteralType, quasis) == 8usize);
-    assert!(offset_of!(TSTemplateLiteralType, types) == 40usize);
+    assert!(offset_of!(TSTemplateLiteralType, types) == 24usize);
     assert!(size_of::<TSAsExpression>() == 24usize);
     assert!(align_of::<TSAsExpression>() == 4usize);
     assert!(offset_of!(TSAsExpression, span) == 0usize);
     assert!(offset_of!(TSAsExpression, expression) == 8usize);
-    assert!(offset_of!(TSAsExpression, type_annotation) == 24usize);
+    assert!(offset_of!(TSAsExpression, type_annotation) == 16usize);
     assert!(size_of::<TSSatisfiesExpression>() == 24usize);
     assert!(align_of::<TSSatisfiesExpression>() == 4usize);
     assert!(offset_of!(TSSatisfiesExpression, span) == 0usize);
     assert!(offset_of!(TSSatisfiesExpression, expression) == 8usize);
-    assert!(offset_of!(TSSatisfiesExpression, type_annotation) == 24usize);
+    assert!(offset_of!(TSSatisfiesExpression, type_annotation) == 16usize);
     assert!(size_of::<TSTypeAssertion>() == 24usize);
     assert!(align_of::<TSTypeAssertion>() == 4usize);
     assert!(offset_of!(TSTypeAssertion, span) == 0usize);
     assert!(offset_of!(TSTypeAssertion, expression) == 8usize);
-    assert!(offset_of!(TSTypeAssertion, type_annotation) == 24usize);
+    assert!(offset_of!(TSTypeAssertion, type_annotation) == 16usize);
     assert!(size_of::<TSImportEqualsDeclaration>() == 40usize);
     assert!(align_of::<TSImportEqualsDeclaration>() == 4usize);
     assert!(offset_of!(TSImportEqualsDeclaration, span) == 0usize);
     assert!(offset_of!(TSImportEqualsDeclaration, id) == 8usize);
-    assert!(offset_of!(TSImportEqualsDeclaration, module_reference) == 40usize);
-    assert!(offset_of!(TSImportEqualsDeclaration, import_kind) == 56usize);
+    assert!(offset_of!(TSImportEqualsDeclaration, module_reference) == 28usize);
+    assert!(offset_of!(TSImportEqualsDeclaration, import_kind) == 36usize);
     assert!(size_of::<TSModuleReference>() == 8usize);
     assert!(align_of::<TSModuleReference>() == 4usize);
     assert!(size_of::<TSExternalModuleReference>() == 24usize);
@@ -2146,19 +2146,19 @@ const _: () = {
     assert!(align_of::<TSInstantiationExpression>() == 4usize);
     assert!(offset_of!(TSInstantiationExpression, span) == 0usize);
     assert!(offset_of!(TSInstantiationExpression, expression) == 8usize);
-    assert!(offset_of!(TSInstantiationExpression, type_parameters) == 24usize);
+    assert!(offset_of!(TSInstantiationExpression, type_parameters) == 16usize);
     assert!(size_of::<ImportOrExportKind>() == 1usize);
     assert!(align_of::<ImportOrExportKind>() == 1usize);
     assert!(size_of::<JSDocNullableType>() == 20usize);
     assert!(align_of::<JSDocNullableType>() == 4usize);
     assert!(offset_of!(JSDocNullableType, span) == 0usize);
     assert!(offset_of!(JSDocNullableType, type_annotation) == 8usize);
-    assert!(offset_of!(JSDocNullableType, postfix) == 24usize);
+    assert!(offset_of!(JSDocNullableType, postfix) == 16usize);
     assert!(size_of::<JSDocNonNullableType>() == 20usize);
     assert!(align_of::<JSDocNonNullableType>() == 4usize);
     assert!(offset_of!(JSDocNonNullableType, span) == 0usize);
     assert!(offset_of!(JSDocNonNullableType, type_annotation) == 8usize);
-    assert!(offset_of!(JSDocNonNullableType, postfix) == 24usize);
+    assert!(offset_of!(JSDocNonNullableType, postfix) == 16usize);
     assert!(size_of::<JSDocUnknownType>() == 8usize);
     assert!(align_of::<JSDocUnknownType>() == 4usize);
     assert!(offset_of!(JSDocUnknownType, span) == 0usize);
@@ -2166,15 +2166,15 @@ const _: () = {
     assert!(align_of::<JSXElement>() == 4usize);
     assert!(offset_of!(JSXElement, span) == 0usize);
     assert!(offset_of!(JSXElement, opening_element) == 8usize);
-    assert!(offset_of!(JSXElement, closing_element) == 16usize);
-    assert!(offset_of!(JSXElement, children) == 24usize);
+    assert!(offset_of!(JSXElement, closing_element) == 12usize);
+    assert!(offset_of!(JSXElement, children) == 16usize);
     assert!(size_of::<JSXOpeningElement>() == 40usize);
     assert!(align_of::<JSXOpeningElement>() == 4usize);
     assert!(offset_of!(JSXOpeningElement, span) == 0usize);
     assert!(offset_of!(JSXOpeningElement, self_closing) == 8usize);
-    assert!(offset_of!(JSXOpeningElement, name) == 16usize);
-    assert!(offset_of!(JSXOpeningElement, attributes) == 32usize);
-    assert!(offset_of!(JSXOpeningElement, type_parameters) == 64usize);
+    assert!(offset_of!(JSXOpeningElement, name) == 12usize);
+    assert!(offset_of!(JSXOpeningElement, attributes) == 20usize);
+    assert!(offset_of!(JSXOpeningElement, type_parameters) == 36usize);
     assert!(size_of::<JSXClosingElement>() == 16usize);
     assert!(align_of::<JSXClosingElement>() == 4usize);
     assert!(offset_of!(JSXClosingElement, span) == 0usize);
@@ -2197,12 +2197,12 @@ const _: () = {
     assert!(align_of::<JSXNamespacedName>() == 4usize);
     assert!(offset_of!(JSXNamespacedName, span) == 0usize);
     assert!(offset_of!(JSXNamespacedName, namespace) == 8usize);
-    assert!(offset_of!(JSXNamespacedName, property) == 32usize);
+    assert!(offset_of!(JSXNamespacedName, property) == 24usize);
     assert!(size_of::<JSXMemberExpression>() == 32usize);
     assert!(align_of::<JSXMemberExpression>() == 4usize);
     assert!(offset_of!(JSXMemberExpression, span) == 0usize);
     assert!(offset_of!(JSXMemberExpression, object) == 8usize);
-    assert!(offset_of!(JSXMemberExpression, property) == 24usize);
+    assert!(offset_of!(JSXMemberExpression, property) == 16usize);
     assert!(size_of::<JSXMemberExpressionObject>() == 8usize);
     assert!(align_of::<JSXMemberExpressionObject>() == 4usize);
     assert!(size_of::<JSXExpressionContainer>() == 20usize);
@@ -2220,7 +2220,7 @@ const _: () = {
     assert!(align_of::<JSXAttribute>() == 4usize);
     assert!(offset_of!(JSXAttribute, span) == 0usize);
     assert!(offset_of!(JSXAttribute, name) == 8usize);
-    assert!(offset_of!(JSXAttribute, value) == 24usize);
+    assert!(offset_of!(JSXAttribute, value) == 16usize);
     assert!(size_of::<JSXSpreadAttribute>() == 16usize);
     assert!(align_of::<JSXSpreadAttribute>() == 4usize);
     assert!(offset_of!(JSXSpreadAttribute, span) == 0usize);
diff --git a/tasks/ast_codegen/src/generators/assert_layouts.rs b/tasks/ast_codegen/src/generators/assert_layouts.rs
index 8fac98436e6975..c078075aed46ae 100644
--- a/tasks/ast_codegen/src/generators/assert_layouts.rs
+++ b/tasks/ast_codegen/src/generators/assert_layouts.rs
@@ -82,7 +82,7 @@ fn assert_type(ty: &Type, def: &TypeDef) -> (TokenStream, TokenStream) {
                 assert_size_align(ty, def.size_32, def.align_32),
                 ty,
                 &def.fields,
-                def.offsets_64.as_deref(),
+                def.offsets_32.as_deref(),
             ),
         ),
         TypeDef::Enum(def) => (