oxc-parser 0.123.0 → 0.125.0

package/src-js/generated/deserialize/ts_range.js

@@ -1,35 +1,50 @@
 // Auto-generated code, DO NOT EDIT DIRECTLY!
 // To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer.rs`.
 
-let uint8, uint32, float64, sourceText, sourceIsAscii, sourceEndPos;
-
-const textDecoder = new TextDecoder("utf-8", { ignoreBOM: true }),
-  decodeStr = textDecoder.decode.bind(textDecoder),
-  { fromCodePoint } = String;
+let uint8,
+  int32,
+  float64,
+  sourceText,
+  sourceTextLatin,
+  sourceEndPos = 0,
+  firstNonAsciiPos = 0;
+
+const { fromCharCode } = String,
+  { utf8Slice, latin1Slice } = Buffer.prototype,
+  stringDecodeArrays = Array(65).fill(null);
+for (let i = 0; i <= 64; i++) stringDecodeArrays[i] = Array(i).fill(0);
 
 export function deserialize(buffer, sourceText, sourceByteLen) {
   sourceEndPos = sourceByteLen;
-  let data = deserializeWith(buffer, sourceText, sourceByteLen, null, deserializeRawTransferData);
-  resetBuffer();
-  return data;
+  return deserializeWith(buffer, sourceText, sourceByteLen, deserializeRawTransferData);
 }
 
-function deserializeWith(buffer, sourceTextInput, sourceByteLen, getLocInput, deserialize) {
+function deserializeWith(buffer, sourceTextInput, sourceByteLen, deserialize) {
   uint8 = buffer;
-  uint32 = buffer.uint32;
+  int32 = buffer.int32;
   float64 = buffer.float64;
   sourceText = sourceTextInput;
-  sourceIsAscii = sourceText.length === sourceByteLen;
-  return deserialize(uint32[536870900]);
+  if (sourceText.length === sourceByteLen) {
+    firstNonAsciiPos = sourceByteLen;
+    sourceTextLatin = sourceText;
+  } else {
+    let i = 0;
+    for (; i < sourceByteLen && uint8[i] < 128; i++);
+    firstNonAsciiPos = i;
+    sourceTextLatin = latin1Slice.call(uint8, 0, sourceByteLen);
+  }
+  let data = deserialize(int32[536870900]);
+  resetBuffer();
+  return data;
 }
 
 export function resetBuffer() {
-  // Clear buffer and source text string to allow them to be garbage collected
-  uint8 = uint32 = float64 = sourceText = void 0;
+  // Clear buffer and source text strings to allow them to be garbage collected
+  uint8 = int32 = float64 = sourceText = sourceTextLatin = void 0;
 }
 
 function deserializeProgram(pos) {
-  let end = deserializeU32(pos + 4),
+  let end = deserializeI32(pos + 4),
     program = {
       type: "Program",
       body: null,
@@ -158,83 +173,67 @@ function deserializeExpression(pos) {
 }
 
 function deserializeIdentifierName(pos) {
-  let start,
-    end,
-    node = {
-      type: "Identifier",
-      decorators: null,
-      name: deserializeStr(pos + 16),
-      optional: null,
-      typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
-      range: [start, end],
-    };
-  node.decorators = [];
-  node.optional = false;
-  return node;
+  let start, end;
+  return {
+    type: "Identifier",
+    decorators: [],
+    name: deserializeStr(pos + 16),
+    optional: false,
+    typeAnnotation: null,
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
+    range: [start, end],
+  };
 }
 
 function deserializeIdentifierReference(pos) {
-  let start,
-    end,
-    node = {
-      type: "Identifier",
-      decorators: null,
-      name: deserializeStr(pos + 16),
-      optional: null,
-      typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
-      range: [start, end],
-    };
-  node.decorators = [];
-  node.optional = false;
-  return node;
+  let start, end;
+  return {
+    type: "Identifier",
+    decorators: [],
+    name: deserializeStr(pos + 16),
+    optional: false,
+    typeAnnotation: null,
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
+    range: [start, end],
+  };
 }
 
 function deserializeBindingIdentifier(pos) {
-  let start,
-    end,
-    node = {
-      type: "Identifier",
-      decorators: null,
-      name: deserializeStr(pos + 16),
-      optional: null,
-      typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
-      range: [start, end],
-    };
-  node.decorators = [];
-  node.optional = false;
-  return node;
+  let start, end;
+  return {
+    type: "Identifier",
+    decorators: [],
+    name: deserializeStr(pos + 16),
+    optional: false,
+    typeAnnotation: null,
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
+    range: [start, end],
+  };
 }
 
 function deserializeLabelIdentifier(pos) {
-  let start,
-    end,
-    node = {
-      type: "Identifier",
-      decorators: null,
-      name: deserializeStr(pos + 16),
-      optional: null,
-      typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
-      range: [start, end],
-    };
-  node.decorators = [];
-  node.optional = false;
-  return node;
+  let start, end;
+  return {
+    type: "Identifier",
+    decorators: [],
+    name: deserializeStr(pos + 16),
+    optional: false,
+    typeAnnotation: null,
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
+    range: [start, end],
+  };
 }
 
 function deserializeThisExpression(pos) {
   let start, end;
   return {
     type: "ThisExpression",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -245,8 +244,8 @@ function deserializeArrayExpression(pos) {
     node = {
       type: "ArrayExpression",
       elements: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.elements = deserializeVecArrayExpressionElement(pos + 16);
@@ -360,8 +359,8 @@ function deserializeObjectExpression(pos) {
     node = {
       type: "ObjectExpression",
       properties: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.properties = deserializeVecObjectPropertyKind(pos + 16);
@@ -390,14 +389,13 @@ function deserializeObjectProperty(pos) {
       method: deserializeBool(pos + 13),
       shorthand: deserializeBool(pos + 14),
       computed: deserializeBool(pos + 15),
-      optional: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      optional: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.key = deserializePropertyKey(pos + 16);
   node.value = deserializeExpression(pos + 32);
-  node.optional = false;
   return node;
 }
 
@@ -518,8 +516,8 @@ function deserializeTemplateLiteral(pos) {
       type: "TemplateLiteral",
       quasis: null,
       expressions: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.quasis = deserializeVecTemplateElement(pos + 16);
@@ -535,8 +533,8 @@ function deserializeTaggedTemplateExpression(pos) {
       tag: null,
       typeArguments: null,
       quasi: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.tag = deserializeExpression(pos + 16);
@@ -547,8 +545,8 @@ function deserializeTaggedTemplateExpression(pos) {
 
 function deserializeTemplateElement(pos) {
   let tail = deserializeBool(pos + 12),
-    start = deserializeU32(pos) - 1,
-    end = deserializeU32(pos + 4) + 2 - tail,
+    start = deserializeI32(pos) - 1,
+    end = deserializeI32(pos + 4) + 2 - tail,
     value = deserializeTemplateElementValue(pos + 16);
   value.cooked !== null &&
     deserializeBool(pos + 13) &&
@@ -580,14 +578,13 @@ function deserializeComputedMemberExpression(pos) {
       object: null,
       property: null,
       optional: deserializeBool(pos + 12),
-      computed: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      computed: true,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.object = deserializeExpression(pos + 16);
   node.property = deserializeExpression(pos + 32);
-  node.computed = true;
   return node;
 }
 
@@ -599,14 +596,13 @@ function deserializeStaticMemberExpression(pos) {
       object: null,
       property: null,
       optional: deserializeBool(pos + 12),
-      computed: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      computed: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.object = deserializeExpression(pos + 16);
   node.property = deserializeIdentifierName(pos + 32);
-  node.computed = false;
   return node;
 }
 
@@ -618,14 +614,13 @@ function deserializePrivateFieldExpression(pos) {
       object: null,
       property: null,
       optional: deserializeBool(pos + 12),
-      computed: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      computed: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.object = deserializeExpression(pos + 16);
   node.property = deserializePrivateIdentifier(pos + 32);
-  node.computed = false;
   return node;
 }
 
@@ -638,8 +633,8 @@ function deserializeCallExpression(pos) {
       typeArguments: null,
       arguments: null,
       optional: deserializeBool(pos + 12),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.callee = deserializeExpression(pos + 16);
@@ -656,8 +651,8 @@ function deserializeNewExpression(pos) {
       callee: null,
       typeArguments: null,
       arguments: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.callee = deserializeExpression(pos + 16);
@@ -673,8 +668,8 @@ function deserializeMetaProperty(pos) {
       type: "MetaProperty",
       meta: null,
       property: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.meta = deserializeIdentifierName(pos + 16);
@@ -688,8 +683,8 @@ function deserializeSpreadElement(pos) {
     node = {
       type: "SpreadElement",
       argument: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.argument = deserializeExpression(pos + 16);
@@ -799,8 +794,8 @@ function deserializeUpdateExpression(pos) {
       operator: deserializeUpdateOperator(pos + 12),
       prefix: deserializeBool(pos + 13),
       argument: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.argument = deserializeSimpleAssignmentTarget(pos + 16);
@@ -814,13 +809,12 @@ function deserializeUnaryExpression(pos) {
       type: "UnaryExpression",
       operator: deserializeUnaryOperator(pos + 12),
       argument: null,
-      prefix: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      prefix: true,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.argument = deserializeExpression(pos + 16);
-  node.prefix = true;
   return node;
 }
 
@@ -832,8 +826,8 @@ function deserializeBinaryExpression(pos) {
       left: null,
       operator: deserializeBinaryOperator(pos + 12),
       right: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.left = deserializeExpression(pos + 16);
@@ -847,14 +841,13 @@ function deserializePrivateInExpression(pos) {
     node = {
       type: "BinaryExpression",
       left: null,
-      operator: null,
+      operator: "in",
       right: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.left = deserializePrivateIdentifier(pos + 16);
-  node.operator = "in";
   node.right = deserializeExpression(pos + 48);
   return node;
 }
@@ -867,8 +860,8 @@ function deserializeLogicalExpression(pos) {
       left: null,
       operator: deserializeLogicalOperator(pos + 12),
       right: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.left = deserializeExpression(pos + 16);
@@ -884,8 +877,8 @@ function deserializeConditionalExpression(pos) {
       test: null,
       consequent: null,
       alternate: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.test = deserializeExpression(pos + 16);
@@ -902,8 +895,8 @@ function deserializeAssignmentExpression(pos) {
       operator: deserializeAssignmentOperator(pos + 12),
       left: null,
       right: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.left = deserializeAssignmentTarget(pos + 16);
@@ -966,20 +959,18 @@ function deserializeArrayAssignmentTarget(pos) {
     end,
     node = {
       type: "ArrayPattern",
-      decorators: null,
+      decorators: [],
       elements: null,
-      optional: null,
+      optional: false,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     elements = deserializeVecOptionAssignmentTargetMaybeDefault(pos + 16),
     rest = deserializeOptionBoxAssignmentTargetRest(pos + 40);
   rest !== null && elements.push(rest);
-  node.decorators = [];
   node.elements = elements;
-  node.optional = false;
   return node;
 }
 
@@ -988,20 +979,18 @@ function deserializeObjectAssignmentTarget(pos) {
     end,
     node = {
       type: "ObjectPattern",
-      decorators: null,
+      decorators: [],
       properties: null,
-      optional: null,
+      optional: false,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     properties = deserializeVecAssignmentTargetProperty(pos + 16),
     rest = deserializeOptionBoxAssignmentTargetRest(pos + 40);
   rest !== null && properties.push(rest);
-  node.decorators = [];
   node.properties = properties;
-  node.optional = false;
   return node;
 }
 
@@ -1010,18 +999,16 @@ function deserializeAssignmentTargetRest(pos) {
     end,
     node = {
       type: "RestElement",
-      decorators: null,
+      decorators: [],
       argument: null,
-      optional: null,
+      optional: false,
       typeAnnotation: null,
       value: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
-  node.decorators = [];
   node.argument = deserializeAssignmentTarget(pos + 16);
-  node.optional = false;
   return node;
 }
 
@@ -1059,19 +1046,17 @@ function deserializeAssignmentTargetWithDefault(pos) {
     end,
     node = {
       type: "AssignmentPattern",
-      decorators: null,
+      decorators: [],
       left: null,
       right: null,
-      optional: null,
+      optional: false,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
-  node.decorators = [];
   node.left = deserializeAssignmentTarget(pos + 16);
   node.right = deserializeExpression(pos + 32);
-  node.optional = false;
   return node;
 }
 
@@ -1087,17 +1072,17 @@ function deserializeAssignmentTargetProperty(pos) {
 }
 
 function deserializeAssignmentTargetPropertyIdentifier(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
+  let start = deserializeI32(pos),
+    end = deserializeI32(pos + 4),
     node = {
       type: "Property",
-      kind: null,
+      kind: "init",
       key: null,
       value: null,
-      method: null,
-      shorthand: null,
-      computed: null,
-      optional: null,
+      method: false,
+      shorthand: true,
+      computed: false,
+      optional: false,
       start,
       end,
       range: [start, end],
@@ -1128,13 +1113,8 @@ function deserializeAssignmentTargetPropertyIdentifier(pos) {
       end,
       range: [start, end],
     });
-  node.kind = "init";
   node.key = key;
   node.value = value;
-  node.method = false;
-  node.shorthand = true;
-  node.computed = false;
-  node.optional = false;
   return node;
 }
 
@@ -1143,23 +1123,19 @@ function deserializeAssignmentTargetPropertyProperty(pos) {
     end,
     node = {
       type: "Property",
-      kind: null,
+      kind: "init",
       key: null,
       value: null,
-      method: null,
-      shorthand: null,
+      method: false,
+      shorthand: false,
       computed: deserializeBool(pos + 12),
-      optional: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      optional: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
-  node.kind = "init";
   node.key = deserializePropertyKey(pos + 16);
   node.value = deserializeAssignmentTargetMaybeDefault(pos + 32);
-  node.method = false;
-  node.shorthand = false;
-  node.optional = false;
   return node;
 }
 
@@ -1169,8 +1145,8 @@ function deserializeSequenceExpression(pos) {
     node = {
       type: "SequenceExpression",
       expressions: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expressions = deserializeVecExpression(pos + 16);
@@ -1181,8 +1157,8 @@ function deserializeSuper(pos) {
   let start, end;
   return {
     type: "Super",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -1193,8 +1169,8 @@ function deserializeAwaitExpression(pos) {
     node = {
       type: "AwaitExpression",
       argument: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.argument = deserializeExpression(pos + 16);
@@ -1207,8 +1183,8 @@ function deserializeChainExpression(pos) {
     node = {
       type: "ChainExpression",
       expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeChainElement(pos + 16);
@@ -1239,8 +1215,8 @@ function deserializeParenthesizedExpression(pos) {
     node = {
       type: "ParenthesizedExpression",
       expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
     node.expression = deserializeExpression(pos + 16);
@@ -1328,8 +1304,8 @@ function deserializeDirective(pos) {
       type: "ExpressionStatement",
       expression: null,
       directive: deserializeStr(pos + 64),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeStringLiteral(pos + 16);
@@ -1341,8 +1317,8 @@ function deserializeHashbang(pos) {
   return {
     type: "Hashbang",
     value: deserializeStr(pos + 16),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -1353,8 +1329,8 @@ function deserializeBlockStatement(pos) {
     node = {
       type: "BlockStatement",
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.body = deserializeVecStatement(pos + 16);
@@ -1394,8 +1370,8 @@ function deserializeVariableDeclaration(pos) {
       kind: deserializeVariableDeclarationKind(pos + 12),
       declarations: null,
       declare: deserializeBool(pos + 13),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.declarations = deserializeVecVariableDeclarator(pos + 16);
@@ -1427,8 +1403,8 @@ function deserializeVariableDeclarator(pos) {
       id: null,
       init: null,
       definite: deserializeBool(pos + 13),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     pattern = deserializeBindingPattern(pos + 16);
@@ -1448,8 +1424,8 @@ function deserializeEmptyStatement(pos) {
   let start, end;
   return {
     type: "EmptyStatement",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -1461,8 +1437,8 @@ function deserializeExpressionStatement(pos) {
       type: "ExpressionStatement",
       expression: null,
       directive: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeExpression(pos + 16);
@@ -1477,8 +1453,8 @@ function deserializeIfStatement(pos) {
       test: null,
       consequent: null,
       alternate: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.test = deserializeExpression(pos + 16);
@@ -1494,8 +1470,8 @@ function deserializeDoWhileStatement(pos) {
       type: "DoWhileStatement",
       body: null,
       test: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.body = deserializeStatement(pos + 16);
@@ -1510,8 +1486,8 @@ function deserializeWhileStatement(pos) {
       type: "WhileStatement",
       test: null,
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.test = deserializeExpression(pos + 16);
@@ -1528,8 +1504,8 @@ function deserializeForStatement(pos) {
       test: null,
       update: null,
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.init = deserializeOptionForStatementInit(pos + 16);
@@ -1642,8 +1618,8 @@ function deserializeForInStatement(pos) {
       left: null,
       right: null,
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.left = deserializeForStatementLeft(pos + 16);
@@ -1690,8 +1666,8 @@ function deserializeForOfStatement(pos) {
       left: null,
       right: null,
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.left = deserializeForStatementLeft(pos + 16);
@@ -1706,8 +1682,8 @@ function deserializeContinueStatement(pos) {
     node = {
       type: "ContinueStatement",
       label: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.label = deserializeOptionLabelIdentifier(pos + 16);
@@ -1720,8 +1696,8 @@ function deserializeBreakStatement(pos) {
     node = {
       type: "BreakStatement",
       label: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.label = deserializeOptionLabelIdentifier(pos + 16);
@@ -1734,8 +1710,8 @@ function deserializeReturnStatement(pos) {
     node = {
       type: "ReturnStatement",
       argument: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.argument = deserializeOptionExpression(pos + 16);
@@ -1749,8 +1725,8 @@ function deserializeWithStatement(pos) {
       type: "WithStatement",
       object: null,
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.object = deserializeExpression(pos + 16);
@@ -1765,8 +1741,8 @@ function deserializeSwitchStatement(pos) {
       type: "SwitchStatement",
       discriminant: null,
       cases: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.discriminant = deserializeExpression(pos + 16);
@@ -1781,8 +1757,8 @@ function deserializeSwitchCase(pos) {
       type: "SwitchCase",
       test: null,
       consequent: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.test = deserializeOptionExpression(pos + 16);
@@ -1797,8 +1773,8 @@ function deserializeLabeledStatement(pos) {
       type: "LabeledStatement",
       label: null,
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.label = deserializeLabelIdentifier(pos + 16);
@@ -1812,8 +1788,8 @@ function deserializeThrowStatement(pos) {
     node = {
       type: "ThrowStatement",
       argument: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.argument = deserializeExpression(pos + 16);
@@ -1828,8 +1804,8 @@ function deserializeTryStatement(pos) {
       block: null,
       handler: null,
       finalizer: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.block = deserializeBoxBlockStatement(pos + 16);
@@ -1845,8 +1821,8 @@ function deserializeCatchClause(pos) {
       type: "CatchClause",
       param: null,
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.param = deserializeOptionCatchParameter(pos + 16);
@@ -1871,8 +1847,8 @@ function deserializeDebuggerStatement(pos) {
   let start, end;
   return {
     type: "DebuggerStatement",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -1897,19 +1873,17 @@ function deserializeAssignmentPattern(pos) {
     end,
     node = {
       type: "AssignmentPattern",
-      decorators: null,
+      decorators: [],
       left: null,
       right: null,
-      optional: null,
+      optional: false,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
-  node.decorators = [];
   node.left = deserializeBindingPattern(pos + 16);
   node.right = deserializeExpression(pos + 32);
-  node.optional = false;
   return node;
 }
 
@@ -1918,20 +1892,18 @@ function deserializeObjectPattern(pos) {
     end,
     node = {
       type: "ObjectPattern",
-      decorators: null,
+      decorators: [],
       properties: null,
-      optional: null,
+      optional: false,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     properties = deserializeVecBindingProperty(pos + 16),
     rest = deserializeOptionBoxBindingRestElement(pos + 40);
   rest !== null && properties.push(rest);
-  node.decorators = [];
   node.properties = properties;
-  node.optional = false;
   return node;
 }
 
@@ -1940,22 +1912,19 @@ function deserializeBindingProperty(pos) {
     end,
     node = {
       type: "Property",
-      kind: null,
+      kind: "init",
       key: null,
       value: null,
-      method: null,
+      method: false,
       shorthand: deserializeBool(pos + 12),
       computed: deserializeBool(pos + 13),
-      optional: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      optional: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
-  node.kind = "init";
   node.key = deserializePropertyKey(pos + 16);
   node.value = deserializeBindingPattern(pos + 32);
-  node.method = false;
-  node.optional = false;
   return node;
 }
 
@@ -1964,20 +1933,18 @@ function deserializeArrayPattern(pos) {
     end,
     node = {
       type: "ArrayPattern",
-      decorators: null,
+      decorators: [],
       elements: null,
-      optional: null,
+      optional: false,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     elements = deserializeVecOptionBindingPattern(pos + 16),
     rest = deserializeOptionBoxBindingRestElement(pos + 40);
   rest !== null && elements.push(rest);
-  node.decorators = [];
   node.elements = elements;
-  node.optional = false;
   return node;
 }
 
@@ -1986,18 +1953,16 @@ function deserializeBindingRestElement(pos) {
     end,
     node = {
       type: "RestElement",
-      decorators: null,
+      decorators: [],
       argument: null,
-      optional: null,
+      optional: false,
       typeAnnotation: null,
       value: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
-  node.decorators = [];
   node.argument = deserializeBindingPattern(pos + 16);
-  node.optional = false;
   return node;
 }
 
@@ -2014,9 +1979,9 @@ function deserializeFunction(pos) {
       params: null,
       returnType: null,
       body: null,
-      expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      expression: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     params = deserializeBoxFormalParameters(pos + 64);
@@ -2029,7 +1994,6 @@ function deserializeFunction(pos) {
   node.params = params;
   node.returnType = deserializeOptionBoxTSTypeAnnotation(pos + 72);
   node.body = deserializeOptionBoxFunctionBody(pos + 80);
-  node.expression = false;
   return node;
 }
 
@@ -2049,9 +2013,10 @@ function deserializeFunctionType(pos) {
 }
 
 function deserializeFormalParameters(pos) {
-  let params = deserializeVecFormalParameter(pos + 16);
-  if (uint32[(pos + 40) >> 2] !== 0 && uint32[(pos + 44) >> 2] !== 0) {
-    pos = uint32[(pos + 40) >> 2];
+  let params = deserializeVecFormalParameter(pos + 16),
+    restFieldPos32 = (pos >> 2) + 10;
+  if (int32[restFieldPos32] !== 0 && int32[restFieldPos32 + 1] !== 0) {
+    pos = int32[restFieldPos32];
     let start,
       end,
       rest = {
@@ -2061,8 +2026,8 @@ function deserializeFormalParameters(pos) {
         optional: false,
         typeAnnotation: null,
         value: null,
-        start: (start = deserializeU32(pos + 40)),
-        end: (end = deserializeU32(pos + 44)),
+        start: (start = deserializeI32(pos + 40)),
+        end: (end = deserializeI32(pos + 44)),
         range: [start, end],
       };
     rest.argument = deserializeBindingPattern(pos + 56);
@@ -2079,7 +2044,8 @@ function deserializeFormalParameters(pos) {
 
 function deserializeFormalParameter(pos) {
   let param,
-    hasInitializer = uint32[(pos + 64) >> 2] !== 0 && uint32[(pos + 68) >> 2] !== 0;
+    initializerFieldPos32 = (pos >> 2) + 16,
+    hasInitializer = int32[initializerFieldPos32] !== 0 && int32[initializerFieldPos32 + 1] !== 0;
   {
     let accessibility = deserializeOptionTSAccessibility(pos + 13),
       readonly = deserializeBool(pos + 14),
@@ -2095,8 +2061,8 @@ function deserializeFormalParameter(pos) {
           right: null,
           optional,
           typeAnnotation: null,
-          start: (start = deserializeU32(pos)),
-          end: (end = deserializeU32(pos + 4)),
+          start: (start = deserializeI32(pos)),
+          end: (end = deserializeI32(pos + 4)),
           range: [start, end],
         };
         param.decorators = deserializeVecDecorator(pos + 16);
@@ -2120,8 +2086,8 @@ function deserializeFormalParameter(pos) {
           param.end = typeAnnotation.end;
           param.range[1] = typeAnnotation.end;
         } else if (optional) {
-          param.end = deserializeU32(pos + 4);
-          param.range[1] = deserializeU32(pos + 4);
+          param.end = deserializeI32(pos + 4);
+          param.range[1] = deserializeI32(pos + 4);
         }
       }
     } else {
@@ -2134,8 +2100,8 @@ function deserializeFormalParameter(pos) {
         parameter: null,
         readonly,
         static: false,
-        start: (start = deserializeU32(pos)),
-        end: (end = deserializeU32(pos + 4)),
+        start: (start = deserializeI32(pos)),
+        end: (end = deserializeI32(pos + 4)),
         range: [start, end],
       };
       param.decorators = deserializeVecDecorator(pos + 16);
@@ -2177,7 +2143,7 @@ function deserializeFormalParameter(pos) {
           param.parameter.end = paramTypeAnnotation.end;
           param.parameter.range[1] = paramTypeAnnotation.end;
         } else if (paramOptional) {
-          let paramEnd = deserializeU32(pos + 4);
+          let paramEnd = deserializeI32(pos + 4);
           param.parameter.end = paramEnd;
           param.parameter.range[1] = paramEnd;
         }
@@ -2193,8 +2159,8 @@ function deserializeFunctionBody(pos) {
     node = {
       type: "BlockStatement",
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     body = deserializeVecDirective(pos + 16);
@@ -2216,9 +2182,9 @@ function deserializeArrowFunctionExpression(pos) {
       returnType: null,
       body: null,
       id: null,
-      generator: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      generator: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     body = deserializeBoxFunctionBody(pos + 40);
@@ -2227,7 +2193,6 @@ function deserializeArrowFunctionExpression(pos) {
   node.params = deserializeBoxFormalParameters(pos + 24);
   node.returnType = deserializeOptionBoxTSTypeAnnotation(pos + 32);
   node.body = body;
-  node.generator = false;
   return node;
 }
 
@@ -2238,8 +2203,8 @@ function deserializeYieldExpression(pos) {
       type: "YieldExpression",
       delegate: deserializeBool(pos + 12),
       argument: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.argument = deserializeOptionExpression(pos + 16);
@@ -2260,8 +2225,8 @@ function deserializeClass(pos) {
       body: null,
       abstract: deserializeBool(pos + 137),
       declare: deserializeBool(pos + 138),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.decorators = deserializeVecDecorator(pos + 16);
@@ -2291,8 +2256,8 @@ function deserializeClassBody(pos) {
     node = {
       type: "ClassBody",
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.body = deserializeVecClassElement(pos + 16);
@@ -2330,8 +2295,8 @@ function deserializeMethodDefinition(pos) {
       override: deserializeBool(pos + 64),
       optional: deserializeBool(pos + 65),
       accessibility: deserializeOptionTSAccessibility(pos + 66),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.decorators = deserializeVecDecorator(pos + 16);
@@ -2368,8 +2333,8 @@ function deserializePropertyDefinition(pos) {
       definite: deserializeBool(pos + 82),
       readonly: deserializeBool(pos + 83),
       accessibility: deserializeOptionTSAccessibility(pos + 84),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.decorators = deserializeVecDecorator(pos + 16);
@@ -2410,8 +2375,8 @@ function deserializePrivateIdentifier(pos) {
   return {
     type: "PrivateIdentifier",
     name: deserializeStr(pos + 16),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -2422,8 +2387,8 @@ function deserializeStaticBlock(pos) {
     node = {
       type: "StaticBlock",
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.body = deserializeVecStatement(pos + 16);
@@ -2455,20 +2420,17 @@ function deserializeAccessorProperty(pos) {
       override: deserializeBool(pos + 15),
       definite: deserializeBool(pos + 80),
       accessibility: deserializeOptionTSAccessibility(pos + 81),
-      declare: null,
-      optional: null,
-      readonly: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      declare: false,
+      optional: false,
+      readonly: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.decorators = deserializeVecDecorator(pos + 16);
   node.key = deserializePropertyKey(pos + 40);
   node.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 56);
   node.value = deserializeOptionExpression(pos + 64);
-  node.declare = false;
-  node.optional = false;
-  node.readonly = false;
   return node;
 }
 
@@ -2480,8 +2442,8 @@ function deserializeImportExpression(pos) {
       source: null,
       options: null,
       phase: deserializeOptionImportPhase(pos + 12),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.source = deserializeExpression(pos + 16);
@@ -2499,8 +2461,8 @@ function deserializeImportDeclaration(pos) {
       phase: deserializeOptionImportPhase(pos + 12),
       attributes: null,
       importKind: deserializeImportOrExportKind(pos + 13),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     specifiers = deserializeOptionVecImportDeclarationSpecifier(pos + 16);
@@ -2544,8 +2506,8 @@ function deserializeImportSpecifier(pos) {
       imported: null,
       local: null,
       importKind: deserializeImportOrExportKind(pos + 12),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.imported = deserializeModuleExportName(pos + 16);
@@ -2559,8 +2521,8 @@ function deserializeImportDefaultSpecifier(pos) {
     node = {
       type: "ImportDefaultSpecifier",
       local: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.local = deserializeBindingIdentifier(pos + 16);
@@ -2573,8 +2535,8 @@ function deserializeImportNamespaceSpecifier(pos) {
     node = {
       type: "ImportNamespaceSpecifier",
       local: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.local = deserializeBindingIdentifier(pos + 16);
@@ -2592,8 +2554,8 @@ function deserializeImportAttribute(pos) {
       type: "ImportAttribute",
       key: null,
       value: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.key = deserializeImportAttributeKey(pos + 16);
@@ -2622,8 +2584,8 @@ function deserializeExportNamedDeclaration(pos) {
       source: null,
       exportKind: deserializeImportOrExportKind(pos + 12),
       attributes: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     withClause = deserializeOptionBoxWithClause(pos + 104);
@@ -2640,13 +2602,12 @@ function deserializeExportDefaultDeclaration(pos) {
     node = {
       type: "ExportDefaultDeclaration",
       declaration: null,
-      exportKind: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      exportKind: "value",
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.declaration = deserializeExportDefaultDeclarationKind(pos + 16);
-  node.exportKind = "value";
   return node;
 }
 
@@ -2659,8 +2620,8 @@ function deserializeExportAllDeclaration(pos) {
       source: null,
       attributes: null,
       exportKind: deserializeImportOrExportKind(pos + 12),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     withClause = deserializeOptionBoxWithClause(pos + 120);
@@ -2678,8 +2639,8 @@ function deserializeExportSpecifier(pos) {
       local: null,
       exported: null,
       exportKind: deserializeImportOrExportKind(pos + 12),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.local = deserializeModuleExportName(pos + 16);
@@ -2806,8 +2767,8 @@ function deserializeV8IntrinsicExpression(pos) {
       type: "V8IntrinsicExpression",
       name: null,
       arguments: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.name = deserializeIdentifierName(pos + 16);
@@ -2817,8 +2778,8 @@ function deserializeV8IntrinsicExpression(pos) {
 
 function deserializeBooleanLiteral(pos) {
   let value = deserializeBool(pos + 12),
-    start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
+    start = deserializeI32(pos),
+    end = deserializeI32(pos + 4),
     node = {
       type: "Literal",
       value,
@@ -2832,41 +2793,46 @@ function deserializeBooleanLiteral(pos) {
 }
 
 function deserializeNullLiteral(pos) {
-  let start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
-    node = {
-      type: "Literal",
-      value: null,
-      raw: null,
-      start,
-      end,
-      range: [start, end],
-    };
-  node.raw = start === 0 && end === 0 ? null : "null";
-  return node;
+  let start = deserializeI32(pos),
+    end = deserializeI32(pos + 4);
+  return {
+    type: "Literal",
+    value: null,
+    raw: start === 0 && end === 0 ? null : "null",
+    start,
+    end,
+    range: [start, end],
+  };
 }
 
 function deserializeNumericLiteral(pos) {
-  let start, end;
+  let start = deserializeI32(pos),
+    end = deserializeI32(pos + 4);
   return {
     type: "Literal",
     value: deserializeF64(pos + 32),
-    raw: deserializeOptionStr(pos + 16),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    raw:
+      int32[(pos >> 2) + 4] === 0 && int32[(pos >> 2) + 5] === 0
+        ? null
+        : sourceText.slice(start, end),
+    start,
+    end,
     range: [start, end],
   };
 }
 
 function deserializeStringLiteral(pos) {
-  let start,
-    end,
+  let start = deserializeI32(pos),
+    end = deserializeI32(pos + 4),
     node = {
       type: "Literal",
       value: null,
-      raw: deserializeOptionStr(pos + 32),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      raw:
+        int32[(pos >> 2) + 8] === 0 && int32[(pos >> 2) + 9] === 0
+          ? null
+          : sourceText.slice(start, end),
+      start,
+      end,
       range: [start, end],
     },
     value = deserializeStr(pos + 16);
@@ -2877,33 +2843,36 @@ function deserializeStringLiteral(pos) {
 }
 
 function deserializeBigIntLiteral(pos) {
-  let start,
-    end,
-    node = {
-      type: "Literal",
-      value: null,
-      raw: deserializeOptionStr(pos + 32),
-      bigint: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
-      range: [start, end],
-    },
+  let start = deserializeI32(pos),
+    end = deserializeI32(pos + 4),
     bigint = deserializeStr(pos + 16);
-  node.value = BigInt(bigint);
-  node.bigint = bigint;
-  return node;
+  return {
+    type: "Literal",
+    value: BigInt(bigint),
+    raw:
+      int32[(pos >> 2) + 8] === 0 && int32[(pos >> 2) + 9] === 0
+        ? null
+        : sourceText.slice(start, end),
+    bigint,
+    start,
+    end,
+    range: [start, end],
+  };
 }
 
 function deserializeRegExpLiteral(pos) {
-  let start,
-    end,
+  let start = deserializeI32(pos),
+    end = deserializeI32(pos + 4),
     node = {
       type: "Literal",
       value: null,
-      raw: deserializeOptionStr(pos + 48),
+      raw:
+        int32[(pos >> 2) + 12] === 0 && int32[(pos >> 2) + 13] === 0
+          ? null
+          : sourceText.slice(start, end),
       regex: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start,
+      end,
       range: [start, end],
     },
     regex = deserializeRegExp(pos + 16),
@@ -2946,8 +2915,8 @@ function deserializeJSXElement(pos) {
       openingElement: null,
       children: null,
       closingElement: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     closingElement = deserializeOptionBoxJSXClosingElement(pos + 48),
@@ -2967,15 +2936,14 @@ function deserializeJSXOpeningElement(pos) {
       name: null,
       typeArguments: null,
       attributes: null,
-      selfClosing: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      selfClosing: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.name = deserializeJSXElementName(pos + 16);
   node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 32);
   node.attributes = deserializeVecJSXAttributeItem(pos + 40);
-  node.selfClosing = false;
   return node;
 }
 
@@ -2985,8 +2953,8 @@ function deserializeJSXClosingElement(pos) {
     node = {
       type: "JSXClosingElement",
       name: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.name = deserializeJSXElementName(pos + 16);
@@ -3001,8 +2969,8 @@ function deserializeJSXFragment(pos) {
       openingFragment: null,
       children: null,
       closingFragment: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.openingFragment = deserializeJSXOpeningFragment(pos + 16);
@@ -3015,8 +2983,8 @@ function deserializeJSXOpeningFragment(pos) {
   let start, end;
   return {
     type: "JSXOpeningFragment",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3025,8 +2993,8 @@ function deserializeJSXClosingFragment(pos) {
   let start, end;
   return {
     type: "JSXClosingFragment",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3069,8 +3037,8 @@ function deserializeJSXNamespacedName(pos) {
       type: "JSXNamespacedName",
       namespace: null,
       name: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.namespace = deserializeJSXIdentifier(pos + 16);
@@ -3085,8 +3053,8 @@ function deserializeJSXMemberExpression(pos) {
       type: "JSXMemberExpression",
       object: null,
       property: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.object = deserializeJSXMemberExpressionObject(pos + 16);
@@ -3127,8 +3095,8 @@ function deserializeJSXExpressionContainer(pos) {
     node = {
       type: "JSXExpressionContainer",
       expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeJSXExpression(pos + 16);
@@ -3234,8 +3202,8 @@ function deserializeJSXEmptyExpression(pos) {
   let start, end;
   return {
     type: "JSXEmptyExpression",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3258,8 +3226,8 @@ function deserializeJSXAttribute(pos) {
       type: "JSXAttribute",
       name: null,
       value: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.name = deserializeJSXAttributeName(pos + 16);
@@ -3273,8 +3241,8 @@ function deserializeJSXSpreadAttribute(pos) {
     node = {
       type: "JSXSpreadAttribute",
       argument: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.argument = deserializeExpression(pos + 16);
@@ -3312,8 +3280,8 @@ function deserializeJSXIdentifier(pos) {
   return {
     type: "JSXIdentifier",
     name: deserializeStr(pos + 16),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3341,8 +3309,8 @@ function deserializeJSXSpreadChild(pos) {
     node = {
       type: "JSXSpreadChild",
       expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeExpression(pos + 16);
@@ -3350,13 +3318,17 @@ function deserializeJSXSpreadChild(pos) {
 }
 
 function deserializeJSXText(pos) {
-  let start, end;
+  let start = deserializeI32(pos),
+    end = deserializeI32(pos + 4);
   return {
     type: "JSXText",
     value: deserializeStr(pos + 16),
-    raw: deserializeOptionStr(pos + 32),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    raw:
+      int32[(pos >> 2) + 8] === 0 && int32[(pos >> 2) + 9] === 0
+        ? null
+        : sourceText.slice(start, end),
+    start,
+    end,
     range: [start, end],
   };
 }
@@ -3366,17 +3338,14 @@ function deserializeTSThisParameter(pos) {
     end,
     node = {
       type: "Identifier",
-      decorators: null,
-      name: null,
-      optional: null,
+      decorators: [],
+      name: "this",
+      optional: false,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
-  node.decorators = [];
-  node.name = "this";
-  node.optional = false;
   node.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 24);
   return node;
 }
@@ -3390,8 +3359,8 @@ function deserializeTSEnumDeclaration(pos) {
       body: null,
       const: deserializeBool(pos + 12),
       declare: deserializeBool(pos + 13),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.id = deserializeBindingIdentifier(pos + 16);
@@ -3405,8 +3374,8 @@ function deserializeTSEnumBody(pos) {
     node = {
       type: "TSEnumBody",
       members: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.members = deserializeVecTSEnumMember(pos + 16);
@@ -3420,14 +3389,13 @@ function deserializeTSEnumMember(pos) {
       type: "TSEnumMember",
       id: null,
       initializer: null,
-      computed: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      computed: deserializeU8(pos + 16) > 1,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.id = deserializeTSEnumMemberName(pos + 16);
   node.initializer = deserializeOptionExpression(pos + 32);
-  node.computed = deserializeU8(pos + 16) > 1;
   return node;
 }
 
@@ -3452,8 +3420,8 @@ function deserializeTSTypeAnnotation(pos) {
     node = {
       type: "TSTypeAnnotation",
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeAnnotation = deserializeTSType(pos + 16);
@@ -3466,8 +3434,8 @@ function deserializeTSLiteralType(pos) {
     node = {
       type: "TSLiteralType",
       literal: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.literal = deserializeTSLiteral(pos + 16);
@@ -3583,8 +3551,8 @@ function deserializeTSConditionalType(pos) {
       extendsType: null,
       trueType: null,
       falseType: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.checkType = deserializeTSType(pos + 16);
@@ -3600,8 +3568,8 @@ function deserializeTSUnionType(pos) {
     node = {
       type: "TSUnionType",
       types: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.types = deserializeVecTSType(pos + 16);
@@ -3614,8 +3582,8 @@ function deserializeTSIntersectionType(pos) {
     node = {
       type: "TSIntersectionType",
       types: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.types = deserializeVecTSType(pos + 16);
@@ -3629,8 +3597,8 @@ function deserializeTSParenthesizedType(pos) {
     node = {
       type: "TSParenthesizedType",
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
     node.typeAnnotation = deserializeTSType(pos + 16);
@@ -3645,8 +3613,8 @@ function deserializeTSTypeOperator(pos) {
       type: "TSTypeOperator",
       operator: deserializeTSTypeOperatorOperator(pos + 12),
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeAnnotation = deserializeTSType(pos + 16);
@@ -3672,8 +3640,8 @@ function deserializeTSArrayType(pos) {
     node = {
       type: "TSArrayType",
       elementType: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.elementType = deserializeTSType(pos + 16);
@@ -3687,8 +3655,8 @@ function deserializeTSIndexedAccessType(pos) {
       type: "TSIndexedAccessType",
       objectType: null,
       indexType: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.objectType = deserializeTSType(pos + 16);
@@ -3702,8 +3670,8 @@ function deserializeTSTupleType(pos) {
     node = {
       type: "TSTupleType",
       elementTypes: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.elementTypes = deserializeVecTSTupleElement(pos + 16);
@@ -3718,8 +3686,8 @@ function deserializeTSNamedTupleMember(pos) {
       label: null,
       elementType: null,
       optional: deserializeBool(pos + 12),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.label = deserializeIdentifierName(pos + 16);
@@ -3733,8 +3701,8 @@ function deserializeTSOptionalType(pos) {
     node = {
       type: "TSOptionalType",
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeAnnotation = deserializeTSType(pos + 16);
@@ -3747,8 +3715,8 @@ function deserializeTSRestType(pos) {
     node = {
       type: "TSRestType",
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeAnnotation = deserializeTSType(pos + 16);
@@ -3844,8 +3812,8 @@ function deserializeTSAnyKeyword(pos) {
   let start, end;
   return {
     type: "TSAnyKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3854,8 +3822,8 @@ function deserializeTSStringKeyword(pos) {
   let start, end;
   return {
     type: "TSStringKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3864,8 +3832,8 @@ function deserializeTSBooleanKeyword(pos) {
   let start, end;
   return {
     type: "TSBooleanKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3874,8 +3842,8 @@ function deserializeTSNumberKeyword(pos) {
   let start, end;
   return {
     type: "TSNumberKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3884,8 +3852,8 @@ function deserializeTSNeverKeyword(pos) {
   let start, end;
   return {
     type: "TSNeverKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3894,8 +3862,8 @@ function deserializeTSIntrinsicKeyword(pos) {
   let start, end;
   return {
     type: "TSIntrinsicKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3904,8 +3872,8 @@ function deserializeTSUnknownKeyword(pos) {
   let start, end;
   return {
     type: "TSUnknownKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3914,8 +3882,8 @@ function deserializeTSNullKeyword(pos) {
   let start, end;
   return {
     type: "TSNullKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3924,8 +3892,8 @@ function deserializeTSUndefinedKeyword(pos) {
   let start, end;
   return {
     type: "TSUndefinedKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3934,8 +3902,8 @@ function deserializeTSVoidKeyword(pos) {
   let start, end;
   return {
     type: "TSVoidKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3944,8 +3912,8 @@ function deserializeTSSymbolKeyword(pos) {
   let start, end;
   return {
     type: "TSSymbolKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3954,8 +3922,8 @@ function deserializeTSThisType(pos) {
   let start, end;
   return {
     type: "TSThisType",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3964,8 +3932,8 @@ function deserializeTSObjectKeyword(pos) {
   let start, end;
   return {
     type: "TSObjectKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3974,8 +3942,8 @@ function deserializeTSBigIntKeyword(pos) {
   let start, end;
   return {
     type: "TSBigIntKeyword",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -3987,8 +3955,8 @@ function deserializeTSTypeReference(pos) {
       type: "TSTypeReference",
       typeName: null,
       typeArguments: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeName = deserializeTSTypeName(pos + 16);
@@ -4016,8 +3984,8 @@ function deserializeTSQualifiedName(pos) {
       type: "TSQualifiedName",
       left: null,
       right: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.left = deserializeTSTypeName(pos + 16);
@@ -4031,8 +3999,8 @@ function deserializeTSTypeParameterInstantiation(pos) {
     node = {
       type: "TSTypeParameterInstantiation",
       params: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.params = deserializeVecTSType(pos + 16);
@@ -4050,8 +4018,8 @@ function deserializeTSTypeParameter(pos) {
       in: deserializeBool(pos + 12),
       out: deserializeBool(pos + 13),
       const: deserializeBool(pos + 14),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.name = deserializeBindingIdentifier(pos + 16);
@@ -4066,8 +4034,8 @@ function deserializeTSTypeParameterDeclaration(pos) {
     node = {
       type: "TSTypeParameterDeclaration",
       params: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.params = deserializeVecTSTypeParameter(pos + 16);
@@ -4083,8 +4051,8 @@ function deserializeTSTypeAliasDeclaration(pos) {
       typeParameters: null,
       typeAnnotation: null,
       declare: deserializeBool(pos + 72),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.id = deserializeBindingIdentifier(pos + 16);
@@ -4113,8 +4081,8 @@ function deserializeTSClassImplements(pos) {
       type: "TSClassImplements",
       expression: null,
       typeArguments: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     expression = deserializeTSTypeName(pos + 16);
@@ -4163,8 +4131,8 @@ function deserializeTSInterfaceDeclaration(pos) {
       extends: null,
       body: null,
       declare: deserializeBool(pos + 88),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.id = deserializeBindingIdentifier(pos + 16);
@@ -4180,8 +4148,8 @@ function deserializeTSInterfaceBody(pos) {
     node = {
       type: "TSInterfaceBody",
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.body = deserializeVecTSSignature(pos + 16);
@@ -4199,14 +4167,13 @@ function deserializeTSPropertySignature(pos) {
       key: null,
       typeAnnotation: null,
       accessibility: null,
-      static: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      static: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.key = deserializePropertyKey(pos + 16);
   node.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 32);
-  node.static = false;
   return node;
 }
 
@@ -4237,8 +4204,8 @@ function deserializeTSIndexSignature(pos) {
       readonly: deserializeBool(pos + 12),
       static: deserializeBool(pos + 13),
       accessibility: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.parameters = deserializeVecTSIndexSignatureName(pos + 16);
@@ -4254,8 +4221,8 @@ function deserializeTSCallSignatureDeclaration(pos) {
       typeParameters: null,
       params: null,
       returnType: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     params = deserializeBoxFormalParameters(pos + 32),
@@ -4293,10 +4260,10 @@ function deserializeTSMethodSignature(pos) {
       params: null,
       returnType: null,
       accessibility: null,
-      readonly: null,
-      static: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      readonly: false,
+      static: false,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     params = deserializeBoxFormalParameters(pos + 48),
@@ -4306,8 +4273,6 @@ function deserializeTSMethodSignature(pos) {
   node.typeParameters = deserializeOptionBoxTSTypeParameterDeclaration(pos + 32);
   node.params = params;
   node.returnType = deserializeOptionBoxTSTypeAnnotation(pos + 56);
-  node.readonly = false;
-  node.static = false;
   return node;
 }
 
@@ -4319,8 +4284,8 @@ function deserializeTSConstructSignatureDeclaration(pos) {
       typeParameters: null,
       params: null,
       returnType: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeParameters = deserializeOptionBoxTSTypeParameterDeclaration(pos + 16);
@@ -4334,16 +4299,14 @@ function deserializeTSIndexSignatureName(pos) {
     end,
     node = {
       type: "Identifier",
-      decorators: null,
+      decorators: [],
       name: deserializeStr(pos + 16),
-      optional: null,
+      optional: false,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
-  node.decorators = [];
-  node.optional = false;
   node.typeAnnotation = deserializeBoxTSTypeAnnotation(pos + 32);
   return node;
 }
@@ -4355,8 +4318,8 @@ function deserializeTSInterfaceHeritage(pos) {
       type: "TSInterfaceHeritage",
       expression: null,
       typeArguments: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeExpression(pos + 16);
@@ -4372,8 +4335,8 @@ function deserializeTSTypePredicate(pos) {
       parameterName: null,
       asserts: deserializeBool(pos + 12),
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.parameterName = deserializeTSTypePredicateName(pos + 16);
@@ -4394,8 +4357,8 @@ function deserializeTSTypePredicateName(pos) {
 
 function deserializeTSModuleDeclaration(pos) {
   let kind = deserializeTSModuleDeclarationKind(pos + 88),
-    start = deserializeU32(pos),
-    end = deserializeU32(pos + 4),
+    start = deserializeI32(pos),
+    end = deserializeI32(pos + 4),
     declare = deserializeBool(pos + 89),
     node,
     body = deserializeOptionTSModuleDeclarationBody(pos + 72);
@@ -4507,11 +4470,11 @@ function deserializeTSGlobalDeclaration(pos) {
       type: "TSModuleDeclaration",
       id: null,
       body: null,
-      kind: null,
+      kind: "global",
       declare: deserializeBool(pos + 88),
-      global: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      global: true,
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     keywordStart,
@@ -4522,13 +4485,11 @@ function deserializeTSGlobalDeclaration(pos) {
     name: "global",
     optional: false,
     typeAnnotation: null,
-    start: (keywordStart = deserializeU32(pos + 16)),
-    end: (keywordEnd = deserializeU32(pos + 20)),
+    start: (keywordStart = deserializeI32(pos + 16)),
+    end: (keywordEnd = deserializeI32(pos + 20)),
     range: [keywordStart, keywordEnd],
   };
   node.body = deserializeTSModuleBlock(pos + 24);
-  node.kind = "global";
-  node.global = true;
   return node;
 }
 
@@ -4538,8 +4499,8 @@ function deserializeTSModuleBlock(pos) {
     node = {
       type: "TSModuleBlock",
       body: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     body = deserializeVecDirective(pos + 16);
@@ -4554,8 +4515,8 @@ function deserializeTSTypeLiteral(pos) {
     node = {
       type: "TSTypeLiteral",
       members: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.members = deserializeVecTSSignature(pos + 16);
@@ -4568,8 +4529,8 @@ function deserializeTSInferType(pos) {
     node = {
       type: "TSInferType",
       typeParameter: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeParameter = deserializeBoxTSTypeParameter(pos + 16);
@@ -4583,8 +4544,8 @@ function deserializeTSTypeQuery(pos) {
       type: "TSTypeQuery",
       exprName: null,
       typeArguments: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.exprName = deserializeTSTypeQueryExprName(pos + 16);
@@ -4616,8 +4577,8 @@ function deserializeTSImportType(pos) {
       options: null,
       qualifier: null,
       typeArguments: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.source = deserializeStringLiteral(pos + 16);
@@ -4645,8 +4606,8 @@ function deserializeTSImportTypeQualifiedName(pos) {
       type: "TSQualifiedName",
       left: null,
       right: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.left = deserializeTSImportTypeQualifier(pos + 16);
@@ -4662,8 +4623,8 @@ function deserializeTSFunctionType(pos) {
       typeParameters: null,
       params: null,
       returnType: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     params = deserializeBoxFormalParameters(pos + 32),
@@ -4684,8 +4645,8 @@ function deserializeTSConstructorType(pos) {
       typeParameters: null,
       params: null,
       returnType: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeParameters = deserializeOptionBoxTSTypeParameterDeclaration(pos + 16);
@@ -4705,8 +4666,8 @@ function deserializeTSMappedType(pos) {
       typeAnnotation: null,
       optional: null,
       readonly: deserializeOptionTSMappedTypeModifierOperator(pos + 97),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     },
     optional = deserializeOptionTSMappedTypeModifierOperator(pos + 96);
@@ -4739,8 +4700,8 @@ function deserializeTSTemplateLiteralType(pos) {
       type: "TSTemplateLiteralType",
       quasis: null,
       types: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.quasis = deserializeVecTemplateElement(pos + 16);
@@ -4755,8 +4716,8 @@ function deserializeTSAsExpression(pos) {
       type: "TSAsExpression",
       expression: null,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeExpression(pos + 16);
@@ -4771,8 +4732,8 @@ function deserializeTSSatisfiesExpression(pos) {
       type: "TSSatisfiesExpression",
       expression: null,
       typeAnnotation: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeExpression(pos + 16);
@@ -4787,8 +4748,8 @@ function deserializeTSTypeAssertion(pos) {
       type: "TSTypeAssertion",
       typeAnnotation: null,
       expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeAnnotation = deserializeTSType(pos + 16);
@@ -4804,8 +4765,8 @@ function deserializeTSImportEqualsDeclaration(pos) {
       id: null,
       moduleReference: null,
       importKind: deserializeImportOrExportKind(pos + 12),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.id = deserializeBindingIdentifier(pos + 16);
@@ -4832,8 +4793,8 @@ function deserializeTSExternalModuleReference(pos) {
     node = {
       type: "TSExternalModuleReference",
       expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeStringLiteral(pos + 16);
@@ -4846,8 +4807,8 @@ function deserializeTSNonNullExpression(pos) {
     node = {
       type: "TSNonNullExpression",
       expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeExpression(pos + 16);
@@ -4860,8 +4821,8 @@ function deserializeDecorator(pos) {
     node = {
       type: "Decorator",
       expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeExpression(pos + 16);
@@ -4874,8 +4835,8 @@ function deserializeTSExportAssignment(pos) {
     node = {
       type: "TSExportAssignment",
       expression: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeExpression(pos + 16);
@@ -4888,8 +4849,8 @@ function deserializeTSNamespaceExportDeclaration(pos) {
     node = {
       type: "TSNamespaceExportDeclaration",
       id: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.id = deserializeIdentifierName(pos + 16);
@@ -4903,8 +4864,8 @@ function deserializeTSInstantiationExpression(pos) {
       type: "TSInstantiationExpression",
       expression: null,
       typeArguments: null,
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.expression = deserializeExpression(pos + 16);
@@ -4930,8 +4891,8 @@ function deserializeJSDocNullableType(pos) {
       type: "TSJSDocNullableType",
       typeAnnotation: null,
       postfix: deserializeBool(pos + 12),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeAnnotation = deserializeTSType(pos + 16);
@@ -4945,8 +4906,8 @@ function deserializeJSDocNonNullableType(pos) {
       type: "TSJSDocNonNullableType",
       typeAnnotation: null,
       postfix: deserializeBool(pos + 12),
-      start: (start = deserializeU32(pos)),
-      end: (end = deserializeU32(pos + 4)),
+      start: (start = deserializeI32(pos)),
+      end: (end = deserializeI32(pos + 4)),
       range: [start, end],
     };
   node.typeAnnotation = deserializeTSType(pos + 16);
@@ -4957,8 +4918,8 @@ function deserializeJSDocUnknownType(pos) {
   let start, end;
   return {
     type: "TSJSDocUnknownType",
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -4978,8 +4939,8 @@ function deserializeCommentKind(pos) {
 
 function deserializeComment(pos) {
   let type = deserializeCommentKind(pos + 12),
-    start = deserializeU32(pos),
-    end = deserializeU32(pos + 4);
+    start = deserializeI32(pos),
+    end = deserializeI32(pos + 4);
   return {
     type,
     value: sourceText.slice(start + 2, end - (type === "Line" ? 0 : 2)),
@@ -5004,8 +4965,8 @@ function deserializeModuleKind(pos) {
 
 function deserializeSpan(pos) {
   return {
-    start: deserializeU32(pos),
-    end: deserializeU32(pos + 4),
+    start: deserializeI32(pos),
+    end: deserializeI32(pos + 4),
   };
 }
 
@@ -5013,8 +4974,8 @@ function deserializeNameSpan(pos) {
   let start, end;
   return {
     value: deserializeStr(pos + 8),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -5068,8 +5029,8 @@ function deserializeExportEntry(pos) {
     exportName: deserializeExportExportName(pos + 72),
     localName: deserializeExportLocalName(pos + 104),
     isType: deserializeBool(pos + 136),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -5184,8 +5145,8 @@ function deserializeDynamicImport(pos) {
   let start, end;
   return {
     moduleRequest: deserializeSpan(pos + 8),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -5361,8 +5322,8 @@ function deserializeErrorLabel(pos) {
   let start, end;
   return {
     message: deserializeOptionStr(pos + 8),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -5382,8 +5343,8 @@ function deserializeStaticImport(pos) {
   return {
     moduleRequest: deserializeNameSpan(pos + 8),
     entries: deserializeVecImportEntry(pos + 32),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
@@ -5392,41 +5353,45 @@ function deserializeStaticExport(pos) {
   let start, end;
   return {
     entries: deserializeVecExportEntry(pos + 8),
-    start: (start = deserializeU32(pos)),
-    end: (end = deserializeU32(pos + 4)),
+    start: (start = deserializeI32(pos)),
+    end: (end = deserializeI32(pos + 4)),
     range: [start, end],
   };
 }
 
 function deserializeStr(pos) {
   let pos32 = pos >> 2,
-    len = uint32[pos32 + 2];
+    len = int32[pos32 + 2];
   if (len === 0) return "";
-  pos = uint32[pos32];
-  if (sourceIsAscii && pos < sourceEndPos) return sourceText.substr(pos, len);
-  // Longer strings use `TextDecoder`
-  // TODO: Find best switch-over point
+  pos = int32[pos32];
   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;
-  do {
-    c = uint8[pos++];
-    if (c < 128) out += fromCodePoint(c);
-    else {
-      out += decodeStr(uint8.subarray(pos - 1, end));
-      break;
-    }
-  } while (pos < end);
-  return out;
+  if (end <= firstNonAsciiPos) return sourceTextLatin.substr(pos, len);
+  // Use `utf8Slice` for strings longer than 64 bytes
+  if (len > 64) return utf8Slice.call(uint8, pos, end);
+  if (pos < sourceEndPos) {
+    // Check if all bytes are ASCII, use `utf8Slice` if not
+    for (let i = pos; i < end; i++) if (uint8[i] >= 128) return utf8Slice.call(uint8, pos, end);
+    // String is all ASCII, so slice from `sourceTextLatin`
+    return sourceTextLatin.substr(pos, len);
+  }
+  // String is not in source region - use `fromCharCode.apply` with a temp array of correct length.
+  // Copy bytes into temp array.
+  // If any byte is non-ASCII, use `utf8Slice`.
+  let arr = stringDecodeArrays[len];
+  for (let i = 0; i < len; i++) {
+    let b = uint8[pos + i];
+    if (b >= 128) return utf8Slice.call(uint8, pos, end);
+    arr[i] = b;
+  }
+  // Call `fromCharCode` with temp array
+  return fromCharCode.apply(null, arr);
 }
 
 function deserializeVecComment(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeComment(pos));
     pos += 16;
@@ -5435,15 +5400,16 @@ function deserializeVecComment(pos) {
 }
 
 function deserializeOptionHashbang(pos) {
-  if (uint32[(pos + 16) >> 2] === 0 && uint32[(pos + 20) >> 2] === 0) return null;
-  return deserializeHashbang(pos);
+  return int32[(pos >> 2) + 4] === 0 && int32[(pos >> 2) + 5] === 0
+    ? null
+    : deserializeHashbang(pos);
 }
 
 function deserializeVecDirective(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 80;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 80;
   for (; pos !== endPos; ) {
     arr.push(deserializeDirective(pos));
     pos += 80;
@@ -5454,8 +5420,8 @@ function deserializeVecDirective(pos) {
 function deserializeVecStatement(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeStatement(pos));
     pos += 16;
@@ -5464,170 +5430,170 @@ function deserializeVecStatement(pos) {
 }
 
 function deserializeBoxBooleanLiteral(pos) {
-  return deserializeBooleanLiteral(uint32[pos >> 2]);
+  return deserializeBooleanLiteral(int32[pos >> 2]);
 }
 
 function deserializeBoxNullLiteral(pos) {
-  return deserializeNullLiteral(uint32[pos >> 2]);
+  return deserializeNullLiteral(int32[pos >> 2]);
 }
 
 function deserializeBoxNumericLiteral(pos) {
-  return deserializeNumericLiteral(uint32[pos >> 2]);
+  return deserializeNumericLiteral(int32[pos >> 2]);
 }
 
 function deserializeBoxBigIntLiteral(pos) {
-  return deserializeBigIntLiteral(uint32[pos >> 2]);
+  return deserializeBigIntLiteral(int32[pos >> 2]);
 }
 
 function deserializeBoxRegExpLiteral(pos) {
-  return deserializeRegExpLiteral(uint32[pos >> 2]);
+  return deserializeRegExpLiteral(int32[pos >> 2]);
 }
 
 function deserializeBoxStringLiteral(pos) {
-  return deserializeStringLiteral(uint32[pos >> 2]);
+  return deserializeStringLiteral(int32[pos >> 2]);
 }
 
 function deserializeBoxTemplateLiteral(pos) {
-  return deserializeTemplateLiteral(uint32[pos >> 2]);
+  return deserializeTemplateLiteral(int32[pos >> 2]);
 }
 
 function deserializeBoxIdentifierReference(pos) {
-  return deserializeIdentifierReference(uint32[pos >> 2]);
+  return deserializeIdentifierReference(int32[pos >> 2]);
 }
 
 function deserializeBoxMetaProperty(pos) {
-  return deserializeMetaProperty(uint32[pos >> 2]);
+  return deserializeMetaProperty(int32[pos >> 2]);
 }
 
 function deserializeBoxSuper(pos) {
-  return deserializeSuper(uint32[pos >> 2]);
+  return deserializeSuper(int32[pos >> 2]);
 }
 
 function deserializeBoxArrayExpression(pos) {
-  return deserializeArrayExpression(uint32[pos >> 2]);
+  return deserializeArrayExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxArrowFunctionExpression(pos) {
-  return deserializeArrowFunctionExpression(uint32[pos >> 2]);
+  return deserializeArrowFunctionExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxAssignmentExpression(pos) {
-  return deserializeAssignmentExpression(uint32[pos >> 2]);
+  return deserializeAssignmentExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxAwaitExpression(pos) {
-  return deserializeAwaitExpression(uint32[pos >> 2]);
+  return deserializeAwaitExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxBinaryExpression(pos) {
-  return deserializeBinaryExpression(uint32[pos >> 2]);
+  return deserializeBinaryExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxCallExpression(pos) {
-  return deserializeCallExpression(uint32[pos >> 2]);
+  return deserializeCallExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxChainExpression(pos) {
-  return deserializeChainExpression(uint32[pos >> 2]);
+  return deserializeChainExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxClass(pos) {
-  return deserializeClass(uint32[pos >> 2]);
+  return deserializeClass(int32[pos >> 2]);
 }
 
 function deserializeBoxConditionalExpression(pos) {
-  return deserializeConditionalExpression(uint32[pos >> 2]);
+  return deserializeConditionalExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxFunction(pos) {
-  return deserializeFunction(uint32[pos >> 2]);
+  return deserializeFunction(int32[pos >> 2]);
 }
 
 function deserializeBoxImportExpression(pos) {
-  return deserializeImportExpression(uint32[pos >> 2]);
+  return deserializeImportExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxLogicalExpression(pos) {
-  return deserializeLogicalExpression(uint32[pos >> 2]);
+  return deserializeLogicalExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxNewExpression(pos) {
-  return deserializeNewExpression(uint32[pos >> 2]);
+  return deserializeNewExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxObjectExpression(pos) {
-  return deserializeObjectExpression(uint32[pos >> 2]);
+  return deserializeObjectExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxParenthesizedExpression(pos) {
-  return deserializeParenthesizedExpression(uint32[pos >> 2]);
+  return deserializeParenthesizedExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxSequenceExpression(pos) {
-  return deserializeSequenceExpression(uint32[pos >> 2]);
+  return deserializeSequenceExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxTaggedTemplateExpression(pos) {
-  return deserializeTaggedTemplateExpression(uint32[pos >> 2]);
+  return deserializeTaggedTemplateExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxThisExpression(pos) {
-  return deserializeThisExpression(uint32[pos >> 2]);
+  return deserializeThisExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxUnaryExpression(pos) {
-  return deserializeUnaryExpression(uint32[pos >> 2]);
+  return deserializeUnaryExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxUpdateExpression(pos) {
-  return deserializeUpdateExpression(uint32[pos >> 2]);
+  return deserializeUpdateExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxYieldExpression(pos) {
-  return deserializeYieldExpression(uint32[pos >> 2]);
+  return deserializeYieldExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxPrivateInExpression(pos) {
-  return deserializePrivateInExpression(uint32[pos >> 2]);
+  return deserializePrivateInExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxJSXElement(pos) {
-  return deserializeJSXElement(uint32[pos >> 2]);
+  return deserializeJSXElement(int32[pos >> 2]);
 }
 
 function deserializeBoxJSXFragment(pos) {
-  return deserializeJSXFragment(uint32[pos >> 2]);
+  return deserializeJSXFragment(int32[pos >> 2]);
 }
 
 function deserializeBoxTSAsExpression(pos) {
-  return deserializeTSAsExpression(uint32[pos >> 2]);
+  return deserializeTSAsExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxTSSatisfiesExpression(pos) {
-  return deserializeTSSatisfiesExpression(uint32[pos >> 2]);
+  return deserializeTSSatisfiesExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTypeAssertion(pos) {
-  return deserializeTSTypeAssertion(uint32[pos >> 2]);
+  return deserializeTSTypeAssertion(int32[pos >> 2]);
 }
 
 function deserializeBoxTSNonNullExpression(pos) {
-  return deserializeTSNonNullExpression(uint32[pos >> 2]);
+  return deserializeTSNonNullExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxTSInstantiationExpression(pos) {
-  return deserializeTSInstantiationExpression(uint32[pos >> 2]);
+  return deserializeTSInstantiationExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxV8IntrinsicExpression(pos) {
-  return deserializeV8IntrinsicExpression(uint32[pos >> 2]);
+  return deserializeV8IntrinsicExpression(int32[pos >> 2]);
 }
 
 function deserializeVecArrayExpressionElement(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 24;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 24;
   for (; pos !== endPos; ) {
     arr.push(deserializeArrayExpressionElement(pos));
     pos += 24;
@@ -5636,14 +5602,14 @@ function deserializeVecArrayExpressionElement(pos) {
 }
 
 function deserializeBoxSpreadElement(pos) {
-  return deserializeSpreadElement(uint32[pos >> 2]);
+  return deserializeSpreadElement(int32[pos >> 2]);
 }
 
 function deserializeVecObjectPropertyKind(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeObjectPropertyKind(pos));
     pos += 16;
@@ -5652,7 +5618,7 @@ function deserializeVecObjectPropertyKind(pos) {
 }
 
 function deserializeBoxObjectProperty(pos) {
-  return deserializeObjectProperty(uint32[pos >> 2]);
+  return deserializeObjectProperty(int32[pos >> 2]);
 }
 
 function deserializeBool(pos) {
@@ -5660,18 +5626,18 @@ function deserializeBool(pos) {
 }
 
 function deserializeBoxIdentifierName(pos) {
-  return deserializeIdentifierName(uint32[pos >> 2]);
+  return deserializeIdentifierName(int32[pos >> 2]);
 }
 
 function deserializeBoxPrivateIdentifier(pos) {
-  return deserializePrivateIdentifier(uint32[pos >> 2]);
+  return deserializePrivateIdentifier(int32[pos >> 2]);
 }
 
 function deserializeVecTemplateElement(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 48;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 48;
   for (; pos !== endPos; ) {
     arr.push(deserializeTemplateElement(pos));
     pos += 48;
@@ -5682,8 +5648,8 @@ function deserializeVecTemplateElement(pos) {
 function deserializeVecExpression(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeExpression(pos));
     pos += 16;
@@ -5692,36 +5658,36 @@ function deserializeVecExpression(pos) {
 }
 
 function deserializeBoxTSTypeParameterInstantiation(pos) {
-  return deserializeTSTypeParameterInstantiation(uint32[pos >> 2]);
+  return deserializeTSTypeParameterInstantiation(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxTSTypeParameterInstantiation(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxTSTypeParameterInstantiation(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxTSTypeParameterInstantiation(pos);
 }
 
 function deserializeOptionStr(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeStr(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0 ? null : deserializeStr(pos);
 }
 
 function deserializeBoxComputedMemberExpression(pos) {
-  return deserializeComputedMemberExpression(uint32[pos >> 2]);
+  return deserializeComputedMemberExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxStaticMemberExpression(pos) {
-  return deserializeStaticMemberExpression(uint32[pos >> 2]);
+  return deserializeStaticMemberExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxPrivateFieldExpression(pos) {
-  return deserializePrivateFieldExpression(uint32[pos >> 2]);
+  return deserializePrivateFieldExpression(int32[pos >> 2]);
 }
 
 function deserializeVecArgument(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeArgument(pos));
     pos += 16;
@@ -5730,23 +5696,22 @@ function deserializeVecArgument(pos) {
 }
 
 function deserializeBoxArrayAssignmentTarget(pos) {
-  return deserializeArrayAssignmentTarget(uint32[pos >> 2]);
+  return deserializeArrayAssignmentTarget(int32[pos >> 2]);
 }
 
 function deserializeBoxObjectAssignmentTarget(pos) {
-  return deserializeObjectAssignmentTarget(uint32[pos >> 2]);
+  return deserializeObjectAssignmentTarget(int32[pos >> 2]);
 }
 
 function deserializeOptionAssignmentTargetMaybeDefault(pos) {
-  if (uint8[pos] === 51) return null;
-  return deserializeAssignmentTargetMaybeDefault(pos);
+  return uint8[pos] === 51 ? null : deserializeAssignmentTargetMaybeDefault(pos);
 }
 
 function deserializeVecOptionAssignmentTargetMaybeDefault(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeOptionAssignmentTargetMaybeDefault(pos));
     pos += 16;
@@ -5755,19 +5720,20 @@ function deserializeVecOptionAssignmentTargetMaybeDefault(pos) {
 }
 
 function deserializeBoxAssignmentTargetRest(pos) {
-  return deserializeAssignmentTargetRest(uint32[pos >> 2]);
+  return deserializeAssignmentTargetRest(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxAssignmentTargetRest(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxAssignmentTargetRest(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxAssignmentTargetRest(pos);
 }
 
 function deserializeVecAssignmentTargetProperty(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeAssignmentTargetProperty(pos));
     pos += 16;
@@ -5776,127 +5742,126 @@ function deserializeVecAssignmentTargetProperty(pos) {
 }
 
 function deserializeBoxAssignmentTargetWithDefault(pos) {
-  return deserializeAssignmentTargetWithDefault(uint32[pos >> 2]);
+  return deserializeAssignmentTargetWithDefault(int32[pos >> 2]);
 }
 
 function deserializeBoxAssignmentTargetPropertyIdentifier(pos) {
-  return deserializeAssignmentTargetPropertyIdentifier(uint32[pos >> 2]);
+  return deserializeAssignmentTargetPropertyIdentifier(int32[pos >> 2]);
 }
 
 function deserializeBoxAssignmentTargetPropertyProperty(pos) {
-  return deserializeAssignmentTargetPropertyProperty(uint32[pos >> 2]);
+  return deserializeAssignmentTargetPropertyProperty(int32[pos >> 2]);
 }
 
 function deserializeOptionExpression(pos) {
-  if (uint8[pos] === 51) return null;
-  return deserializeExpression(pos);
+  return uint8[pos] === 51 ? null : deserializeExpression(pos);
 }
 
 function deserializeBoxBlockStatement(pos) {
-  return deserializeBlockStatement(uint32[pos >> 2]);
+  return deserializeBlockStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxBreakStatement(pos) {
-  return deserializeBreakStatement(uint32[pos >> 2]);
+  return deserializeBreakStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxContinueStatement(pos) {
-  return deserializeContinueStatement(uint32[pos >> 2]);
+  return deserializeContinueStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxDebuggerStatement(pos) {
-  return deserializeDebuggerStatement(uint32[pos >> 2]);
+  return deserializeDebuggerStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxDoWhileStatement(pos) {
-  return deserializeDoWhileStatement(uint32[pos >> 2]);
+  return deserializeDoWhileStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxEmptyStatement(pos) {
-  return deserializeEmptyStatement(uint32[pos >> 2]);
+  return deserializeEmptyStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxExpressionStatement(pos) {
-  return deserializeExpressionStatement(uint32[pos >> 2]);
+  return deserializeExpressionStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxForInStatement(pos) {
-  return deserializeForInStatement(uint32[pos >> 2]);
+  return deserializeForInStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxForOfStatement(pos) {
-  return deserializeForOfStatement(uint32[pos >> 2]);
+  return deserializeForOfStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxForStatement(pos) {
-  return deserializeForStatement(uint32[pos >> 2]);
+  return deserializeForStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxIfStatement(pos) {
-  return deserializeIfStatement(uint32[pos >> 2]);
+  return deserializeIfStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxLabeledStatement(pos) {
-  return deserializeLabeledStatement(uint32[pos >> 2]);
+  return deserializeLabeledStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxReturnStatement(pos) {
-  return deserializeReturnStatement(uint32[pos >> 2]);
+  return deserializeReturnStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxSwitchStatement(pos) {
-  return deserializeSwitchStatement(uint32[pos >> 2]);
+  return deserializeSwitchStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxThrowStatement(pos) {
-  return deserializeThrowStatement(uint32[pos >> 2]);
+  return deserializeThrowStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxTryStatement(pos) {
-  return deserializeTryStatement(uint32[pos >> 2]);
+  return deserializeTryStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxWhileStatement(pos) {
-  return deserializeWhileStatement(uint32[pos >> 2]);
+  return deserializeWhileStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxWithStatement(pos) {
-  return deserializeWithStatement(uint32[pos >> 2]);
+  return deserializeWithStatement(int32[pos >> 2]);
 }
 
 function deserializeBoxVariableDeclaration(pos) {
-  return deserializeVariableDeclaration(uint32[pos >> 2]);
+  return deserializeVariableDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTypeAliasDeclaration(pos) {
-  return deserializeTSTypeAliasDeclaration(uint32[pos >> 2]);
+  return deserializeTSTypeAliasDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxTSInterfaceDeclaration(pos) {
-  return deserializeTSInterfaceDeclaration(uint32[pos >> 2]);
+  return deserializeTSInterfaceDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxTSEnumDeclaration(pos) {
-  return deserializeTSEnumDeclaration(uint32[pos >> 2]);
+  return deserializeTSEnumDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxTSModuleDeclaration(pos) {
-  return deserializeTSModuleDeclaration(uint32[pos >> 2]);
+  return deserializeTSModuleDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxTSGlobalDeclaration(pos) {
-  return deserializeTSGlobalDeclaration(uint32[pos >> 2]);
+  return deserializeTSGlobalDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxTSImportEqualsDeclaration(pos) {
-  return deserializeTSImportEqualsDeclaration(uint32[pos >> 2]);
+  return deserializeTSImportEqualsDeclaration(int32[pos >> 2]);
 }
 
 function deserializeVecVariableDeclarator(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 56;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 56;
   for (; pos !== endPos; ) {
     arr.push(deserializeVariableDeclarator(pos));
     pos += 56;
@@ -5905,34 +5870,34 @@ function deserializeVecVariableDeclarator(pos) {
 }
 
 function deserializeBoxTSTypeAnnotation(pos) {
-  return deserializeTSTypeAnnotation(uint32[pos >> 2]);
+  return deserializeTSTypeAnnotation(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxTSTypeAnnotation(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxTSTypeAnnotation(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxTSTypeAnnotation(pos);
 }
 
 function deserializeOptionStatement(pos) {
-  if (uint8[pos] === 70) return null;
-  return deserializeStatement(pos);
+  return uint8[pos] === 70 ? null : deserializeStatement(pos);
 }
 
 function deserializeOptionForStatementInit(pos) {
-  if (uint8[pos] === 65) return null;
-  return deserializeForStatementInit(pos);
+  return uint8[pos] === 65 ? null : deserializeForStatementInit(pos);
 }
 
 function deserializeOptionLabelIdentifier(pos) {
-  if (uint32[(pos + 16) >> 2] === 0 && uint32[(pos + 20) >> 2] === 0) return null;
-  return deserializeLabelIdentifier(pos);
+  return int32[(pos >> 2) + 4] === 0 && int32[(pos >> 2) + 5] === 0
+    ? null
+    : deserializeLabelIdentifier(pos);
 }
 
 function deserializeVecSwitchCase(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 56;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 56;
   for (; pos !== endPos; ) {
     arr.push(deserializeSwitchCase(pos));
     pos += 56;
@@ -5941,45 +5906,46 @@ function deserializeVecSwitchCase(pos) {
 }
 
 function deserializeBoxCatchClause(pos) {
-  return deserializeCatchClause(uint32[pos >> 2]);
+  return deserializeCatchClause(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxCatchClause(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxCatchClause(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxCatchClause(pos);
 }
 
 function deserializeOptionBoxBlockStatement(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxBlockStatement(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxBlockStatement(pos);
 }
 
 function deserializeOptionCatchParameter(pos) {
-  if (uint8[pos + 16] === 4) return null;
-  return deserializeCatchParameter(pos);
+  return uint8[pos + 16] === 4 ? null : deserializeCatchParameter(pos);
 }
 
 function deserializeBoxBindingIdentifier(pos) {
-  return deserializeBindingIdentifier(uint32[pos >> 2]);
+  return deserializeBindingIdentifier(int32[pos >> 2]);
 }
 
 function deserializeBoxObjectPattern(pos) {
-  return deserializeObjectPattern(uint32[pos >> 2]);
+  return deserializeObjectPattern(int32[pos >> 2]);
 }
 
 function deserializeBoxArrayPattern(pos) {
-  return deserializeArrayPattern(uint32[pos >> 2]);
+  return deserializeArrayPattern(int32[pos >> 2]);
 }
 
 function deserializeBoxAssignmentPattern(pos) {
-  return deserializeAssignmentPattern(uint32[pos >> 2]);
+  return deserializeAssignmentPattern(int32[pos >> 2]);
 }
 
 function deserializeVecBindingProperty(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 48;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 48;
   for (; pos !== endPos; ) {
     arr.push(deserializeBindingProperty(pos));
     pos += 48;
@@ -5988,24 +5954,24 @@ function deserializeVecBindingProperty(pos) {
 }
 
 function deserializeBoxBindingRestElement(pos) {
-  return deserializeBindingRestElement(uint32[pos >> 2]);
+  return deserializeBindingRestElement(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxBindingRestElement(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxBindingRestElement(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxBindingRestElement(pos);
 }
 
 function deserializeOptionBindingPattern(pos) {
-  if (uint8[pos] === 4) return null;
-  return deserializeBindingPattern(pos);
+  return uint8[pos] === 4 ? null : deserializeBindingPattern(pos);
 }
 
 function deserializeVecOptionBindingPattern(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeOptionBindingPattern(pos));
     pos += 16;
@@ -6014,46 +5980,50 @@ function deserializeVecOptionBindingPattern(pos) {
 }
 
 function deserializeOptionBindingIdentifier(pos) {
-  if (uint32[(pos + 16) >> 2] === 0 && uint32[(pos + 20) >> 2] === 0) return null;
-  return deserializeBindingIdentifier(pos);
+  return int32[(pos >> 2) + 4] === 0 && int32[(pos >> 2) + 5] === 0
+    ? null
+    : deserializeBindingIdentifier(pos);
 }
 
 function deserializeBoxTSTypeParameterDeclaration(pos) {
-  return deserializeTSTypeParameterDeclaration(uint32[pos >> 2]);
+  return deserializeTSTypeParameterDeclaration(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxTSTypeParameterDeclaration(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxTSTypeParameterDeclaration(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxTSTypeParameterDeclaration(pos);
 }
 
 function deserializeBoxTSThisParameter(pos) {
-  return deserializeTSThisParameter(uint32[pos >> 2]);
+  return deserializeTSThisParameter(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxTSThisParameter(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxTSThisParameter(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxTSThisParameter(pos);
 }
 
 function deserializeBoxFormalParameters(pos) {
-  return deserializeFormalParameters(uint32[pos >> 2]);
+  return deserializeFormalParameters(int32[pos >> 2]);
 }
 
 function deserializeBoxFunctionBody(pos) {
-  return deserializeFunctionBody(uint32[pos >> 2]);
+  return deserializeFunctionBody(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxFunctionBody(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxFunctionBody(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxFunctionBody(pos);
 }
 
 function deserializeVecFormalParameter(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 72;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 72;
   for (; pos !== endPos; ) {
     arr.push(deserializeFormalParameter(pos));
     pos += 72;
@@ -6064,8 +6034,8 @@ function deserializeVecFormalParameter(pos) {
 function deserializeVecDecorator(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 32;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 5);
   for (; pos !== endPos; ) {
     arr.push(deserializeDecorator(pos));
     pos += 32;
@@ -6074,24 +6044,24 @@ function deserializeVecDecorator(pos) {
 }
 
 function deserializeBoxExpression(pos) {
-  return deserializeExpression(uint32[pos >> 2]);
+  return deserializeExpression(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxExpression(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxExpression(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxExpression(pos);
 }
 
 function deserializeOptionTSAccessibility(pos) {
-  if (uint8[pos] === 3) return null;
-  return deserializeTSAccessibility(pos);
+  return uint8[pos] === 3 ? null : deserializeTSAccessibility(pos);
 }
 
 function deserializeVecTSClassImplements(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 40;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 40;
   for (; pos !== endPos; ) {
     arr.push(deserializeTSClassImplements(pos));
     pos += 40;
@@ -6100,14 +6070,14 @@ function deserializeVecTSClassImplements(pos) {
 }
 
 function deserializeBoxClassBody(pos) {
-  return deserializeClassBody(uint32[pos >> 2]);
+  return deserializeClassBody(int32[pos >> 2]);
 }
 
 function deserializeVecClassElement(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeClassElement(pos));
     pos += 16;
@@ -6116,59 +6086,58 @@ function deserializeVecClassElement(pos) {
 }
 
 function deserializeBoxStaticBlock(pos) {
-  return deserializeStaticBlock(uint32[pos >> 2]);
+  return deserializeStaticBlock(int32[pos >> 2]);
 }
 
 function deserializeBoxMethodDefinition(pos) {
-  return deserializeMethodDefinition(uint32[pos >> 2]);
+  return deserializeMethodDefinition(int32[pos >> 2]);
 }
 
 function deserializeBoxPropertyDefinition(pos) {
-  return deserializePropertyDefinition(uint32[pos >> 2]);
+  return deserializePropertyDefinition(int32[pos >> 2]);
 }
 
 function deserializeBoxAccessorProperty(pos) {
-  return deserializeAccessorProperty(uint32[pos >> 2]);
+  return deserializeAccessorProperty(int32[pos >> 2]);
 }
 
 function deserializeBoxTSIndexSignature(pos) {
-  return deserializeTSIndexSignature(uint32[pos >> 2]);
+  return deserializeTSIndexSignature(int32[pos >> 2]);
 }
 
 function deserializeBoxImportDeclaration(pos) {
-  return deserializeImportDeclaration(uint32[pos >> 2]);
+  return deserializeImportDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxExportAllDeclaration(pos) {
-  return deserializeExportAllDeclaration(uint32[pos >> 2]);
+  return deserializeExportAllDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxExportDefaultDeclaration(pos) {
-  return deserializeExportDefaultDeclaration(uint32[pos >> 2]);
+  return deserializeExportDefaultDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxExportNamedDeclaration(pos) {
-  return deserializeExportNamedDeclaration(uint32[pos >> 2]);
+  return deserializeExportNamedDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxTSExportAssignment(pos) {
-  return deserializeTSExportAssignment(uint32[pos >> 2]);
+  return deserializeTSExportAssignment(int32[pos >> 2]);
 }
 
 function deserializeBoxTSNamespaceExportDeclaration(pos) {
-  return deserializeTSNamespaceExportDeclaration(uint32[pos >> 2]);
+  return deserializeTSNamespaceExportDeclaration(int32[pos >> 2]);
 }
 
 function deserializeOptionImportPhase(pos) {
-  if (uint8[pos] === 2) return null;
-  return deserializeImportPhase(pos);
+  return uint8[pos] === 2 ? null : deserializeImportPhase(pos);
 }
 
 function deserializeVecImportDeclarationSpecifier(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeImportDeclarationSpecifier(pos));
     pos += 16;
@@ -6177,36 +6146,38 @@ function deserializeVecImportDeclarationSpecifier(pos) {
 }
 
 function deserializeOptionVecImportDeclarationSpecifier(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeVecImportDeclarationSpecifier(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeVecImportDeclarationSpecifier(pos);
 }
 
 function deserializeBoxWithClause(pos) {
-  return deserializeWithClause(uint32[pos >> 2]);
+  return deserializeWithClause(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxWithClause(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxWithClause(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxWithClause(pos);
 }
 
 function deserializeBoxImportSpecifier(pos) {
-  return deserializeImportSpecifier(uint32[pos >> 2]);
+  return deserializeImportSpecifier(int32[pos >> 2]);
 }
 
 function deserializeBoxImportDefaultSpecifier(pos) {
-  return deserializeImportDefaultSpecifier(uint32[pos >> 2]);
+  return deserializeImportDefaultSpecifier(int32[pos >> 2]);
 }
 
 function deserializeBoxImportNamespaceSpecifier(pos) {
-  return deserializeImportNamespaceSpecifier(uint32[pos >> 2]);
+  return deserializeImportNamespaceSpecifier(int32[pos >> 2]);
 }
 
 function deserializeVecImportAttribute(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 120;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 120;
   for (; pos !== endPos; ) {
     arr.push(deserializeImportAttribute(pos));
     pos += 120;
@@ -6215,15 +6186,14 @@ function deserializeVecImportAttribute(pos) {
 }
 
 function deserializeOptionDeclaration(pos) {
-  if (uint8[pos] === 31) return null;
-  return deserializeDeclaration(pos);
+  return uint8[pos] === 31 ? null : deserializeDeclaration(pos);
 }
 
 function deserializeVecExportSpecifier(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 128;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 7);
   for (; pos !== endPos; ) {
     arr.push(deserializeExportSpecifier(pos));
     pos += 128;
@@ -6232,13 +6202,11 @@ function deserializeVecExportSpecifier(pos) {
 }
 
 function deserializeOptionStringLiteral(pos) {
-  if (uint8[pos + 12] === 2) return null;
-  return deserializeStringLiteral(pos);
+  return uint8[pos + 12] === 2 ? null : deserializeStringLiteral(pos);
 }
 
 function deserializeOptionModuleExportName(pos) {
-  if (uint8[pos] === 3) return null;
-  return deserializeModuleExportName(pos);
+  return uint8[pos] === 3 ? null : deserializeModuleExportName(pos);
 }
 
 function deserializeF64(pos) {
@@ -6250,14 +6218,14 @@ function deserializeU8(pos) {
 }
 
 function deserializeBoxJSXOpeningElement(pos) {
-  return deserializeJSXOpeningElement(uint32[pos >> 2]);
+  return deserializeJSXOpeningElement(int32[pos >> 2]);
 }
 
 function deserializeVecJSXChild(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeJSXChild(pos));
     pos += 16;
@@ -6266,19 +6234,20 @@ function deserializeVecJSXChild(pos) {
 }
 
 function deserializeBoxJSXClosingElement(pos) {
-  return deserializeJSXClosingElement(uint32[pos >> 2]);
+  return deserializeJSXClosingElement(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxJSXClosingElement(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxJSXClosingElement(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxJSXClosingElement(pos);
 }
 
 function deserializeVecJSXAttributeItem(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeJSXAttributeItem(pos));
     pos += 16;
@@ -6287,47 +6256,46 @@ function deserializeVecJSXAttributeItem(pos) {
 }
 
 function deserializeBoxJSXIdentifier(pos) {
-  return deserializeJSXIdentifier(uint32[pos >> 2]);
+  return deserializeJSXIdentifier(int32[pos >> 2]);
 }
 
 function deserializeBoxJSXNamespacedName(pos) {
-  return deserializeJSXNamespacedName(uint32[pos >> 2]);
+  return deserializeJSXNamespacedName(int32[pos >> 2]);
 }
 
 function deserializeBoxJSXMemberExpression(pos) {
-  return deserializeJSXMemberExpression(uint32[pos >> 2]);
+  return deserializeJSXMemberExpression(int32[pos >> 2]);
 }
 
 function deserializeBoxJSXAttribute(pos) {
-  return deserializeJSXAttribute(uint32[pos >> 2]);
+  return deserializeJSXAttribute(int32[pos >> 2]);
 }
 
 function deserializeBoxJSXSpreadAttribute(pos) {
-  return deserializeJSXSpreadAttribute(uint32[pos >> 2]);
+  return deserializeJSXSpreadAttribute(int32[pos >> 2]);
 }
 
 function deserializeOptionJSXAttributeValue(pos) {
-  if (uint8[pos] === 4) return null;
-  return deserializeJSXAttributeValue(pos);
+  return uint8[pos] === 4 ? null : deserializeJSXAttributeValue(pos);
 }
 
 function deserializeBoxJSXExpressionContainer(pos) {
-  return deserializeJSXExpressionContainer(uint32[pos >> 2]);
+  return deserializeJSXExpressionContainer(int32[pos >> 2]);
 }
 
 function deserializeBoxJSXText(pos) {
-  return deserializeJSXText(uint32[pos >> 2]);
+  return deserializeJSXText(int32[pos >> 2]);
 }
 
 function deserializeBoxJSXSpreadChild(pos) {
-  return deserializeJSXSpreadChild(uint32[pos >> 2]);
+  return deserializeJSXSpreadChild(int32[pos >> 2]);
 }
 
 function deserializeVecTSEnumMember(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 48;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 48;
   for (; pos !== endPos; ) {
     arr.push(deserializeTSEnumMember(pos));
     pos += 48;
@@ -6336,158 +6304,158 @@ function deserializeVecTSEnumMember(pos) {
 }
 
 function deserializeBoxTSAnyKeyword(pos) {
-  return deserializeTSAnyKeyword(uint32[pos >> 2]);
+  return deserializeTSAnyKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSBigIntKeyword(pos) {
-  return deserializeTSBigIntKeyword(uint32[pos >> 2]);
+  return deserializeTSBigIntKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSBooleanKeyword(pos) {
-  return deserializeTSBooleanKeyword(uint32[pos >> 2]);
+  return deserializeTSBooleanKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSIntrinsicKeyword(pos) {
-  return deserializeTSIntrinsicKeyword(uint32[pos >> 2]);
+  return deserializeTSIntrinsicKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSNeverKeyword(pos) {
-  return deserializeTSNeverKeyword(uint32[pos >> 2]);
+  return deserializeTSNeverKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSNullKeyword(pos) {
-  return deserializeTSNullKeyword(uint32[pos >> 2]);
+  return deserializeTSNullKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSNumberKeyword(pos) {
-  return deserializeTSNumberKeyword(uint32[pos >> 2]);
+  return deserializeTSNumberKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSObjectKeyword(pos) {
-  return deserializeTSObjectKeyword(uint32[pos >> 2]);
+  return deserializeTSObjectKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSStringKeyword(pos) {
-  return deserializeTSStringKeyword(uint32[pos >> 2]);
+  return deserializeTSStringKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSSymbolKeyword(pos) {
-  return deserializeTSSymbolKeyword(uint32[pos >> 2]);
+  return deserializeTSSymbolKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSUndefinedKeyword(pos) {
-  return deserializeTSUndefinedKeyword(uint32[pos >> 2]);
+  return deserializeTSUndefinedKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSUnknownKeyword(pos) {
-  return deserializeTSUnknownKeyword(uint32[pos >> 2]);
+  return deserializeTSUnknownKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSVoidKeyword(pos) {
-  return deserializeTSVoidKeyword(uint32[pos >> 2]);
+  return deserializeTSVoidKeyword(int32[pos >> 2]);
 }
 
 function deserializeBoxTSArrayType(pos) {
-  return deserializeTSArrayType(uint32[pos >> 2]);
+  return deserializeTSArrayType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSConditionalType(pos) {
-  return deserializeTSConditionalType(uint32[pos >> 2]);
+  return deserializeTSConditionalType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSConstructorType(pos) {
-  return deserializeTSConstructorType(uint32[pos >> 2]);
+  return deserializeTSConstructorType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSFunctionType(pos) {
-  return deserializeTSFunctionType(uint32[pos >> 2]);
+  return deserializeTSFunctionType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSImportType(pos) {
-  return deserializeTSImportType(uint32[pos >> 2]);
+  return deserializeTSImportType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSIndexedAccessType(pos) {
-  return deserializeTSIndexedAccessType(uint32[pos >> 2]);
+  return deserializeTSIndexedAccessType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSInferType(pos) {
-  return deserializeTSInferType(uint32[pos >> 2]);
+  return deserializeTSInferType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSIntersectionType(pos) {
-  return deserializeTSIntersectionType(uint32[pos >> 2]);
+  return deserializeTSIntersectionType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSLiteralType(pos) {
-  return deserializeTSLiteralType(uint32[pos >> 2]);
+  return deserializeTSLiteralType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSMappedType(pos) {
-  return deserializeTSMappedType(uint32[pos >> 2]);
+  return deserializeTSMappedType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSNamedTupleMember(pos) {
-  return deserializeTSNamedTupleMember(uint32[pos >> 2]);
+  return deserializeTSNamedTupleMember(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTemplateLiteralType(pos) {
-  return deserializeTSTemplateLiteralType(uint32[pos >> 2]);
+  return deserializeTSTemplateLiteralType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSThisType(pos) {
-  return deserializeTSThisType(uint32[pos >> 2]);
+  return deserializeTSThisType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTupleType(pos) {
-  return deserializeTSTupleType(uint32[pos >> 2]);
+  return deserializeTSTupleType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTypeLiteral(pos) {
-  return deserializeTSTypeLiteral(uint32[pos >> 2]);
+  return deserializeTSTypeLiteral(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTypeOperator(pos) {
-  return deserializeTSTypeOperator(uint32[pos >> 2]);
+  return deserializeTSTypeOperator(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTypePredicate(pos) {
-  return deserializeTSTypePredicate(uint32[pos >> 2]);
+  return deserializeTSTypePredicate(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTypeQuery(pos) {
-  return deserializeTSTypeQuery(uint32[pos >> 2]);
+  return deserializeTSTypeQuery(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTypeReference(pos) {
-  return deserializeTSTypeReference(uint32[pos >> 2]);
+  return deserializeTSTypeReference(int32[pos >> 2]);
 }
 
 function deserializeBoxTSUnionType(pos) {
-  return deserializeTSUnionType(uint32[pos >> 2]);
+  return deserializeTSUnionType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSParenthesizedType(pos) {
-  return deserializeTSParenthesizedType(uint32[pos >> 2]);
+  return deserializeTSParenthesizedType(int32[pos >> 2]);
 }
 
 function deserializeBoxJSDocNullableType(pos) {
-  return deserializeJSDocNullableType(uint32[pos >> 2]);
+  return deserializeJSDocNullableType(int32[pos >> 2]);
 }
 
 function deserializeBoxJSDocNonNullableType(pos) {
-  return deserializeJSDocNonNullableType(uint32[pos >> 2]);
+  return deserializeJSDocNonNullableType(int32[pos >> 2]);
 }
 
 function deserializeBoxJSDocUnknownType(pos) {
-  return deserializeJSDocUnknownType(uint32[pos >> 2]);
+  return deserializeJSDocUnknownType(int32[pos >> 2]);
 }
 
 function deserializeVecTSType(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeTSType(pos));
     pos += 16;
@@ -6498,8 +6466,8 @@ function deserializeVecTSType(pos) {
 function deserializeVecTSTupleElement(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeTSTupleElement(pos));
     pos += 16;
@@ -6508,27 +6476,26 @@ function deserializeVecTSTupleElement(pos) {
 }
 
 function deserializeBoxTSOptionalType(pos) {
-  return deserializeTSOptionalType(uint32[pos >> 2]);
+  return deserializeTSOptionalType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSRestType(pos) {
-  return deserializeTSRestType(uint32[pos >> 2]);
+  return deserializeTSRestType(int32[pos >> 2]);
 }
 
 function deserializeBoxTSQualifiedName(pos) {
-  return deserializeTSQualifiedName(uint32[pos >> 2]);
+  return deserializeTSQualifiedName(int32[pos >> 2]);
 }
 
 function deserializeOptionTSType(pos) {
-  if (uint8[pos] === 38) return null;
-  return deserializeTSType(pos);
+  return uint8[pos] === 38 ? null : deserializeTSType(pos);
 }
 
 function deserializeVecTSTypeParameter(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 80;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 80;
   for (; pos !== endPos; ) {
     arr.push(deserializeTSTypeParameter(pos));
     pos += 80;
@@ -6539,8 +6506,8 @@ function deserializeVecTSTypeParameter(pos) {
 function deserializeVecTSInterfaceHeritage(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 40;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 40;
   for (; pos !== endPos; ) {
     arr.push(deserializeTSInterfaceHeritage(pos));
     pos += 40;
@@ -6549,14 +6516,14 @@ function deserializeVecTSInterfaceHeritage(pos) {
 }
 
 function deserializeBoxTSInterfaceBody(pos) {
-  return deserializeTSInterfaceBody(uint32[pos >> 2]);
+  return deserializeTSInterfaceBody(int32[pos >> 2]);
 }
 
 function deserializeVecTSSignature(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeTSSignature(pos));
     pos += 16;
@@ -6565,26 +6532,26 @@ function deserializeVecTSSignature(pos) {
 }
 
 function deserializeBoxTSPropertySignature(pos) {
-  return deserializeTSPropertySignature(uint32[pos >> 2]);
+  return deserializeTSPropertySignature(int32[pos >> 2]);
 }
 
 function deserializeBoxTSCallSignatureDeclaration(pos) {
-  return deserializeTSCallSignatureDeclaration(uint32[pos >> 2]);
+  return deserializeTSCallSignatureDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxTSConstructSignatureDeclaration(pos) {
-  return deserializeTSConstructSignatureDeclaration(uint32[pos >> 2]);
+  return deserializeTSConstructSignatureDeclaration(int32[pos >> 2]);
 }
 
 function deserializeBoxTSMethodSignature(pos) {
-  return deserializeTSMethodSignature(uint32[pos >> 2]);
+  return deserializeTSMethodSignature(int32[pos >> 2]);
 }
 
 function deserializeVecTSIndexSignatureName(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 40;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 40;
   for (; pos !== endPos; ) {
     arr.push(deserializeTSIndexSignatureName(pos));
     pos += 40;
@@ -6593,55 +6560,54 @@ function deserializeVecTSIndexSignatureName(pos) {
 }
 
 function deserializeOptionTSModuleDeclarationBody(pos) {
-  if (uint8[pos] === 2) return null;
-  return deserializeTSModuleDeclarationBody(pos);
+  return uint8[pos] === 2 ? null : deserializeTSModuleDeclarationBody(pos);
 }
 
 function deserializeBoxTSModuleBlock(pos) {
-  return deserializeTSModuleBlock(uint32[pos >> 2]);
+  return deserializeTSModuleBlock(int32[pos >> 2]);
 }
 
 function deserializeBoxTSTypeParameter(pos) {
-  return deserializeTSTypeParameter(uint32[pos >> 2]);
+  return deserializeTSTypeParameter(int32[pos >> 2]);
 }
 
 function deserializeOptionBoxObjectExpression(pos) {
-  if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
-  return deserializeBoxObjectExpression(pos);
+  return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
+    ? null
+    : deserializeBoxObjectExpression(pos);
 }
 
 function deserializeOptionTSImportTypeQualifier(pos) {
-  if (uint8[pos] === 2) return null;
-  return deserializeTSImportTypeQualifier(pos);
+  return uint8[pos] === 2 ? null : deserializeTSImportTypeQualifier(pos);
 }
 
 function deserializeBoxTSImportTypeQualifiedName(pos) {
-  return deserializeTSImportTypeQualifiedName(uint32[pos >> 2]);
+  return deserializeTSImportTypeQualifiedName(int32[pos >> 2]);
 }
 
 function deserializeOptionTSMappedTypeModifierOperator(pos) {
-  if (uint8[pos] === 3) return null;
-  return deserializeTSMappedTypeModifierOperator(pos);
+  return uint8[pos] === 3 ? null : deserializeTSMappedTypeModifierOperator(pos);
 }
 
 function deserializeBoxTSExternalModuleReference(pos) {
-  return deserializeTSExternalModuleReference(uint32[pos >> 2]);
+  return deserializeTSExternalModuleReference(int32[pos >> 2]);
 }
 
-function deserializeU32(pos) {
-  return uint32[pos >> 2];
+function deserializeI32(pos) {
+  return int32[pos >> 2];
 }
 
 function deserializeOptionNameSpan(pos) {
-  if (uint32[(pos + 8) >> 2] === 0 && uint32[(pos + 12) >> 2] === 0) return null;
-  return deserializeNameSpan(pos);
+  return int32[(pos >> 2) + 2] === 0 && int32[(pos >> 2) + 3] === 0
+    ? null
+    : deserializeNameSpan(pos);
 }
 
 function deserializeVecError(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 80;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 80;
   for (; pos !== endPos; ) {
     arr.push(deserializeError(pos));
     pos += 80;
@@ -6652,8 +6618,8 @@ function deserializeVecError(pos) {
 function deserializeVecErrorLabel(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 24;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 24;
   for (; pos !== endPos; ) {
     arr.push(deserializeErrorLabel(pos));
     pos += 24;
@@ -6664,8 +6630,8 @@ function deserializeVecErrorLabel(pos) {
 function deserializeVecStaticImport(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 56;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 56;
   for (; pos !== endPos; ) {
     arr.push(deserializeStaticImport(pos));
     pos += 56;
@@ -6676,8 +6642,8 @@ function deserializeVecStaticImport(pos) {
 function deserializeVecStaticExport(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 32;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 5);
   for (; pos !== endPos; ) {
     arr.push(deserializeStaticExport(pos));
     pos += 32;
@@ -6688,8 +6654,8 @@ function deserializeVecStaticExport(pos) {
 function deserializeVecDynamicImport(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 16;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 4);
   for (; pos !== endPos; ) {
     arr.push(deserializeDynamicImport(pos));
     pos += 16;
@@ -6700,8 +6666,8 @@ function deserializeVecDynamicImport(pos) {
 function deserializeVecSpan(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 8;
+  pos = int32[pos32];
+  let endPos = pos + (int32[pos32 + 2] << 3);
   for (; pos !== endPos; ) {
     arr.push(deserializeSpan(pos));
     pos += 8;
@@ -6712,8 +6678,8 @@ function deserializeVecSpan(pos) {
 function deserializeVecImportEntry(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 96;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 96;
   for (; pos !== endPos; ) {
     arr.push(deserializeImportEntry(pos));
     pos += 96;
@@ -6724,8 +6690,8 @@ function deserializeVecImportEntry(pos) {
 function deserializeVecExportEntry(pos) {
   let arr = [],
     pos32 = pos >> 2;
-  pos = uint32[pos32];
-  let endPos = pos + uint32[pos32 + 2] * 144;
+  pos = int32[pos32];
+  let endPos = pos + int32[pos32 + 2] * 144;
   for (; pos !== endPos; ) {
     arr.push(deserializeExportEntry(pos));
     pos += 144;