oxc-parser 0.94.0 → 0.96.0

package/generated/deserialize/js.js

@@ -2,16 +2,15 @@
 // To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer.rs`.
 
 let uint8, uint32, float64, sourceText, sourceIsAscii, sourceByteLen;
+
 const textDecoder = new TextDecoder('utf-8', { ignoreBOM: true }),
   decodeStr = textDecoder.decode.bind(textDecoder),
   { fromCodePoint } = String;
 
 export function deserialize(buffer, sourceText, sourceByteLen) {
-  return deserializeWith(buffer, sourceText, sourceByteLen, null, deserializeRawTransferData);
-}
-
-export function deserializeProgramOnly(buffer, sourceText, sourceByteLen, getLoc) {
-  return deserializeWith(buffer, sourceText, sourceByteLen, getLoc, deserializeProgram);
+  let data = deserializeWith(buffer, sourceText, sourceByteLen, null, deserializeRawTransferData);
+  resetBuffer();
+  return data;
 }
 
 function deserializeWith(buffer, sourceTextInput, sourceByteLenInput, getLocInput, deserialize) {
@@ -21,13 +20,12 @@ function deserializeWith(buffer, sourceTextInput, sourceByteLenInput, getLocInpu
   sourceText = sourceTextInput;
   sourceByteLen = sourceByteLenInput;
   sourceIsAscii = sourceText.length === sourceByteLen;
-  let data = deserialize(uint32[536870902]);
-  uint8 =
-    uint32 =
-    float64 =
-    sourceText =
-      void 0;
-  return data;
+  return deserialize(uint32[536870902]);
+}
+
+export function resetBuffer() {
+  // Clear buffer and source text string to allow them to be garbage collected
+  uint8 = uint32 = float64 = sourceText = void 0;
 }
 
 function deserializeProgram(pos) {
@@ -140,7 +138,8 @@ function deserializeExpression(pos) {
 }
 
 function deserializeIdentifierName(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     type: 'Identifier',
     name: deserializeStr(pos + 8),
@@ -150,7 +149,8 @@ function deserializeIdentifierName(pos) {
 }
 
 function deserializeIdentifierReference(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     type: 'Identifier',
     name: deserializeStr(pos + 8),
@@ -160,7 +160,8 @@ function deserializeIdentifierReference(pos) {
 }
 
 function deserializeBindingIdentifier(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     type: 'Identifier',
     name: deserializeStr(pos + 8),
@@ -170,7 +171,8 @@ function deserializeBindingIdentifier(pos) {
 }
 
 function deserializeLabelIdentifier(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     type: 'Identifier',
     name: deserializeStr(pos + 8),
@@ -180,23 +182,20 @@ function deserializeLabelIdentifier(pos) {
 }
 
 function deserializeThisExpression(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'ThisExpression',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeArrayExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ArrayExpression',
-      elements: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ArrayExpression',
+    elements: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.elements = deserializeVecArrayExpressionElement(pos + 8);
   return node;
 }
@@ -303,14 +302,12 @@ function deserializeElision(pos) {
 }
 
 function deserializeObjectExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ObjectExpression',
-      properties: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ObjectExpression',
+    properties: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.properties = deserializeVecObjectPropertyKind(pos + 8);
   return node;
 }
@@ -456,30 +453,26 @@ function deserializePropertyKind(pos) {
 }
 
 function deserializeTemplateLiteral(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TemplateLiteral',
-      quasis: null,
-      expressions: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TemplateLiteral',
+    quasis: null,
+    expressions: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.quasis = deserializeVecTemplateElement(pos + 8);
   node.expressions = deserializeVecExpression(pos + 32);
   return node;
 }
 
 function deserializeTaggedTemplateExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TaggedTemplateExpression',
-      tag: null,
-      quasi: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TaggedTemplateExpression',
+    tag: null,
+    quasi: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.tag = deserializeExpression(pos + 8);
   node.quasi = deserializeTemplateLiteral(pos + 32);
   return node;
@@ -490,7 +483,8 @@ function deserializeTemplateElement(pos) {
     start = deserializeU32(pos),
     end = deserializeU32(pos + 4),
     value = deserializeTemplateElementValue(pos + 8);
-  value.cooked !== null && deserializeBool(pos + 41) &&
+  value.cooked !== null &&
+    deserializeBool(pos + 41) &&
     (value.cooked = value.cooked.replace(/\uFFFD(.{4})/g, (_, hex) => String.fromCodePoint(parseInt(hex, 16))));
   return {
     type: 'TemplateElement',
@@ -579,44 +573,38 @@ function deserializeCallExpression(pos) {
 }
 
 function deserializeNewExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'NewExpression',
-      callee: null,
-      arguments: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'NewExpression',
+    callee: null,
+    arguments: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.callee = deserializeExpression(pos + 8);
   node.arguments = deserializeVecArgument(pos + 32);
   return node;
 }
 
 function deserializeMetaProperty(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'MetaProperty',
-      meta: null,
-      property: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'MetaProperty',
+    meta: null,
+    property: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.meta = deserializeIdentifierName(pos + 8);
   node.property = deserializeIdentifierName(pos + 32);
   return node;
 }
 
 function deserializeSpreadElement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'SpreadElement',
-      argument: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'SpreadElement',
+    argument: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.argument = deserializeExpression(pos + 8);
   return node;
 }
@@ -764,16 +752,14 @@ function deserializeBinaryExpression(pos) {
 }
 
 function deserializePrivateInExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'BinaryExpression',
-      left: null,
-      operator: null,
-      right: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'BinaryExpression',
+    left: null,
+    operator: null,
+    right: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.left = deserializePrivateIdentifier(pos + 8);
   node.operator = 'in';
   node.right = deserializeExpression(pos + 32);
@@ -797,16 +783,14 @@ function deserializeLogicalExpression(pos) {
 }
 
 function deserializeConditionalExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ConditionalExpression',
-      test: null,
-      consequent: null,
-      alternate: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ConditionalExpression',
+    test: null,
+    consequent: null,
+    alternate: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.test = deserializeExpression(pos + 8);
   node.consequent = deserializeExpression(pos + 24);
   node.alternate = deserializeExpression(pos + 40);
@@ -880,13 +864,11 @@ function deserializeSimpleAssignmentTarget(pos) {
 }
 
 function deserializeArrayAssignmentTarget(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'ArrayPattern',
       elements: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     elements = deserializeVecOptionAssignmentTargetMaybeDefault(pos + 8),
     rest = deserializeOptionBoxAssignmentTargetRest(pos + 32);
@@ -896,13 +878,11 @@ function deserializeArrayAssignmentTarget(pos) {
 }
 
 function deserializeObjectAssignmentTarget(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'ObjectPattern',
       properties: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     properties = deserializeVecAssignmentTargetProperty(pos + 8),
     rest = deserializeOptionBoxAssignmentTargetRest(pos + 32);
@@ -912,14 +892,12 @@ function deserializeObjectAssignmentTarget(pos) {
 }
 
 function deserializeAssignmentTargetRest(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'RestElement',
-      argument: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'RestElement',
+    argument: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.argument = deserializeAssignmentTarget(pos + 8);
   return node;
 }
@@ -954,15 +932,13 @@ function deserializeAssignmentTargetMaybeDefault(pos) {
 }
 
 function deserializeAssignmentTargetWithDefault(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'AssignmentPattern',
-      left: null,
-      right: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'AssignmentPattern',
+    left: null,
+    right: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.left = deserializeAssignmentTarget(pos + 8);
   node.right = deserializeExpression(pos + 24);
   return node;
@@ -996,13 +972,14 @@ function deserializeAssignmentTargetPropertyIdentifier(pos) {
     key = deserializeIdentifierReference(pos + 8),
     init = deserializeOptionExpression(pos + 40),
     value = { ...key };
-  init !== null && (value = {
-    type: 'AssignmentPattern',
-    left: value,
-    right: init,
-    start,
-    end,
-  });
+  init !== null &&
+    (value = {
+      type: 'AssignmentPattern',
+      left: value,
+      right: init,
+      start,
+      end,
+    });
   node.kind = 'init';
   node.key = key;
   node.value = value;
@@ -1035,49 +1012,42 @@ function deserializeAssignmentTargetPropertyProperty(pos) {
 }
 
 function deserializeSequenceExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'SequenceExpression',
-      expressions: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'SequenceExpression',
+    expressions: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expressions = deserializeVecExpression(pos + 8);
   return node;
 }
 
 function deserializeSuper(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'Super',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeAwaitExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'AwaitExpression',
-      argument: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'AwaitExpression',
+    argument: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.argument = deserializeExpression(pos + 8);
   return node;
 }
 
 function deserializeChainExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ChainExpression',
-      expression: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ChainExpression',
+    expression: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeChainElement(pos + 8);
   return node;
 }
@@ -1197,7 +1167,8 @@ function deserializeDirective(pos) {
 }
 
 function deserializeHashbang(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     type: 'Hashbang',
     value: deserializeStr(pos + 8),
@@ -1207,14 +1178,12 @@ function deserializeHashbang(pos) {
 }
 
 function deserializeBlockStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'BlockStatement',
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'BlockStatement',
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.body = deserializeVecStatement(pos + 8);
   return node;
 }
@@ -1274,53 +1243,46 @@ function deserializeVariableDeclarationKind(pos) {
 }
 
 function deserializeVariableDeclarator(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'VariableDeclarator',
-      id: null,
-      init: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'VariableDeclarator',
+    id: null,
+    init: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.id = deserializeBindingPattern(pos + 8);
   node.init = deserializeOptionExpression(pos + 40);
   return node;
 }
 
 function deserializeEmptyStatement(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'EmptyStatement',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeExpressionStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ExpressionStatement',
-      expression: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ExpressionStatement',
+    expression: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeExpression(pos + 8);
   return node;
 }
 
 function deserializeIfStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'IfStatement',
-      test: null,
-      consequent: null,
-      alternate: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'IfStatement',
+    test: null,
+    consequent: null,
+    alternate: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.test = deserializeExpression(pos + 8);
   node.consequent = deserializeStatement(pos + 24);
   node.alternate = deserializeOptionStatement(pos + 40);
@@ -1328,47 +1290,41 @@ function deserializeIfStatement(pos) {
 }
 
 function deserializeDoWhileStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'DoWhileStatement',
-      body: null,
-      test: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'DoWhileStatement',
+    body: null,
+    test: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.body = deserializeStatement(pos + 8);
   node.test = deserializeExpression(pos + 24);
   return node;
 }
 
 function deserializeWhileStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'WhileStatement',
-      test: null,
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'WhileStatement',
+    test: null,
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.test = deserializeExpression(pos + 8);
   node.body = deserializeStatement(pos + 24);
   return node;
 }
 
 function deserializeForStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ForStatement',
-      init: null,
-      test: null,
-      update: null,
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ForStatement',
+    init: null,
+    test: null,
+    update: null,
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.init = deserializeOptionForStatementInit(pos + 8);
   node.test = deserializeOptionExpression(pos + 24);
   node.update = deserializeOptionExpression(pos + 40);
@@ -1472,16 +1428,14 @@ function deserializeForStatementInit(pos) {
 }
 
 function deserializeForInStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ForInStatement',
-      left: null,
-      right: null,
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ForInStatement',
+    left: null,
+    right: null,
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.left = deserializeForStatementLeft(pos + 8);
   node.right = deserializeExpression(pos + 24);
   node.body = deserializeStatement(pos + 40);
@@ -1536,128 +1490,110 @@ function deserializeForOfStatement(pos) {
 }
 
 function deserializeContinueStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ContinueStatement',
-      label: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ContinueStatement',
+    label: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.label = deserializeOptionLabelIdentifier(pos + 8);
   return node;
 }
 
 function deserializeBreakStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'BreakStatement',
-      label: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'BreakStatement',
+    label: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.label = deserializeOptionLabelIdentifier(pos + 8);
   return node;
 }
 
 function deserializeReturnStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ReturnStatement',
-      argument: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ReturnStatement',
+    argument: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.argument = deserializeOptionExpression(pos + 8);
   return node;
 }
 
 function deserializeWithStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'WithStatement',
-      object: null,
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'WithStatement',
+    object: null,
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.object = deserializeExpression(pos + 8);
   node.body = deserializeStatement(pos + 24);
   return node;
 }
 
 function deserializeSwitchStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'SwitchStatement',
-      discriminant: null,
-      cases: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'SwitchStatement',
+    discriminant: null,
+    cases: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.discriminant = deserializeExpression(pos + 8);
   node.cases = deserializeVecSwitchCase(pos + 24);
   return node;
 }
 
 function deserializeSwitchCase(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'SwitchCase',
-      test: null,
-      consequent: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'SwitchCase',
+    test: null,
+    consequent: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.test = deserializeOptionExpression(pos + 8);
   node.consequent = deserializeVecStatement(pos + 24);
   return node;
 }
 
 function deserializeLabeledStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'LabeledStatement',
-      label: null,
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'LabeledStatement',
+    label: null,
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.label = deserializeLabelIdentifier(pos + 8);
   node.body = deserializeStatement(pos + 32);
   return node;
 }
 
 function deserializeThrowStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ThrowStatement',
-      argument: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ThrowStatement',
+    argument: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.argument = deserializeExpression(pos + 8);
   return node;
 }
 
 function deserializeTryStatement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TryStatement',
-      block: null,
-      handler: null,
-      finalizer: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TryStatement',
+    block: null,
+    handler: null,
+    finalizer: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.block = deserializeBoxBlockStatement(pos + 8);
   node.handler = deserializeOptionBoxCatchClause(pos + 16);
   node.finalizer = deserializeOptionBoxBlockStatement(pos + 24);
@@ -1665,15 +1601,13 @@ function deserializeTryStatement(pos) {
 }
 
 function deserializeCatchClause(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'CatchClause',
-      param: null,
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'CatchClause',
+    param: null,
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.param = deserializeOptionCatchParameter(pos + 8);
   node.body = deserializeBoxBlockStatement(pos + 48);
   return node;
@@ -1684,11 +1618,10 @@ function deserializeCatchParameter(pos) {
 }
 
 function deserializeDebuggerStatement(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'DebuggerStatement',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
@@ -1712,28 +1645,24 @@ function deserializeBindingPatternKind(pos) {
 }
 
 function deserializeAssignmentPattern(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'AssignmentPattern',
-      left: null,
-      right: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'AssignmentPattern',
+    left: null,
+    right: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.left = deserializeBindingPattern(pos + 8);
   node.right = deserializeExpression(pos + 40);
   return node;
 }
 
 function deserializeObjectPattern(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'ObjectPattern',
       properties: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     properties = deserializeVecBindingProperty(pos + 8),
     rest = deserializeOptionBoxBindingRestElement(pos + 32);
@@ -1764,13 +1693,11 @@ function deserializeBindingProperty(pos) {
 }
 
 function deserializeArrayPattern(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'ArrayPattern',
       elements: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     elements = deserializeVecOptionBindingPattern(pos + 8),
     rest = deserializeOptionBoxBindingRestElement(pos + 32);
@@ -1780,14 +1707,12 @@ function deserializeArrayPattern(pos) {
 }
 
 function deserializeBindingRestElement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'RestElement',
-      argument: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'RestElement',
+    argument: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.argument = deserializeBindingPattern(pos + 8);
   return node;
 }
@@ -1831,8 +1756,8 @@ function deserializeFunctionType(pos) {
 
 function deserializeFormalParameters(pos) {
   let params = deserializeVecFormalParameter(pos + 8);
-  if (uint32[pos + 32 >> 2] !== 0 && uint32[pos + 36 >> 2] !== 0) {
-    pos = uint32[pos + 32 >> 2];
+  if (uint32[(pos + 32) >> 2] !== 0 && uint32[(pos + 36) >> 2] !== 0) {
+    pos = uint32[(pos + 32) >> 2];
     let rest = {
       type: 'RestElement',
       argument: null,
@@ -1852,13 +1777,11 @@ function deserializeFormalParameter(pos) {
 }
 
 function deserializeFunctionBody(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'BlockStatement',
       body: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     body = deserializeVecDirective(pos + 8);
   body.push(...deserializeVecStatement(pos + 32));
@@ -1935,14 +1858,12 @@ function deserializeClassType(pos) {
 }
 
 function deserializeClassBody(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ClassBody',
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ClassBody',
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.body = deserializeVecClassElement(pos + 8);
   return node;
 }
@@ -2041,7 +1962,8 @@ function deserializeMethodDefinitionKind(pos) {
 }
 
 function deserializePrivateIdentifier(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     type: 'PrivateIdentifier',
     name: deserializeStr(pos + 8),
@@ -2051,14 +1973,12 @@ function deserializePrivateIdentifier(pos) {
 }
 
 function deserializeStaticBlock(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'StaticBlock',
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'StaticBlock',
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.body = deserializeVecStatement(pos + 8);
   return node;
 }
@@ -2155,42 +2075,36 @@ function deserializeImportDeclarationSpecifier(pos) {
 }
 
 function deserializeImportSpecifier(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ImportSpecifier',
-      imported: null,
-      local: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ImportSpecifier',
+    imported: null,
+    local: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.imported = deserializeModuleExportName(pos + 8);
   node.local = deserializeBindingIdentifier(pos + 64);
   return node;
 }
 
 function deserializeImportDefaultSpecifier(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ImportDefaultSpecifier',
-      local: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ImportDefaultSpecifier',
+    local: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.local = deserializeBindingIdentifier(pos + 8);
   return node;
 }
 
 function deserializeImportNamespaceSpecifier(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ImportNamespaceSpecifier',
-      local: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ImportNamespaceSpecifier',
+    local: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.local = deserializeBindingIdentifier(pos + 8);
   return node;
 }
@@ -2200,15 +2114,13 @@ function deserializeWithClause(pos) {
 }
 
 function deserializeImportAttribute(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ImportAttribute',
-      key: null,
-      value: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ImportAttribute',
+    key: null,
+    value: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.key = deserializeImportAttributeKey(pos + 8);
   node.value = deserializeStringLiteral(pos + 64);
   return node;
@@ -2226,16 +2138,14 @@ function deserializeImportAttributeKey(pos) {
 }
 
 function deserializeExportNamedDeclaration(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'ExportNamedDeclaration',
       declaration: null,
       specifiers: null,
       source: null,
       attributes: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     withClause = deserializeOptionBoxWithClause(pos + 96);
   node.declaration = deserializeOptionDeclaration(pos + 8);
@@ -2246,28 +2156,24 @@ function deserializeExportNamedDeclaration(pos) {
 }
 
 function deserializeExportDefaultDeclaration(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ExportDefaultDeclaration',
-      declaration: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'ExportDefaultDeclaration',
+    declaration: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.declaration = deserializeExportDefaultDeclarationKind(pos + 8);
   return node;
 }
 
 function deserializeExportAllDeclaration(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'ExportAllDeclaration',
       exported: null,
       source: null,
       attributes: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     withClause = deserializeOptionBoxWithClause(pos + 112);
   node.exported = deserializeOptionModuleExportName(pos + 8);
@@ -2277,17 +2183,15 @@ function deserializeExportAllDeclaration(pos) {
 }
 
 function deserializeExportSpecifier(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'ExportSpecifier',
-      local: null,
-      exported: null,
-      start,
-      end,
-    };
-  node.local = deserializeModuleExportName(pos + 8);
-  node.exported = deserializeModuleExportName(pos + 64);
+  let node = {
+    type: 'ExportSpecifier',
+    local: null,
+    exported: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
+  node.local = deserializeModuleExportName(pos + 8);
+  node.exported = deserializeModuleExportName(pos + 64);
   return node;
 }
 
@@ -2404,15 +2308,13 @@ function deserializeModuleExportName(pos) {
 }
 
 function deserializeV8IntrinsicExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'V8IntrinsicExpression',
-      name: null,
-      arguments: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'V8IntrinsicExpression',
+    name: null,
+    arguments: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.name = deserializeIdentifierName(pos + 8);
   node.arguments = deserializeVecArgument(pos + 32);
   return node;
@@ -2449,7 +2351,8 @@ function deserializeNullLiteral(pos) {
 }
 
 function deserializeNumericLiteral(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     type: 'Literal',
     value: deserializeF64(pos + 8),
@@ -2522,7 +2425,8 @@ function deserializeRegExp(pos) {
 }
 
 function deserializeRegExpFlags(pos) {
-  let flagBits = deserializeU8(pos), flags = '';
+  let flagBits = deserializeU8(pos),
+    flags = '';
   // Alphabetical order
   flagBits & 64 && (flags += 'd');
   flagBits & 1 && (flags += 'g');
@@ -2536,15 +2440,13 @@ function deserializeRegExpFlags(pos) {
 }
 
 function deserializeJSXElement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'JSXElement',
       openingElement: null,
       children: null,
       closingElement: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     closingElement = deserializeOptionBoxJSXClosingElement(pos + 40),
     openingElement = deserializeBoxJSXOpeningElement(pos + 8);
@@ -2556,16 +2458,14 @@ function deserializeJSXElement(pos) {
 }
 
 function deserializeJSXOpeningElement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXOpeningElement',
-      name: null,
-      attributes: null,
-      selfClosing: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXOpeningElement',
+    name: null,
+    attributes: null,
+    selfClosing: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.name = deserializeJSXElementName(pos + 8);
   node.attributes = deserializeVecJSXAttributeItem(pos + 32);
   node.selfClosing = false;
@@ -2573,29 +2473,25 @@ function deserializeJSXOpeningElement(pos) {
 }
 
 function deserializeJSXClosingElement(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXClosingElement',
-      name: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXClosingElement',
+    name: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.name = deserializeJSXElementName(pos + 8);
   return node;
 }
 
 function deserializeJSXFragment(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXFragment',
-      openingFragment: null,
-      children: null,
-      closingFragment: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXFragment',
+    openingFragment: null,
+    children: null,
+    closingFragment: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.openingFragment = deserializeJSXOpeningFragment(pos + 8);
   node.children = deserializeVecJSXChild(pos + 16);
   node.closingFragment = deserializeJSXClosingFragment(pos + 40);
@@ -2603,26 +2499,23 @@ function deserializeJSXFragment(pos) {
 }
 
 function deserializeJSXOpeningFragment(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXOpeningFragment',
-      attributes: null,
-      selfClosing: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXOpeningFragment',
+    attributes: null,
+    selfClosing: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.attributes = [];
   node.selfClosing = false;
   return node;
 }
 
 function deserializeJSXClosingFragment(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'JSXClosingFragment',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
@@ -2656,30 +2549,26 @@ function deserializeJSXElementName(pos) {
 }
 
 function deserializeJSXNamespacedName(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXNamespacedName',
-      namespace: null,
-      name: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXNamespacedName',
+    namespace: null,
+    name: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.namespace = deserializeJSXIdentifier(pos + 8);
   node.name = deserializeJSXIdentifier(pos + 32);
   return node;
 }
 
 function deserializeJSXMemberExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXMemberExpression',
-      object: null,
-      property: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXMemberExpression',
+    object: null,
+    property: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.object = deserializeJSXMemberExpressionObject(pos + 8);
   node.property = deserializeJSXIdentifier(pos + 24);
   return node;
@@ -2711,14 +2600,12 @@ function deserializeJSXMemberExpressionObject(pos) {
 }
 
 function deserializeJSXExpressionContainer(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXExpressionContainer',
-      expression: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXExpressionContainer',
+    expression: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeJSXExpression(pos + 8);
   return node;
 }
@@ -2819,11 +2706,10 @@ function deserializeJSXExpression(pos) {
 }
 
 function deserializeJSXEmptyExpression(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'JSXEmptyExpression',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
@@ -2839,29 +2725,25 @@ function deserializeJSXAttributeItem(pos) {
 }
 
 function deserializeJSXAttribute(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXAttribute',
-      name: null,
-      value: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXAttribute',
+    name: null,
+    value: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.name = deserializeJSXAttributeName(pos + 8);
   node.value = deserializeOptionJSXAttributeValue(pos + 24);
   return node;
 }
 
 function deserializeJSXSpreadAttribute(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXSpreadAttribute',
-      argument: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXSpreadAttribute',
+    argument: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.argument = deserializeExpression(pos + 8);
   return node;
 }
@@ -2893,7 +2775,8 @@ function deserializeJSXAttributeValue(pos) {
 }
 
 function deserializeJSXIdentifier(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     type: 'JSXIdentifier',
     name: deserializeStr(pos + 8),
@@ -2920,20 +2803,19 @@ function deserializeJSXChild(pos) {
 }
 
 function deserializeJSXSpreadChild(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'JSXSpreadChild',
-      expression: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'JSXSpreadChild',
+    expression: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeExpression(pos + 8);
   return node;
 }
 
 function deserializeJSXText(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     type: 'JSXText',
     value: deserializeStr(pos + 8),
@@ -2944,17 +2826,15 @@ function deserializeJSXText(pos) {
 }
 
 function deserializeTSThisParameter(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'Identifier',
-      decorators: null,
-      name: null,
-      optional: null,
-      typeAnnotation: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'Identifier',
+    decorators: null,
+    name: null,
+    optional: null,
+    typeAnnotation: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.decorators = [];
   node.name = 'this';
   node.optional = false;
@@ -2980,29 +2860,25 @@ function deserializeTSEnumDeclaration(pos) {
 }
 
 function deserializeTSEnumBody(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSEnumBody',
-      members: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSEnumBody',
+    members: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.members = deserializeVecTSEnumMember(pos + 8);
   return node;
 }
 
 function deserializeTSEnumMember(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSEnumMember',
-      id: null,
-      initializer: null,
-      computed: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSEnumMember',
+    id: null,
+    initializer: null,
+    computed: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.id = deserializeTSEnumMemberName(pos + 8);
   node.initializer = deserializeOptionExpression(pos + 24);
   node.computed = deserializeU8(pos + 8) > 1;
@@ -3025,27 +2901,23 @@ function deserializeTSEnumMemberName(pos) {
 }
 
 function deserializeTSTypeAnnotation(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSTypeAnnotation',
-      typeAnnotation: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSTypeAnnotation',
+    typeAnnotation: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.typeAnnotation = deserializeTSType(pos + 8);
   return node;
 }
 
 function deserializeTSLiteralType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSLiteralType',
-      literal: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSLiteralType',
+    literal: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.literal = deserializeTSLiteral(pos + 8);
   return node;
 }
@@ -3151,17 +3023,15 @@ function deserializeTSType(pos) {
 }
 
 function deserializeTSConditionalType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSConditionalType',
-      checkType: null,
-      extendsType: null,
-      trueType: null,
-      falseType: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSConditionalType',
+    checkType: null,
+    extendsType: null,
+    trueType: null,
+    falseType: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.checkType = deserializeTSType(pos + 8);
   node.extendsType = deserializeTSType(pos + 24);
   node.trueType = deserializeTSType(pos + 40);
@@ -3170,27 +3040,23 @@ function deserializeTSConditionalType(pos) {
 }
 
 function deserializeTSUnionType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSUnionType',
-      types: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSUnionType',
+    types: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.types = deserializeVecTSType(pos + 8);
   return node;
 }
 
 function deserializeTSIntersectionType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSIntersectionType',
-      types: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSIntersectionType',
+    types: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.types = deserializeVecTSType(pos + 8);
   return node;
 }
@@ -3235,42 +3101,36 @@ function deserializeTSTypeOperatorOperator(pos) {
 }
 
 function deserializeTSArrayType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSArrayType',
-      elementType: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSArrayType',
+    elementType: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.elementType = deserializeTSType(pos + 8);
   return node;
 }
 
 function deserializeTSIndexedAccessType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSIndexedAccessType',
-      objectType: null,
-      indexType: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSIndexedAccessType',
+    objectType: null,
+    indexType: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.objectType = deserializeTSType(pos + 8);
   node.indexType = deserializeTSType(pos + 24);
   return node;
 }
 
 function deserializeTSTupleType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSTupleType',
-      elementTypes: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSTupleType',
+    elementTypes: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.elementTypes = deserializeVecTSTupleElement(pos + 8);
   return node;
 }
@@ -3292,27 +3152,23 @@ function deserializeTSNamedTupleMember(pos) {
 }
 
 function deserializeTSOptionalType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSOptionalType',
-      typeAnnotation: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSOptionalType',
+    typeAnnotation: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.typeAnnotation = deserializeTSType(pos + 8);
   return node;
 }
 
 function deserializeTSRestType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSRestType',
-      typeAnnotation: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSRestType',
+    typeAnnotation: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.typeAnnotation = deserializeTSType(pos + 8);
   return node;
 }
@@ -3403,141 +3259,125 @@ function deserializeTSTupleElement(pos) {
 }
 
 function deserializeTSAnyKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSAnyKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSStringKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSStringKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSBooleanKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSBooleanKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSNumberKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSNumberKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSNeverKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSNeverKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSIntrinsicKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSIntrinsicKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSUnknownKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSUnknownKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSNullKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSNullKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSUndefinedKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSUndefinedKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSVoidKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSVoidKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSSymbolKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSSymbolKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSThisType(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSThisType',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSObjectKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSObjectKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSBigIntKeyword(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSBigIntKeyword',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
 function deserializeTSTypeReference(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSTypeReference',
-      typeName: null,
-      typeArguments: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSTypeReference',
+    typeName: null,
+    typeArguments: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.typeName = deserializeTSTypeName(pos + 8);
   node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 24);
   return node;
@@ -3557,29 +3397,25 @@ function deserializeTSTypeName(pos) {
 }
 
 function deserializeTSQualifiedName(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSQualifiedName',
-      left: null,
-      right: null,
-      start,
-      end,
-    };
-  node.left = deserializeTSTypeName(pos + 8);
-  node.right = deserializeIdentifierName(pos + 24);
-  return node;
-}
-
-function deserializeTSTypeParameterInstantiation(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSTypeParameterInstantiation',
-      params: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSQualifiedName',
+    left: null,
+    right: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
+  node.left = deserializeTSTypeName(pos + 8);
+  node.right = deserializeIdentifierName(pos + 24);
+  return node;
+}
+
+function deserializeTSTypeParameterInstantiation(pos) {
+  let node = {
+    type: 'TSTypeParameterInstantiation',
+    params: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.params = deserializeVecTSType(pos + 8);
   return node;
 }
@@ -3605,14 +3441,12 @@ function deserializeTSTypeParameter(pos) {
 }
 
 function deserializeTSTypeParameterDeclaration(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSTypeParameterDeclaration',
-      params: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSTypeParameterDeclaration',
+    params: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.params = deserializeVecTSTypeParameter(pos + 8);
   return node;
 }
@@ -3656,14 +3490,12 @@ function deserializeTSInterfaceDeclaration(pos) {
 }
 
 function deserializeTSInterfaceBody(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSInterfaceBody',
-      body: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSInterfaceBody',
+    body: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.body = deserializeVecTSSignature(pos + 8);
   return node;
 }
@@ -3727,15 +3559,13 @@ function deserializeTSIndexSignature(pos) {
 }
 
 function deserializeTSCallSignatureDeclaration(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'TSCallSignatureDeclaration',
       typeParameters: null,
       params: null,
       returnType: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     params = deserializeBoxFormalParameters(pos + 24),
     thisParam = deserializeOptionBoxTSThisParameter(pos + 16);
@@ -3791,16 +3621,14 @@ function deserializeTSMethodSignature(pos) {
 }
 
 function deserializeTSConstructSignatureDeclaration(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSConstructSignatureDeclaration',
-      typeParameters: null,
-      params: null,
-      returnType: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSConstructSignatureDeclaration',
+    typeParameters: null,
+    params: null,
+    returnType: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.typeParameters = deserializeOptionBoxTSTypeParameterDeclaration(pos + 8);
   node.params = deserializeBoxFormalParameters(pos + 16);
   node.returnType = deserializeOptionBoxTSTypeAnnotation(pos + 24);
@@ -3826,15 +3654,13 @@ function deserializeTSIndexSignatureName(pos) {
 }
 
 function deserializeTSInterfaceHeritage(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSInterfaceHeritage',
-      expression: null,
-      typeArguments: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSInterfaceHeritage',
+    expression: null,
+    typeArguments: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeExpression(pos + 8);
   node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 24);
   return node;
@@ -3901,7 +3727,7 @@ function deserializeTSModuleDeclaration(pos) {
     if (body.type === 'TSModuleBlock') node.id = id;
     else {
       let innerId = body.id;
-      if (innerId.type === 'Identifier') {
+      if (innerId.type === 'Identifier')
         node.id = {
           type: 'TSQualifiedName',
           left: id,
@@ -3909,7 +3735,7 @@ function deserializeTSModuleDeclaration(pos) {
           start: id.start,
           end: innerId.end,
         };
-      } else {
+      else {
         // Replace `left` of innermost `TSQualifiedName` with a nested `TSQualifiedName` with `id` of
         // this module on left, and previous `left` of innermost `TSQualifiedName` on right
         node.id = innerId;
@@ -3973,13 +3799,11 @@ function deserializeTSModuleDeclarationBody(pos) {
 }
 
 function deserializeTSModuleBlock(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'TSModuleBlock',
       body: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     body = deserializeVecDirective(pos + 8);
   body.push(...deserializeVecStatement(pos + 32));
@@ -3988,41 +3812,35 @@ function deserializeTSModuleBlock(pos) {
 }
 
 function deserializeTSTypeLiteral(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSTypeLiteral',
-      members: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSTypeLiteral',
+    members: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.members = deserializeVecTSSignature(pos + 8);
   return node;
 }
 
 function deserializeTSInferType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSInferType',
-      typeParameter: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSInferType',
+    typeParameter: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.typeParameter = deserializeBoxTSTypeParameter(pos + 8);
   return node;
 }
 
 function deserializeTSTypeQuery(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSTypeQuery',
-      exprName: null,
-      typeArguments: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSTypeQuery',
+    exprName: null,
+    typeArguments: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.exprName = deserializeTSTypeQueryExprName(pos + 8);
   node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 24);
   return node;
@@ -4044,17 +3862,15 @@ function deserializeTSTypeQueryExprName(pos) {
 }
 
 function deserializeTSImportType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSImportType',
-      argument: null,
-      options: null,
-      qualifier: null,
-      typeArguments: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSImportType',
+    argument: null,
+    options: null,
+    qualifier: null,
+    typeArguments: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.argument = deserializeTSType(pos + 8);
   node.options = deserializeOptionBoxObjectExpression(pos + 24);
   node.qualifier = deserializeOptionTSImportTypeQualifier(pos + 32);
@@ -4074,30 +3890,26 @@ function deserializeTSImportTypeQualifier(pos) {
 }
 
 function deserializeTSImportTypeQualifiedName(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSQualifiedName',
-      left: null,
-      right: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSQualifiedName',
+    left: null,
+    right: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.left = deserializeTSImportTypeQualifier(pos + 8);
   node.right = deserializeIdentifierName(pos + 24);
   return node;
 }
 
 function deserializeTSFunctionType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
+  let node = {
       type: 'TSFunctionType',
       typeParameters: null,
       params: null,
       returnType: null,
-      start,
-      end,
+      start: deserializeU32(pos),
+      end: deserializeU32(pos + 4),
     },
     params = deserializeBoxFormalParameters(pos + 24),
     thisParam = deserializeOptionBoxTSThisParameter(pos + 16);
@@ -4113,7 +3925,7 @@ function deserializeTSConstructorType(pos) {
     end = deserializeU32(pos + 4),
     node = {
       type: 'TSConstructorType',
-      abstract: deserializeBool(pos + 32),
+      abstract: deserializeBool(pos + 36),
       typeParameters: null,
       params: null,
       returnType: null,
@@ -4167,60 +3979,52 @@ function deserializeTSMappedTypeModifierOperator(pos) {
 }
 
 function deserializeTSTemplateLiteralType(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSTemplateLiteralType',
-      quasis: null,
-      types: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSTemplateLiteralType',
+    quasis: null,
+    types: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.quasis = deserializeVecTemplateElement(pos + 8);
   node.types = deserializeVecTSType(pos + 32);
   return node;
 }
 
 function deserializeTSAsExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSAsExpression',
-      expression: null,
-      typeAnnotation: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSAsExpression',
+    expression: null,
+    typeAnnotation: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeExpression(pos + 8);
   node.typeAnnotation = deserializeTSType(pos + 24);
   return node;
 }
 
 function deserializeTSSatisfiesExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSSatisfiesExpression',
-      expression: null,
-      typeAnnotation: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSSatisfiesExpression',
+    expression: null,
+    typeAnnotation: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeExpression(pos + 8);
   node.typeAnnotation = deserializeTSType(pos + 24);
   return node;
 }
 
 function deserializeTSTypeAssertion(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSTypeAssertion',
-      typeAnnotation: null,
-      expression: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSTypeAssertion',
+    typeAnnotation: null,
+    expression: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.typeAnnotation = deserializeTSType(pos + 8);
   node.expression = deserializeExpression(pos + 24);
   return node;
@@ -4258,80 +4062,68 @@ function deserializeTSModuleReference(pos) {
 }
 
 function deserializeTSExternalModuleReference(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSExternalModuleReference',
-      expression: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSExternalModuleReference',
+    expression: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeStringLiteral(pos + 8);
   return node;
 }
 
 function deserializeTSNonNullExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSNonNullExpression',
-      expression: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSNonNullExpression',
+    expression: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeExpression(pos + 8);
   return node;
 }
 
 function deserializeDecorator(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'Decorator',
-      expression: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'Decorator',
+    expression: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeExpression(pos + 8);
   return node;
 }
 
 function deserializeTSExportAssignment(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSExportAssignment',
-      expression: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSExportAssignment',
+    expression: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeExpression(pos + 8);
   return node;
 }
 
 function deserializeTSNamespaceExportDeclaration(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSNamespaceExportDeclaration',
-      id: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSNamespaceExportDeclaration',
+    id: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.id = deserializeIdentifierName(pos + 8);
   return node;
 }
 
 function deserializeTSInstantiationExpression(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: 'TSInstantiationExpression',
-      expression: null,
-      typeArguments: null,
-      start,
-      end,
-    };
+  let node = {
+    type: 'TSInstantiationExpression',
+    expression: null,
+    typeArguments: null,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
+  };
   node.expression = deserializeExpression(pos + 8);
   node.typeArguments = deserializeBoxTSTypeParameterInstantiation(pos + 24);
   return node;
@@ -4377,11 +4169,10 @@ function deserializeJSDocNonNullableType(pos) {
 }
 
 function deserializeJSDocUnknownType(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
   return {
     type: 'TSJSDocUnknownType',
-    start,
-    end,
+    start: deserializeU32(pos),
+    end: deserializeU32(pos + 4),
   };
 }
 
@@ -4399,20 +4190,18 @@ function deserializeCommentKind(pos) {
 function deserializeComment(pos) {
   let type = deserializeCommentKind(pos + 12),
     start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type,
-      value: null,
-      start,
-      end,
-    },
-    endCut = type === 'Line' ? 0 : 2;
-  node.value = sourceText.slice(start + 2, end - endCut);
-  return node;
+    end = deserializeU32(pos + 4);
+  return {
+    type,
+    value: sourceText.slice(start + 2, end - (type === 'Line' ? 0 : 2)),
+    start,
+    end,
+  };
 }
 
 function deserializeNameSpan(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     value: deserializeStr(pos + 8),
     start,
@@ -4459,7 +4248,8 @@ function deserializeImportImportName(pos) {
 }
 
 function deserializeExportEntry(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     moduleRequest: deserializeOptionNameSpan(pos + 16),
     importName: deserializeExportImportName(pos + 40),
@@ -4568,7 +4358,8 @@ function deserializeExportLocalName(pos) {
 }
 
 function deserializeDynamicImport(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     moduleRequest: deserializeSpan(pos + 8),
     start,
@@ -4762,7 +4553,8 @@ function deserializeErrorSeverity(pos) {
 }
 
 function deserializeErrorLabel(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     message: deserializeOptionStr(pos + 8),
     start,
@@ -4781,7 +4573,8 @@ function deserializeEcmaScriptModule(pos) {
 }
 
 function deserializeStaticImport(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     moduleRequest: deserializeNameSpan(pos + 8),
     entries: deserializeVecImportEntry(pos + 32),
@@ -4791,7 +4584,8 @@ function deserializeStaticImport(pos) {
 }
 
 function deserializeStaticExport(pos) {
-  let start = deserializeU32(pos), end = deserializeU32(pos + 4);
+  let start = deserializeU32(pos),
+    end = deserializeU32(pos + 4);
   return {
     entries: deserializeVecExportEntry(pos + 8),
     start,
@@ -4808,7 +4602,8 @@ function deserializeU8(pos) {
 }
 
 function deserializeStr(pos) {
-  let pos32 = pos >> 2, len = uint32[pos32 + 2];
+  let pos32 = pos >> 2,
+    len = uint32[pos32 + 2];
   if (len === 0) return '';
   pos = uint32[pos32];
   if (sourceIsAscii && pos < sourceByteLen) return sourceText.substr(pos, len);
@@ -4817,7 +4612,8 @@ function deserializeStr(pos) {
   let end = pos + len;
   if (len > 50) return decodeStr(uint8.subarray(pos, end));
   // Shorter strings decode by hand to avoid native call
-  let out = '', c;
+  let out = '',
+    c;
   do {
     c = uint8[pos++];
     if (c < 128) out += fromCodePoint(c);
@@ -4830,10 +4626,11 @@ function deserializeStr(pos) {
 }
 
 function deserializeVecComment(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeComment(pos));
     pos += 16;
   }
@@ -4841,15 +4638,16 @@ function deserializeVecComment(pos) {
 }
 
 function deserializeOptionHashbang(pos) {
-  if (uint32[pos + 8 >> 2] === 0 && uint32[pos + 12 >> 2] === 0) return null;
+  if (uint32[(pos + 8) >> 2] === 0 && uint32[(pos + 12) >> 2] === 0) return null;
   return deserializeHashbang(pos);
 }
 
 function deserializeVecDirective(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 72;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeDirective(pos));
     pos += 72;
   }
@@ -4857,10 +4655,11 @@ function deserializeVecDirective(pos) {
 }
 
 function deserializeVecStatement(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeStatement(pos));
     pos += 16;
   }
@@ -5028,10 +4827,11 @@ function deserializeBoxV8IntrinsicExpression(pos) {
 }
 
 function deserializeVecArrayExpressionElement(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeArrayExpressionElement(pos));
     pos += 16;
   }
@@ -5043,10 +4843,11 @@ function deserializeBoxSpreadElement(pos) {
 }
 
 function deserializeVecObjectPropertyKind(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeObjectPropertyKind(pos));
     pos += 16;
   }
@@ -5070,10 +4871,11 @@ function deserializeBoxPrivateIdentifier(pos) {
 }
 
 function deserializeVecTemplateElement(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 48;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeTemplateElement(pos));
     pos += 48;
   }
@@ -5081,10 +4883,11 @@ function deserializeVecTemplateElement(pos) {
 }
 
 function deserializeVecExpression(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeExpression(pos));
     pos += 16;
   }
@@ -5096,12 +4899,12 @@ function deserializeBoxTSTypeParameterInstantiation(pos) {
 }
 
 function deserializeOptionBoxTSTypeParameterInstantiation(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxTSTypeParameterInstantiation(pos);
 }
 
 function deserializeOptionStr(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeStr(pos);
 }
 
@@ -5118,10 +4921,11 @@ function deserializeBoxPrivateFieldExpression(pos) {
 }
 
 function deserializeVecArgument(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeArgument(pos));
     pos += 16;
   }
@@ -5142,10 +4946,11 @@ function deserializeOptionAssignmentTargetMaybeDefault(pos) {
 }
 
 function deserializeVecOptionAssignmentTargetMaybeDefault(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeOptionAssignmentTargetMaybeDefault(pos));
     pos += 16;
   }
@@ -5157,15 +4962,16 @@ function deserializeBoxAssignmentTargetRest(pos) {
 }
 
 function deserializeOptionBoxAssignmentTargetRest(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxAssignmentTargetRest(pos);
 }
 
 function deserializeVecAssignmentTargetProperty(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeAssignmentTargetProperty(pos));
     pos += 16;
   }
@@ -5286,10 +5092,11 @@ function deserializeBoxTSImportEqualsDeclaration(pos) {
 }
 
 function deserializeVecVariableDeclarator(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 64;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeVariableDeclarator(pos));
     pos += 64;
   }
@@ -5307,15 +5114,16 @@ function deserializeOptionForStatementInit(pos) {
 }
 
 function deserializeOptionLabelIdentifier(pos) {
-  if (uint32[pos + 8 >> 2] === 0 && uint32[pos + 12 >> 2] === 0) return null;
+  if (uint32[(pos + 8) >> 2] === 0 && uint32[(pos + 12) >> 2] === 0) return null;
   return deserializeLabelIdentifier(pos);
 }
 
 function deserializeVecSwitchCase(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 48;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeSwitchCase(pos));
     pos += 48;
   }
@@ -5327,12 +5135,12 @@ function deserializeBoxCatchClause(pos) {
 }
 
 function deserializeOptionBoxCatchClause(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxCatchClause(pos);
 }
 
 function deserializeOptionBoxBlockStatement(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxBlockStatement(pos);
 }
 
@@ -5346,7 +5154,7 @@ function deserializeBoxTSTypeAnnotation(pos) {
 }
 
 function deserializeOptionBoxTSTypeAnnotation(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxTSTypeAnnotation(pos);
 }
 
@@ -5367,10 +5175,11 @@ function deserializeBoxAssignmentPattern(pos) {
 }
 
 function deserializeVecBindingProperty(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 64;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeBindingProperty(pos));
     pos += 64;
   }
@@ -5382,7 +5191,7 @@ function deserializeBoxBindingRestElement(pos) {
 }
 
 function deserializeOptionBoxBindingRestElement(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxBindingRestElement(pos);
 }
 
@@ -5392,10 +5201,11 @@ function deserializeOptionBindingPattern(pos) {
 }
 
 function deserializeVecOptionBindingPattern(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 32;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeOptionBindingPattern(pos));
     pos += 32;
   }
@@ -5403,7 +5213,7 @@ function deserializeVecOptionBindingPattern(pos) {
 }
 
 function deserializeOptionBindingIdentifier(pos) {
-  if (uint32[pos + 8 >> 2] === 0 && uint32[pos + 12 >> 2] === 0) return null;
+  if (uint32[(pos + 8) >> 2] === 0 && uint32[(pos + 12) >> 2] === 0) return null;
   return deserializeBindingIdentifier(pos);
 }
 
@@ -5412,7 +5222,7 @@ function deserializeBoxTSTypeParameterDeclaration(pos) {
 }
 
 function deserializeOptionBoxTSTypeParameterDeclaration(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxTSTypeParameterDeclaration(pos);
 }
 
@@ -5421,7 +5231,7 @@ function deserializeBoxTSThisParameter(pos) {
 }
 
 function deserializeOptionBoxTSThisParameter(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxTSThisParameter(pos);
 }
 
@@ -5434,15 +5244,16 @@ function deserializeBoxFunctionBody(pos) {
 }
 
 function deserializeOptionBoxFunctionBody(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxFunctionBody(pos);
 }
 
 function deserializeVecFormalParameter(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 72;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeFormalParameter(pos));
     pos += 72;
   }
@@ -5450,10 +5261,11 @@ function deserializeVecFormalParameter(pos) {
 }
 
 function deserializeVecDecorator(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 24;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeDecorator(pos));
     pos += 24;
   }
@@ -5465,10 +5277,11 @@ function deserializeBoxClassBody(pos) {
 }
 
 function deserializeVecClassElement(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeClassElement(pos));
     pos += 16;
   }
@@ -5525,10 +5338,11 @@ function deserializeOptionImportPhase(pos) {
 }
 
 function deserializeVecImportDeclarationSpecifier(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeImportDeclarationSpecifier(pos));
     pos += 16;
   }
@@ -5536,7 +5350,7 @@ function deserializeVecImportDeclarationSpecifier(pos) {
 }
 
 function deserializeOptionVecImportDeclarationSpecifier(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeVecImportDeclarationSpecifier(pos);
 }
 
@@ -5545,7 +5359,7 @@ function deserializeBoxWithClause(pos) {
 }
 
 function deserializeOptionBoxWithClause(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxWithClause(pos);
 }
 
@@ -5562,10 +5376,11 @@ function deserializeBoxImportNamespaceSpecifier(pos) {
 }
 
 function deserializeVecImportAttribute(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 112;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeImportAttribute(pos));
     pos += 112;
   }
@@ -5578,10 +5393,11 @@ function deserializeOptionDeclaration(pos) {
 }
 
 function deserializeVecExportSpecifier(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 128;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeExportSpecifier(pos));
     pos += 128;
   }
@@ -5607,10 +5423,11 @@ function deserializeBoxJSXOpeningElement(pos) {
 }
 
 function deserializeVecJSXChild(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeJSXChild(pos));
     pos += 16;
   }
@@ -5622,15 +5439,16 @@ function deserializeBoxJSXClosingElement(pos) {
 }
 
 function deserializeOptionBoxJSXClosingElement(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxJSXClosingElement(pos);
 }
 
 function deserializeVecJSXAttributeItem(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeJSXAttributeItem(pos));
     pos += 16;
   }
@@ -5675,10 +5493,11 @@ function deserializeBoxJSXSpreadChild(pos) {
 }
 
 function deserializeVecTSEnumMember(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 40;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeTSEnumMember(pos));
     pos += 40;
   }
@@ -5834,10 +5653,11 @@ function deserializeBoxJSDocUnknownType(pos) {
 }
 
 function deserializeVecTSType(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeTSType(pos));
     pos += 16;
   }
@@ -5845,10 +5665,11 @@ function deserializeVecTSType(pos) {
 }
 
 function deserializeVecTSTupleElement(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeTSTupleElement(pos));
     pos += 16;
   }
@@ -5873,10 +5694,11 @@ function deserializeOptionTSType(pos) {
 }
 
 function deserializeVecTSTypeParameter(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 80;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeTSTypeParameter(pos));
     pos += 80;
   }
@@ -5884,10 +5706,11 @@ function deserializeVecTSTypeParameter(pos) {
 }
 
 function deserializeVecTSInterfaceHeritage(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 32;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeTSInterfaceHeritage(pos));
     pos += 32;
   }
@@ -5899,10 +5722,11 @@ function deserializeBoxTSInterfaceBody(pos) {
 }
 
 function deserializeVecTSSignature(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeTSSignature(pos));
     pos += 16;
   }
@@ -5926,10 +5750,11 @@ function deserializeBoxTSMethodSignature(pos) {
 }
 
 function deserializeVecTSIndexSignatureName(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 32;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeTSIndexSignatureName(pos));
     pos += 32;
   }
@@ -5950,7 +5775,7 @@ function deserializeBoxTSTypeParameter(pos) {
 }
 
 function deserializeOptionBoxObjectExpression(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[pos + 4 >> 2] === 0) return null;
+  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
   return deserializeBoxObjectExpression(pos);
 }
 
@@ -5973,15 +5798,16 @@ function deserializeBoxTSExternalModuleReference(pos) {
 }
 
 function deserializeOptionNameSpan(pos) {
-  if (uint32[pos + 8 >> 2] === 0 && uint32[pos + 12 >> 2] === 0) return null;
+  if (uint32[(pos + 8) >> 2] === 0 && uint32[(pos + 12) >> 2] === 0) return null;
   return deserializeNameSpan(pos);
 }
 
 function deserializeVecError(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 80;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeError(pos));
     pos += 80;
   }
@@ -5989,10 +5815,11 @@ function deserializeVecError(pos) {
 }
 
 function deserializeVecErrorLabel(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 24;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeErrorLabel(pos));
     pos += 24;
   }
@@ -6000,10 +5827,11 @@ function deserializeVecErrorLabel(pos) {
 }
 
 function deserializeVecStaticImport(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 56;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeStaticImport(pos));
     pos += 56;
   }
@@ -6011,10 +5839,11 @@ function deserializeVecStaticImport(pos) {
 }
 
 function deserializeVecStaticExport(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 32;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeStaticExport(pos));
     pos += 32;
   }
@@ -6022,10 +5851,11 @@ function deserializeVecStaticExport(pos) {
 }
 
 function deserializeVecDynamicImport(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 16;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeDynamicImport(pos));
     pos += 16;
   }
@@ -6033,10 +5863,11 @@ function deserializeVecDynamicImport(pos) {
 }
 
 function deserializeVecSpan(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 8;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeSpan(pos));
     pos += 8;
   }
@@ -6044,10 +5875,11 @@ function deserializeVecSpan(pos) {
 }
 
 function deserializeVecImportEntry(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 96;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeImportEntry(pos));
     pos += 96;
   }
@@ -6055,10 +5887,11 @@ function deserializeVecImportEntry(pos) {
 }
 
 function deserializeVecExportEntry(pos) {
-  let arr = [], pos32 = pos >> 2;
+  let arr = [],
+    pos32 = pos >> 2;
   pos = uint32[pos32];
   let endPos = pos + uint32[pos32 + 2] * 144;
-  for (; pos !== endPos;) {
+  for (; pos !== endPos; ) {
     arr.push(deserializeExportEntry(pos));
     pos += 144;
   }