oxc-parser 0.123.0 → 0.125.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (12) hide show
  1. package/package.json +28 -28
  2. package/src-js/bindings.js +52 -52
  3. package/src-js/generated/constants.js +3 -3
  4. package/src-js/generated/deserialize/js.js +829 -817
  5. package/src-js/generated/deserialize/js_range.js +833 -830
  6. package/src-js/generated/deserialize/ts.js +869 -891
  7. package/src-js/generated/deserialize/ts_range.js +894 -928
  8. package/src-js/generated/lazy/constructors.js +661 -667
  9. package/src-js/generated/lazy/walk.js +261 -261
  10. package/src-js/raw-transfer/common.js +1 -1
  11. package/src-js/raw-transfer/eager.js +21 -16
  12. package/src-js/raw-transfer/lazy.js +1 -1
package/src-js/generated/deserialize/ts.js CHANGED
@@ -1,35 +1,50 @@
1
1
  // Auto-generated code, DO NOT EDIT DIRECTLY!
2
2
  // To edit this generated file you have to edit `tasks/ast_tools/src/generators/raw_transfer.rs`.
3
3
 
4
- let uint8, uint32, float64, sourceText, sourceIsAscii, sourceEndPos;
5
-
6
- const textDecoder = new TextDecoder("utf-8", { ignoreBOM: true }),
7
- decodeStr = textDecoder.decode.bind(textDecoder),
8
- { fromCodePoint } = String;
4
+ let uint8,
5
+ int32,
6
+ float64,
7
+ sourceText,
8
+ sourceTextLatin,
9
+ sourceEndPos = 0,
10
+ firstNonAsciiPos = 0;
11
+
12
+ const { fromCharCode } = String,
13
+ { utf8Slice, latin1Slice } = Buffer.prototype,
14
+ stringDecodeArrays = Array(65).fill(null);
15
+ for (let i = 0; i <= 64; i++) stringDecodeArrays[i] = Array(i).fill(0);
9
16
 
10
17
  export function deserialize(buffer, sourceText, sourceByteLen) {
11
18
  sourceEndPos = sourceByteLen;
12
- let data = deserializeWith(buffer, sourceText, sourceByteLen, null, deserializeRawTransferData);
13
- resetBuffer();
14
- return data;
19
+ return deserializeWith(buffer, sourceText, sourceByteLen, deserializeRawTransferData);
15
20
  }
16
21
 
17
- function deserializeWith(buffer, sourceTextInput, sourceByteLen, getLocInput, deserialize) {
22
+ function deserializeWith(buffer, sourceTextInput, sourceByteLen, deserialize) {
18
23
  uint8 = buffer;
19
- uint32 = buffer.uint32;
24
+ int32 = buffer.int32;
20
25
  float64 = buffer.float64;
21
26
  sourceText = sourceTextInput;
22
- sourceIsAscii = sourceText.length === sourceByteLen;
23
- return deserialize(uint32[536870900]);
27
+ if (sourceText.length === sourceByteLen) {
28
+ firstNonAsciiPos = sourceByteLen;
29
+ sourceTextLatin = sourceText;
30
+ } else {
31
+ let i = 0;
32
+ for (; i < sourceByteLen && uint8[i] < 128; i++);
33
+ firstNonAsciiPos = i;
34
+ sourceTextLatin = latin1Slice.call(uint8, 0, sourceByteLen);
35
+ }
36
+ let data = deserialize(int32[536870900]);
37
+ resetBuffer();
38
+ return data;
24
39
  }
25
40
 
26
41
  export function resetBuffer() {
27
- // Clear buffer and source text string to allow them to be garbage collected
28
- uint8 = uint32 = float64 = sourceText = void 0;
42
+ // Clear buffer and source text strings to allow them to be garbage collected
43
+ uint8 = int32 = float64 = sourceText = sourceTextLatin = void 0;
29
44
  }
30
45
 
31
46
  function deserializeProgram(pos) {
32
- let end = deserializeU32(pos + 4),
47
+ let end = deserializeI32(pos + 4),
33
48
  program = {
34
49
  type: "Program",
35
50
  body: null,
@@ -157,70 +172,58 @@ function deserializeExpression(pos) {
157
172
  }
158
173
 
159
174
  function deserializeIdentifierName(pos) {
160
- let node = {
175
+ return {
161
176
  type: "Identifier",
162
- decorators: null,
177
+ decorators: [],
163
178
  name: deserializeStr(pos + 16),
164
- optional: null,
179
+ optional: false,
165
180
  typeAnnotation: null,
166
- start: deserializeU32(pos),
167
- end: deserializeU32(pos + 4),
181
+ start: deserializeI32(pos),
182
+ end: deserializeI32(pos + 4),
168
183
  };
169
- node.decorators = [];
170
- node.optional = false;
171
- return node;
172
184
  }
173
185
 
174
186
  function deserializeIdentifierReference(pos) {
175
- let node = {
187
+ return {
176
188
  type: "Identifier",
177
- decorators: null,
189
+ decorators: [],
178
190
  name: deserializeStr(pos + 16),
179
- optional: null,
191
+ optional: false,
180
192
  typeAnnotation: null,
181
- start: deserializeU32(pos),
182
- end: deserializeU32(pos + 4),
193
+ start: deserializeI32(pos),
194
+ end: deserializeI32(pos + 4),
183
195
  };
184
- node.decorators = [];
185
- node.optional = false;
186
- return node;
187
196
  }
188
197
 
189
198
  function deserializeBindingIdentifier(pos) {
190
- let node = {
199
+ return {
191
200
  type: "Identifier",
192
- decorators: null,
201
+ decorators: [],
193
202
  name: deserializeStr(pos + 16),
194
- optional: null,
203
+ optional: false,
195
204
  typeAnnotation: null,
196
- start: deserializeU32(pos),
197
- end: deserializeU32(pos + 4),
205
+ start: deserializeI32(pos),
206
+ end: deserializeI32(pos + 4),
198
207
  };
199
- node.decorators = [];
200
- node.optional = false;
201
- return node;
202
208
  }
203
209
 
204
210
  function deserializeLabelIdentifier(pos) {
205
- let node = {
211
+ return {
206
212
  type: "Identifier",
207
- decorators: null,
213
+ decorators: [],
208
214
  name: deserializeStr(pos + 16),
209
- optional: null,
215
+ optional: false,
210
216
  typeAnnotation: null,
211
- start: deserializeU32(pos),
212
- end: deserializeU32(pos + 4),
217
+ start: deserializeI32(pos),
218
+ end: deserializeI32(pos + 4),
213
219
  };
214
- node.decorators = [];
215
- node.optional = false;
216
- return node;
217
220
  }
218
221
 
219
222
  function deserializeThisExpression(pos) {
220
223
  return {
221
224
  type: "ThisExpression",
222
- start: deserializeU32(pos),
223
- end: deserializeU32(pos + 4),
225
+ start: deserializeI32(pos),
226
+ end: deserializeI32(pos + 4),
224
227
  };
225
228
  }
226
229
 
@@ -228,8 +231,8 @@ function deserializeArrayExpression(pos) {
228
231
  let node = {
229
232
  type: "ArrayExpression",
230
233
  elements: null,
231
- start: deserializeU32(pos),
232
- end: deserializeU32(pos + 4),
234
+ start: deserializeI32(pos),
235
+ end: deserializeI32(pos + 4),
233
236
  };
234
237
  node.elements = deserializeVecArrayExpressionElement(pos + 16);
235
238
  return node;
@@ -340,8 +343,8 @@ function deserializeObjectExpression(pos) {
340
343
  let node = {
341
344
  type: "ObjectExpression",
342
345
  properties: null,
343
- start: deserializeU32(pos),
344
- end: deserializeU32(pos + 4),
346
+ start: deserializeI32(pos),
347
+ end: deserializeI32(pos + 4),
345
348
  };
346
349
  node.properties = deserializeVecObjectPropertyKind(pos + 16);
347
350
  return node;
@@ -367,13 +370,12 @@ function deserializeObjectProperty(pos) {
367
370
  method: deserializeBool(pos + 13),
368
371
  shorthand: deserializeBool(pos + 14),
369
372
  computed: deserializeBool(pos + 15),
370
- optional: null,
371
- start: deserializeU32(pos),
372
- end: deserializeU32(pos + 4),
373
+ optional: false,
374
+ start: deserializeI32(pos),
375
+ end: deserializeI32(pos + 4),
373
376
  };
374
377
  node.key = deserializePropertyKey(pos + 16);
375
378
  node.value = deserializeExpression(pos + 32);
376
- node.optional = false;
377
379
  return node;
378
380
  }
379
381
 
@@ -492,8 +494,8 @@ function deserializeTemplateLiteral(pos) {
492
494
  type: "TemplateLiteral",
493
495
  quasis: null,
494
496
  expressions: null,
495
- start: deserializeU32(pos),
496
- end: deserializeU32(pos + 4),
497
+ start: deserializeI32(pos),
498
+ end: deserializeI32(pos + 4),
497
499
  };
498
500
  node.quasis = deserializeVecTemplateElement(pos + 16);
499
501
  node.expressions = deserializeVecExpression(pos + 40);
@@ -506,8 +508,8 @@ function deserializeTaggedTemplateExpression(pos) {
506
508
  tag: null,
507
509
  typeArguments: null,
508
510
  quasi: null,
509
- start: deserializeU32(pos),
510
- end: deserializeU32(pos + 4),
511
+ start: deserializeI32(pos),
512
+ end: deserializeI32(pos + 4),
511
513
  };
512
514
  node.tag = deserializeExpression(pos + 16);
513
515
  node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 32);
@@ -517,8 +519,8 @@ function deserializeTaggedTemplateExpression(pos) {
517
519
 
518
520
  function deserializeTemplateElement(pos) {
519
521
  let tail = deserializeBool(pos + 12),
520
- start = deserializeU32(pos) - 1,
521
- end = deserializeU32(pos + 4) + 2 - tail,
522
+ start = deserializeI32(pos) - 1,
523
+ end = deserializeI32(pos + 4) + 2 - tail,
522
524
  value = deserializeTemplateElementValue(pos + 16);
523
525
  value.cooked !== null &&
524
526
  deserializeBool(pos + 13) &&
@@ -547,13 +549,12 @@ function deserializeComputedMemberExpression(pos) {
547
549
  object: null,
548
550
  property: null,
549
551
  optional: deserializeBool(pos + 12),
550
- computed: null,
551
- start: deserializeU32(pos),
552
- end: deserializeU32(pos + 4),
552
+ computed: true,
553
+ start: deserializeI32(pos),
554
+ end: deserializeI32(pos + 4),
553
555
  };
554
556
  node.object = deserializeExpression(pos + 16);
555
557
  node.property = deserializeExpression(pos + 32);
556
- node.computed = true;
557
558
  return node;
558
559
  }
559
560
 
@@ -563,13 +564,12 @@ function deserializeStaticMemberExpression(pos) {
563
564
  object: null,
564
565
  property: null,
565
566
  optional: deserializeBool(pos + 12),
566
- computed: null,
567
- start: deserializeU32(pos),
568
- end: deserializeU32(pos + 4),
567
+ computed: false,
568
+ start: deserializeI32(pos),
569
+ end: deserializeI32(pos + 4),
569
570
  };
570
571
  node.object = deserializeExpression(pos + 16);
571
572
  node.property = deserializeIdentifierName(pos + 32);
572
- node.computed = false;
573
573
  return node;
574
574
  }
575
575
 
@@ -579,13 +579,12 @@ function deserializePrivateFieldExpression(pos) {
579
579
  object: null,
580
580
  property: null,
581
581
  optional: deserializeBool(pos + 12),
582
- computed: null,
583
- start: deserializeU32(pos),
584
- end: deserializeU32(pos + 4),
582
+ computed: false,
583
+ start: deserializeI32(pos),
584
+ end: deserializeI32(pos + 4),
585
585
  };
586
586
  node.object = deserializeExpression(pos + 16);
587
587
  node.property = deserializePrivateIdentifier(pos + 32);
588
- node.computed = false;
589
588
  return node;
590
589
  }
591
590
 
@@ -596,8 +595,8 @@ function deserializeCallExpression(pos) {
596
595
  typeArguments: null,
597
596
  arguments: null,
598
597
  optional: deserializeBool(pos + 12),
599
- start: deserializeU32(pos),
600
- end: deserializeU32(pos + 4),
598
+ start: deserializeI32(pos),
599
+ end: deserializeI32(pos + 4),
601
600
  };
602
601
  node.callee = deserializeExpression(pos + 16);
603
602
  node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 32);
@@ -611,8 +610,8 @@ function deserializeNewExpression(pos) {
611
610
  callee: null,
612
611
  typeArguments: null,
613
612
  arguments: null,
614
- start: deserializeU32(pos),
615
- end: deserializeU32(pos + 4),
613
+ start: deserializeI32(pos),
614
+ end: deserializeI32(pos + 4),
616
615
  };
617
616
  node.callee = deserializeExpression(pos + 16);
618
617
  node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 32);
@@ -625,8 +624,8 @@ function deserializeMetaProperty(pos) {
625
624
  type: "MetaProperty",
626
625
  meta: null,
627
626
  property: null,
628
- start: deserializeU32(pos),
629
- end: deserializeU32(pos + 4),
627
+ start: deserializeI32(pos),
628
+ end: deserializeI32(pos + 4),
630
629
  };
631
630
  node.meta = deserializeIdentifierName(pos + 16);
632
631
  node.property = deserializeIdentifierName(pos + 48);
@@ -637,8 +636,8 @@ function deserializeSpreadElement(pos) {
637
636
  let node = {
638
637
  type: "SpreadElement",
639
638
  argument: null,
640
- start: deserializeU32(pos),
641
- end: deserializeU32(pos + 4),
639
+ start: deserializeI32(pos),
640
+ end: deserializeI32(pos + 4),
642
641
  };
643
642
  node.argument = deserializeExpression(pos + 16);
644
643
  return node;
@@ -745,8 +744,8 @@ function deserializeUpdateExpression(pos) {
745
744
  operator: deserializeUpdateOperator(pos + 12),
746
745
  prefix: deserializeBool(pos + 13),
747
746
  argument: null,
748
- start: deserializeU32(pos),
749
- end: deserializeU32(pos + 4),
747
+ start: deserializeI32(pos),
748
+ end: deserializeI32(pos + 4),
750
749
  };
751
750
  node.argument = deserializeSimpleAssignmentTarget(pos + 16);
752
751
  return node;
@@ -757,12 +756,11 @@ function deserializeUnaryExpression(pos) {
757
756
  type: "UnaryExpression",
758
757
  operator: deserializeUnaryOperator(pos + 12),
759
758
  argument: null,
760
- prefix: null,
761
- start: deserializeU32(pos),
762
- end: deserializeU32(pos + 4),
759
+ prefix: true,
760
+ start: deserializeI32(pos),
761
+ end: deserializeI32(pos + 4),
763
762
  };
764
763
  node.argument = deserializeExpression(pos + 16);
765
- node.prefix = true;
766
764
  return node;
767
765
  }
768
766
 
@@ -772,8 +770,8 @@ function deserializeBinaryExpression(pos) {
772
770
  left: null,
773
771
  operator: deserializeBinaryOperator(pos + 12),
774
772
  right: null,
775
- start: deserializeU32(pos),
776
- end: deserializeU32(pos + 4),
773
+ start: deserializeI32(pos),
774
+ end: deserializeI32(pos + 4),
777
775
  };
778
776
  node.left = deserializeExpression(pos + 16);
779
777
  node.right = deserializeExpression(pos + 32);
@@ -784,13 +782,12 @@ function deserializePrivateInExpression(pos) {
784
782
  let node = {
785
783
  type: "BinaryExpression",
786
784
  left: null,
787
- operator: null,
785
+ operator: "in",
788
786
  right: null,
789
- start: deserializeU32(pos),
790
- end: deserializeU32(pos + 4),
787
+ start: deserializeI32(pos),
788
+ end: deserializeI32(pos + 4),
791
789
  };
792
790
  node.left = deserializePrivateIdentifier(pos + 16);
793
- node.operator = "in";
794
791
  node.right = deserializeExpression(pos + 48);
795
792
  return node;
796
793
  }
@@ -801,8 +798,8 @@ function deserializeLogicalExpression(pos) {
801
798
  left: null,
802
799
  operator: deserializeLogicalOperator(pos + 12),
803
800
  right: null,
804
- start: deserializeU32(pos),
805
- end: deserializeU32(pos + 4),
801
+ start: deserializeI32(pos),
802
+ end: deserializeI32(pos + 4),
806
803
  };
807
804
  node.left = deserializeExpression(pos + 16);
808
805
  node.right = deserializeExpression(pos + 32);
@@ -815,8 +812,8 @@ function deserializeConditionalExpression(pos) {
815
812
  test: null,
816
813
  consequent: null,
817
814
  alternate: null,
818
- start: deserializeU32(pos),
819
- end: deserializeU32(pos + 4),
815
+ start: deserializeI32(pos),
816
+ end: deserializeI32(pos + 4),
820
817
  };
821
818
  node.test = deserializeExpression(pos + 16);
822
819
  node.consequent = deserializeExpression(pos + 32);
@@ -830,8 +827,8 @@ function deserializeAssignmentExpression(pos) {
830
827
  operator: deserializeAssignmentOperator(pos + 12),
831
828
  left: null,
832
829
  right: null,
833
- start: deserializeU32(pos),
834
- end: deserializeU32(pos + 4),
830
+ start: deserializeI32(pos),
831
+ end: deserializeI32(pos + 4),
835
832
  };
836
833
  node.left = deserializeAssignmentTarget(pos + 16);
837
834
  node.right = deserializeExpression(pos + 32);
@@ -891,55 +888,49 @@ function deserializeSimpleAssignmentTarget(pos) {
891
888
  function deserializeArrayAssignmentTarget(pos) {
892
889
  let node = {
893
890
  type: "ArrayPattern",
894
- decorators: null,
891
+ decorators: [],
895
892
  elements: null,
896
- optional: null,
893
+ optional: false,
897
894
  typeAnnotation: null,
898
- start: deserializeU32(pos),
899
- end: deserializeU32(pos + 4),
895
+ start: deserializeI32(pos),
896
+ end: deserializeI32(pos + 4),
900
897
  },
901
898
  elements = deserializeVecOptionAssignmentTargetMaybeDefault(pos + 16),
902
899
  rest = deserializeOptionBoxAssignmentTargetRest(pos + 40);
903
900
  rest !== null && elements.push(rest);
904
- node.decorators = [];
905
901
  node.elements = elements;
906
- node.optional = false;
907
902
  return node;
908
903
  }
909
904
 
910
905
  function deserializeObjectAssignmentTarget(pos) {
911
906
  let node = {
912
907
  type: "ObjectPattern",
913
- decorators: null,
908
+ decorators: [],
914
909
  properties: null,
915
- optional: null,
910
+ optional: false,
916
911
  typeAnnotation: null,
917
- start: deserializeU32(pos),
918
- end: deserializeU32(pos + 4),
912
+ start: deserializeI32(pos),
913
+ end: deserializeI32(pos + 4),
919
914
  },
920
915
  properties = deserializeVecAssignmentTargetProperty(pos + 16),
921
916
  rest = deserializeOptionBoxAssignmentTargetRest(pos + 40);
922
917
  rest !== null && properties.push(rest);
923
- node.decorators = [];
924
918
  node.properties = properties;
925
- node.optional = false;
926
919
  return node;
927
920
  }
928
921
 
929
922
  function deserializeAssignmentTargetRest(pos) {
930
923
  let node = {
931
924
  type: "RestElement",
932
- decorators: null,
925
+ decorators: [],
933
926
  argument: null,
934
- optional: null,
927
+ optional: false,
935
928
  typeAnnotation: null,
936
929
  value: null,
937
- start: deserializeU32(pos),
938
- end: deserializeU32(pos + 4),
930
+ start: deserializeI32(pos),
931
+ end: deserializeI32(pos + 4),
939
932
  };
940
- node.decorators = [];
941
933
  node.argument = deserializeAssignmentTarget(pos + 16);
942
- node.optional = false;
943
934
  return node;
944
935
  }
945
936
 
@@ -975,18 +966,16 @@ function deserializeAssignmentTargetMaybeDefault(pos) {
975
966
  function deserializeAssignmentTargetWithDefault(pos) {
976
967
  let node = {
977
968
  type: "AssignmentPattern",
978
- decorators: null,
969
+ decorators: [],
979
970
  left: null,
980
971
  right: null,
981
- optional: null,
972
+ optional: false,
982
973
  typeAnnotation: null,
983
- start: deserializeU32(pos),
984
- end: deserializeU32(pos + 4),
974
+ start: deserializeI32(pos),
975
+ end: deserializeI32(pos + 4),
985
976
  };
986
- node.decorators = [];
987
977
  node.left = deserializeAssignmentTarget(pos + 16);
988
978
  node.right = deserializeExpression(pos + 32);
989
- node.optional = false;
990
979
  return node;
991
980
  }
992
981
 
@@ -1002,17 +991,17 @@ function deserializeAssignmentTargetProperty(pos) {
1002
991
  }
1003
992
 
1004
993
  function deserializeAssignmentTargetPropertyIdentifier(pos) {
1005
- let start = deserializeU32(pos),
1006
- end = deserializeU32(pos + 4),
994
+ let start = deserializeI32(pos),
995
+ end = deserializeI32(pos + 4),
1007
996
  node = {
1008
997
  type: "Property",
1009
- kind: null,
998
+ kind: "init",
1010
999
  key: null,
1011
1000
  value: null,
1012
- method: null,
1013
- shorthand: null,
1014
- computed: null,
1015
- optional: null,
1001
+ method: false,
1002
+ shorthand: true,
1003
+ computed: false,
1004
+ optional: false,
1016
1005
  start,
1017
1006
  end,
1018
1007
  },
@@ -1038,35 +1027,26 @@ function deserializeAssignmentTargetPropertyIdentifier(pos) {
1038
1027
  start,
1039
1028
  end,
1040
1029
  });
1041
- node.kind = "init";
1042
1030
  node.key = key;
1043
1031
  node.value = value;
1044
- node.method = false;
1045
- node.shorthand = true;
1046
- node.computed = false;
1047
- node.optional = false;
1048
1032
  return node;
1049
1033
  }
1050
1034
 
1051
1035
  function deserializeAssignmentTargetPropertyProperty(pos) {
1052
1036
  let node = {
1053
1037
  type: "Property",
1054
- kind: null,
1038
+ kind: "init",
1055
1039
  key: null,
1056
1040
  value: null,
1057
- method: null,
1058
- shorthand: null,
1041
+ method: false,
1042
+ shorthand: false,
1059
1043
  computed: deserializeBool(pos + 12),
1060
- optional: null,
1061
- start: deserializeU32(pos),
1062
- end: deserializeU32(pos + 4),
1044
+ optional: false,
1045
+ start: deserializeI32(pos),
1046
+ end: deserializeI32(pos + 4),
1063
1047
  };
1064
- node.kind = "init";
1065
1048
  node.key = deserializePropertyKey(pos + 16);
1066
1049
  node.value = deserializeAssignmentTargetMaybeDefault(pos + 32);
1067
- node.method = false;
1068
- node.shorthand = false;
1069
- node.optional = false;
1070
1050
  return node;
1071
1051
  }
1072
1052
 
@@ -1074,8 +1054,8 @@ function deserializeSequenceExpression(pos) {
1074
1054
  let node = {
1075
1055
  type: "SequenceExpression",
1076
1056
  expressions: null,
1077
- start: deserializeU32(pos),
1078
- end: deserializeU32(pos + 4),
1057
+ start: deserializeI32(pos),
1058
+ end: deserializeI32(pos + 4),
1079
1059
  };
1080
1060
  node.expressions = deserializeVecExpression(pos + 16);
1081
1061
  return node;
@@ -1084,8 +1064,8 @@ function deserializeSequenceExpression(pos) {
1084
1064
  function deserializeSuper(pos) {
1085
1065
  return {
1086
1066
  type: "Super",
1087
- start: deserializeU32(pos),
1088
- end: deserializeU32(pos + 4),
1067
+ start: deserializeI32(pos),
1068
+ end: deserializeI32(pos + 4),
1089
1069
  };
1090
1070
  }
1091
1071
 
@@ -1093,8 +1073,8 @@ function deserializeAwaitExpression(pos) {
1093
1073
  let node = {
1094
1074
  type: "AwaitExpression",
1095
1075
  argument: null,
1096
- start: deserializeU32(pos),
1097
- end: deserializeU32(pos + 4),
1076
+ start: deserializeI32(pos),
1077
+ end: deserializeI32(pos + 4),
1098
1078
  };
1099
1079
  node.argument = deserializeExpression(pos + 16);
1100
1080
  return node;
@@ -1104,8 +1084,8 @@ function deserializeChainExpression(pos) {
1104
1084
  let node = {
1105
1085
  type: "ChainExpression",
1106
1086
  expression: null,
1107
- start: deserializeU32(pos),
1108
- end: deserializeU32(pos + 4),
1087
+ start: deserializeI32(pos),
1088
+ end: deserializeI32(pos + 4),
1109
1089
  };
1110
1090
  node.expression = deserializeChainElement(pos + 16);
1111
1091
  return node;
@@ -1133,8 +1113,8 @@ function deserializeParenthesizedExpression(pos) {
1133
1113
  node = {
1134
1114
  type: "ParenthesizedExpression",
1135
1115
  expression: null,
1136
- start: deserializeU32(pos),
1137
- end: deserializeU32(pos + 4),
1116
+ start: deserializeI32(pos),
1117
+ end: deserializeI32(pos + 4),
1138
1118
  };
1139
1119
  node.expression = deserializeExpression(pos + 16);
1140
1120
  return node;
@@ -1218,8 +1198,8 @@ function deserializeDirective(pos) {
1218
1198
  type: "ExpressionStatement",
1219
1199
  expression: null,
1220
1200
  directive: deserializeStr(pos + 64),
1221
- start: deserializeU32(pos),
1222
- end: deserializeU32(pos + 4),
1201
+ start: deserializeI32(pos),
1202
+ end: deserializeI32(pos + 4),
1223
1203
  };
1224
1204
  node.expression = deserializeStringLiteral(pos + 16);
1225
1205
  return node;
@@ -1229,8 +1209,8 @@ function deserializeHashbang(pos) {
1229
1209
  return {
1230
1210
  type: "Hashbang",
1231
1211
  value: deserializeStr(pos + 16),
1232
- start: deserializeU32(pos),
1233
- end: deserializeU32(pos + 4),
1212
+ start: deserializeI32(pos),
1213
+ end: deserializeI32(pos + 4),
1234
1214
  };
1235
1215
  }
1236
1216
 
@@ -1238,8 +1218,8 @@ function deserializeBlockStatement(pos) {
1238
1218
  let node = {
1239
1219
  type: "BlockStatement",
1240
1220
  body: null,
1241
- start: deserializeU32(pos),
1242
- end: deserializeU32(pos + 4),
1221
+ start: deserializeI32(pos),
1222
+ end: deserializeI32(pos + 4),
1243
1223
  };
1244
1224
  node.body = deserializeVecStatement(pos + 16);
1245
1225
  return node;
@@ -1276,8 +1256,8 @@ function deserializeVariableDeclaration(pos) {
1276
1256
  kind: deserializeVariableDeclarationKind(pos + 12),
1277
1257
  declarations: null,
1278
1258
  declare: deserializeBool(pos + 13),
1279
- start: deserializeU32(pos),
1280
- end: deserializeU32(pos + 4),
1259
+ start: deserializeI32(pos),
1260
+ end: deserializeI32(pos + 4),
1281
1261
  };
1282
1262
  node.declarations = deserializeVecVariableDeclarator(pos + 16);
1283
1263
  return node;
@@ -1306,8 +1286,8 @@ function deserializeVariableDeclarator(pos) {
1306
1286
  id: null,
1307
1287
  init: null,
1308
1288
  definite: deserializeBool(pos + 13),
1309
- start: deserializeU32(pos),
1310
- end: deserializeU32(pos + 4),
1289
+ start: deserializeI32(pos),
1290
+ end: deserializeI32(pos + 4),
1311
1291
  },
1312
1292
  pattern = deserializeBindingPattern(pos + 16);
1313
1293
  {
@@ -1325,8 +1305,8 @@ function deserializeVariableDeclarator(pos) {
1325
1305
  function deserializeEmptyStatement(pos) {
1326
1306
  return {
1327
1307
  type: "EmptyStatement",
1328
- start: deserializeU32(pos),
1329
- end: deserializeU32(pos + 4),
1308
+ start: deserializeI32(pos),
1309
+ end: deserializeI32(pos + 4),
1330
1310
  };
1331
1311
  }
1332
1312
 
@@ -1335,8 +1315,8 @@ function deserializeExpressionStatement(pos) {
1335
1315
  type: "ExpressionStatement",
1336
1316
  expression: null,
1337
1317
  directive: null,
1338
- start: deserializeU32(pos),
1339
- end: deserializeU32(pos + 4),
1318
+ start: deserializeI32(pos),
1319
+ end: deserializeI32(pos + 4),
1340
1320
  };
1341
1321
  node.expression = deserializeExpression(pos + 16);
1342
1322
  return node;
@@ -1348,8 +1328,8 @@ function deserializeIfStatement(pos) {
1348
1328
  test: null,
1349
1329
  consequent: null,
1350
1330
  alternate: null,
1351
- start: deserializeU32(pos),
1352
- end: deserializeU32(pos + 4),
1331
+ start: deserializeI32(pos),
1332
+ end: deserializeI32(pos + 4),
1353
1333
  };
1354
1334
  node.test = deserializeExpression(pos + 16);
1355
1335
  node.consequent = deserializeStatement(pos + 32);
@@ -1362,8 +1342,8 @@ function deserializeDoWhileStatement(pos) {
1362
1342
  type: "DoWhileStatement",
1363
1343
  body: null,
1364
1344
  test: null,
1365
- start: deserializeU32(pos),
1366
- end: deserializeU32(pos + 4),
1345
+ start: deserializeI32(pos),
1346
+ end: deserializeI32(pos + 4),
1367
1347
  };
1368
1348
  node.body = deserializeStatement(pos + 16);
1369
1349
  node.test = deserializeExpression(pos + 32);
@@ -1375,8 +1355,8 @@ function deserializeWhileStatement(pos) {
1375
1355
  type: "WhileStatement",
1376
1356
  test: null,
1377
1357
  body: null,
1378
- start: deserializeU32(pos),
1379
- end: deserializeU32(pos + 4),
1358
+ start: deserializeI32(pos),
1359
+ end: deserializeI32(pos + 4),
1380
1360
  };
1381
1361
  node.test = deserializeExpression(pos + 16);
1382
1362
  node.body = deserializeStatement(pos + 32);
@@ -1390,8 +1370,8 @@ function deserializeForStatement(pos) {
1390
1370
  test: null,
1391
1371
  update: null,
1392
1372
  body: null,
1393
- start: deserializeU32(pos),
1394
- end: deserializeU32(pos + 4),
1373
+ start: deserializeI32(pos),
1374
+ end: deserializeI32(pos + 4),
1395
1375
  };
1396
1376
  node.init = deserializeOptionForStatementInit(pos + 16);
1397
1377
  node.test = deserializeOptionExpression(pos + 32);
@@ -1501,8 +1481,8 @@ function deserializeForInStatement(pos) {
1501
1481
  left: null,
1502
1482
  right: null,
1503
1483
  body: null,
1504
- start: deserializeU32(pos),
1505
- end: deserializeU32(pos + 4),
1484
+ start: deserializeI32(pos),
1485
+ end: deserializeI32(pos + 4),
1506
1486
  };
1507
1487
  node.left = deserializeForStatementLeft(pos + 16);
1508
1488
  node.right = deserializeExpression(pos + 32);
@@ -1546,8 +1526,8 @@ function deserializeForOfStatement(pos) {
1546
1526
  left: null,
1547
1527
  right: null,
1548
1528
  body: null,
1549
- start: deserializeU32(pos),
1550
- end: deserializeU32(pos + 4),
1529
+ start: deserializeI32(pos),
1530
+ end: deserializeI32(pos + 4),
1551
1531
  };
1552
1532
  node.left = deserializeForStatementLeft(pos + 16);
1553
1533
  node.right = deserializeExpression(pos + 32);
@@ -1559,8 +1539,8 @@ function deserializeContinueStatement(pos) {
1559
1539
  let node = {
1560
1540
  type: "ContinueStatement",
1561
1541
  label: null,
1562
- start: deserializeU32(pos),
1563
- end: deserializeU32(pos + 4),
1542
+ start: deserializeI32(pos),
1543
+ end: deserializeI32(pos + 4),
1564
1544
  };
1565
1545
  node.label = deserializeOptionLabelIdentifier(pos + 16);
1566
1546
  return node;
@@ -1570,8 +1550,8 @@ function deserializeBreakStatement(pos) {
1570
1550
  let node = {
1571
1551
  type: "BreakStatement",
1572
1552
  label: null,
1573
- start: deserializeU32(pos),
1574
- end: deserializeU32(pos + 4),
1553
+ start: deserializeI32(pos),
1554
+ end: deserializeI32(pos + 4),
1575
1555
  };
1576
1556
  node.label = deserializeOptionLabelIdentifier(pos + 16);
1577
1557
  return node;
@@ -1581,8 +1561,8 @@ function deserializeReturnStatement(pos) {
1581
1561
  let node = {
1582
1562
  type: "ReturnStatement",
1583
1563
  argument: null,
1584
- start: deserializeU32(pos),
1585
- end: deserializeU32(pos + 4),
1564
+ start: deserializeI32(pos),
1565
+ end: deserializeI32(pos + 4),
1586
1566
  };
1587
1567
  node.argument = deserializeOptionExpression(pos + 16);
1588
1568
  return node;
@@ -1593,8 +1573,8 @@ function deserializeWithStatement(pos) {
1593
1573
  type: "WithStatement",
1594
1574
  object: null,
1595
1575
  body: null,
1596
- start: deserializeU32(pos),
1597
- end: deserializeU32(pos + 4),
1576
+ start: deserializeI32(pos),
1577
+ end: deserializeI32(pos + 4),
1598
1578
  };
1599
1579
  node.object = deserializeExpression(pos + 16);
1600
1580
  node.body = deserializeStatement(pos + 32);
@@ -1606,8 +1586,8 @@ function deserializeSwitchStatement(pos) {
1606
1586
  type: "SwitchStatement",
1607
1587
  discriminant: null,
1608
1588
  cases: null,
1609
- start: deserializeU32(pos),
1610
- end: deserializeU32(pos + 4),
1589
+ start: deserializeI32(pos),
1590
+ end: deserializeI32(pos + 4),
1611
1591
  };
1612
1592
  node.discriminant = deserializeExpression(pos + 16);
1613
1593
  node.cases = deserializeVecSwitchCase(pos + 32);
@@ -1619,8 +1599,8 @@ function deserializeSwitchCase(pos) {
1619
1599
  type: "SwitchCase",
1620
1600
  test: null,
1621
1601
  consequent: null,
1622
- start: deserializeU32(pos),
1623
- end: deserializeU32(pos + 4),
1602
+ start: deserializeI32(pos),
1603
+ end: deserializeI32(pos + 4),
1624
1604
  };
1625
1605
  node.test = deserializeOptionExpression(pos + 16);
1626
1606
  node.consequent = deserializeVecStatement(pos + 32);
@@ -1632,8 +1612,8 @@ function deserializeLabeledStatement(pos) {
1632
1612
  type: "LabeledStatement",
1633
1613
  label: null,
1634
1614
  body: null,
1635
- start: deserializeU32(pos),
1636
- end: deserializeU32(pos + 4),
1615
+ start: deserializeI32(pos),
1616
+ end: deserializeI32(pos + 4),
1637
1617
  };
1638
1618
  node.label = deserializeLabelIdentifier(pos + 16);
1639
1619
  node.body = deserializeStatement(pos + 48);
@@ -1644,8 +1624,8 @@ function deserializeThrowStatement(pos) {
1644
1624
  let node = {
1645
1625
  type: "ThrowStatement",
1646
1626
  argument: null,
1647
- start: deserializeU32(pos),
1648
- end: deserializeU32(pos + 4),
1627
+ start: deserializeI32(pos),
1628
+ end: deserializeI32(pos + 4),
1649
1629
  };
1650
1630
  node.argument = deserializeExpression(pos + 16);
1651
1631
  return node;
@@ -1657,8 +1637,8 @@ function deserializeTryStatement(pos) {
1657
1637
  block: null,
1658
1638
  handler: null,
1659
1639
  finalizer: null,
1660
- start: deserializeU32(pos),
1661
- end: deserializeU32(pos + 4),
1640
+ start: deserializeI32(pos),
1641
+ end: deserializeI32(pos + 4),
1662
1642
  };
1663
1643
  node.block = deserializeBoxBlockStatement(pos + 16);
1664
1644
  node.handler = deserializeOptionBoxCatchClause(pos + 24);
@@ -1671,8 +1651,8 @@ function deserializeCatchClause(pos) {
1671
1651
  type: "CatchClause",
1672
1652
  param: null,
1673
1653
  body: null,
1674
- start: deserializeU32(pos),
1675
- end: deserializeU32(pos + 4),
1654
+ start: deserializeI32(pos),
1655
+ end: deserializeI32(pos + 4),
1676
1656
  };
1677
1657
  node.param = deserializeOptionCatchParameter(pos + 16);
1678
1658
  node.body = deserializeBoxBlockStatement(pos + 56);
@@ -1692,8 +1672,8 @@ function deserializeCatchParameter(pos) {
1692
1672
  function deserializeDebuggerStatement(pos) {
1693
1673
  return {
1694
1674
  type: "DebuggerStatement",
1695
- start: deserializeU32(pos),
1696
- end: deserializeU32(pos + 4),
1675
+ start: deserializeI32(pos),
1676
+ end: deserializeI32(pos + 4),
1697
1677
  };
1698
1678
  }
1699
1679
 
@@ -1715,94 +1695,83 @@ function deserializeBindingPattern(pos) {
1715
1695
  function deserializeAssignmentPattern(pos) {
1716
1696
  let node = {
1717
1697
  type: "AssignmentPattern",
1718
- decorators: null,
1698
+ decorators: [],
1719
1699
  left: null,
1720
1700
  right: null,
1721
- optional: null,
1701
+ optional: false,
1722
1702
  typeAnnotation: null,
1723
- start: deserializeU32(pos),
1724
- end: deserializeU32(pos + 4),
1703
+ start: deserializeI32(pos),
1704
+ end: deserializeI32(pos + 4),
1725
1705
  };
1726
- node.decorators = [];
1727
1706
  node.left = deserializeBindingPattern(pos + 16);
1728
1707
  node.right = deserializeExpression(pos + 32);
1729
- node.optional = false;
1730
1708
  return node;
1731
1709
  }
1732
1710
 
1733
1711
  function deserializeObjectPattern(pos) {
1734
1712
  let node = {
1735
1713
  type: "ObjectPattern",
1736
- decorators: null,
1714
+ decorators: [],
1737
1715
  properties: null,
1738
- optional: null,
1716
+ optional: false,
1739
1717
  typeAnnotation: null,
1740
- start: deserializeU32(pos),
1741
- end: deserializeU32(pos + 4),
1718
+ start: deserializeI32(pos),
1719
+ end: deserializeI32(pos + 4),
1742
1720
  },
1743
1721
  properties = deserializeVecBindingProperty(pos + 16),
1744
1722
  rest = deserializeOptionBoxBindingRestElement(pos + 40);
1745
1723
  rest !== null && properties.push(rest);
1746
- node.decorators = [];
1747
1724
  node.properties = properties;
1748
- node.optional = false;
1749
1725
  return node;
1750
1726
  }
1751
1727
 
1752
1728
  function deserializeBindingProperty(pos) {
1753
1729
  let node = {
1754
1730
  type: "Property",
1755
- kind: null,
1731
+ kind: "init",
1756
1732
  key: null,
1757
1733
  value: null,
1758
- method: null,
1734
+ method: false,
1759
1735
  shorthand: deserializeBool(pos + 12),
1760
1736
  computed: deserializeBool(pos + 13),
1761
- optional: null,
1762
- start: deserializeU32(pos),
1763
- end: deserializeU32(pos + 4),
1737
+ optional: false,
1738
+ start: deserializeI32(pos),
1739
+ end: deserializeI32(pos + 4),
1764
1740
  };
1765
- node.kind = "init";
1766
1741
  node.key = deserializePropertyKey(pos + 16);
1767
1742
  node.value = deserializeBindingPattern(pos + 32);
1768
- node.method = false;
1769
- node.optional = false;
1770
1743
  return node;
1771
1744
  }
1772
1745
 
1773
1746
  function deserializeArrayPattern(pos) {
1774
1747
  let node = {
1775
1748
  type: "ArrayPattern",
1776
- decorators: null,
1749
+ decorators: [],
1777
1750
  elements: null,
1778
- optional: null,
1751
+ optional: false,
1779
1752
  typeAnnotation: null,
1780
- start: deserializeU32(pos),
1781
- end: deserializeU32(pos + 4),
1753
+ start: deserializeI32(pos),
1754
+ end: deserializeI32(pos + 4),
1782
1755
  },
1783
1756
  elements = deserializeVecOptionBindingPattern(pos + 16),
1784
1757
  rest = deserializeOptionBoxBindingRestElement(pos + 40);
1785
1758
  rest !== null && elements.push(rest);
1786
- node.decorators = [];
1787
1759
  node.elements = elements;
1788
- node.optional = false;
1789
1760
  return node;
1790
1761
  }
1791
1762
 
1792
1763
  function deserializeBindingRestElement(pos) {
1793
1764
  let node = {
1794
1765
  type: "RestElement",
1795
- decorators: null,
1766
+ decorators: [],
1796
1767
  argument: null,
1797
- optional: null,
1768
+ optional: false,
1798
1769
  typeAnnotation: null,
1799
1770
  value: null,
1800
- start: deserializeU32(pos),
1801
- end: deserializeU32(pos + 4),
1771
+ start: deserializeI32(pos),
1772
+ end: deserializeI32(pos + 4),
1802
1773
  };
1803
- node.decorators = [];
1804
1774
  node.argument = deserializeBindingPattern(pos + 16);
1805
- node.optional = false;
1806
1775
  return node;
1807
1776
  }
1808
1777
 
@@ -1817,9 +1786,9 @@ function deserializeFunction(pos) {
1817
1786
  params: null,
1818
1787
  returnType: null,
1819
1788
  body: null,
1820
- expression: null,
1821
- start: deserializeU32(pos),
1822
- end: deserializeU32(pos + 4),
1789
+ expression: false,
1790
+ start: deserializeI32(pos),
1791
+ end: deserializeI32(pos + 4),
1823
1792
  },
1824
1793
  params = deserializeBoxFormalParameters(pos + 64);
1825
1794
  {
@@ -1831,7 +1800,6 @@ function deserializeFunction(pos) {
1831
1800
  node.params = params;
1832
1801
  node.returnType = deserializeOptionBoxTSTypeAnnotation(pos + 72);
1833
1802
  node.body = deserializeOptionBoxFunctionBody(pos + 80);
1834
- node.expression = false;
1835
1803
  return node;
1836
1804
  }
1837
1805
 
@@ -1851,9 +1819,10 @@ function deserializeFunctionType(pos) {
1851
1819
  }
1852
1820
 
1853
1821
  function deserializeFormalParameters(pos) {
1854
- let params = deserializeVecFormalParameter(pos + 16);
1855
- if (uint32[(pos + 40) >> 2] !== 0 && uint32[(pos + 44) >> 2] !== 0) {
1856
- pos = uint32[(pos + 40) >> 2];
1822
+ let params = deserializeVecFormalParameter(pos + 16),
1823
+ restFieldPos32 = (pos >> 2) + 10;
1824
+ if (int32[restFieldPos32] !== 0 && int32[restFieldPos32 + 1] !== 0) {
1825
+ pos = int32[restFieldPos32];
1857
1826
  let end,
1858
1827
  rest = {
1859
1828
  type: "RestElement",
@@ -1862,8 +1831,8 @@ function deserializeFormalParameters(pos) {
1862
1831
  optional: false,
1863
1832
  typeAnnotation: null,
1864
1833
  value: null,
1865
- start: deserializeU32(pos + 40),
1866
- end: (end = deserializeU32(pos + 44)),
1834
+ start: deserializeI32(pos + 40),
1835
+ end: (end = deserializeI32(pos + 44)),
1867
1836
  };
1868
1837
  rest.argument = deserializeBindingPattern(pos + 56);
1869
1838
  rest.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 72);
@@ -1878,7 +1847,8 @@ function deserializeFormalParameters(pos) {
1878
1847
 
1879
1848
  function deserializeFormalParameter(pos) {
1880
1849
  let param,
1881
- hasInitializer = uint32[(pos + 64) >> 2] !== 0 && uint32[(pos + 68) >> 2] !== 0;
1850
+ initializerFieldPos32 = (pos >> 2) + 16,
1851
+ hasInitializer = int32[initializerFieldPos32] !== 0 && int32[initializerFieldPos32 + 1] !== 0;
1882
1852
  {
1883
1853
  let accessibility = deserializeOptionTSAccessibility(pos + 13),
1884
1854
  readonly = deserializeBool(pos + 14),
@@ -1893,8 +1863,8 @@ function deserializeFormalParameter(pos) {
1893
1863
  right: null,
1894
1864
  optional,
1895
1865
  typeAnnotation: null,
1896
- start: deserializeU32(pos),
1897
- end: deserializeU32(pos + 4),
1866
+ start: deserializeI32(pos),
1867
+ end: deserializeI32(pos + 4),
1898
1868
  };
1899
1869
  param.decorators = deserializeVecDecorator(pos + 16);
1900
1870
  param.left = deserializeBindingPattern(pos + 40);
@@ -1911,7 +1881,7 @@ function deserializeFormalParameter(pos) {
1911
1881
  let typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 56);
1912
1882
  param.typeAnnotation = typeAnnotation;
1913
1883
  typeAnnotation === null
1914
- ? optional && (param.end = deserializeU32(pos + 4))
1884
+ ? optional && (param.end = deserializeI32(pos + 4))
1915
1885
  : (param.end = typeAnnotation.end);
1916
1886
  }
1917
1887
  } else {
@@ -1923,8 +1893,8 @@ function deserializeFormalParameter(pos) {
1923
1893
  parameter: null,
1924
1894
  readonly,
1925
1895
  static: false,
1926
- start: deserializeU32(pos),
1927
- end: deserializeU32(pos + 4),
1896
+ start: deserializeI32(pos),
1897
+ end: deserializeI32(pos + 4),
1928
1898
  };
1929
1899
  param.decorators = deserializeVecDecorator(pos + 16);
1930
1900
  if (hasInitializer) {
@@ -1957,7 +1927,7 @@ function deserializeFormalParameter(pos) {
1957
1927
  param.parameter.typeAnnotation = paramTypeAnnotation;
1958
1928
  if (paramTypeAnnotation !== null) param.parameter.end = paramTypeAnnotation.end;
1959
1929
  else if (paramOptional) {
1960
- let paramEnd = deserializeU32(pos + 4);
1930
+ let paramEnd = deserializeI32(pos + 4);
1961
1931
  param.parameter.end = paramEnd;
1962
1932
  }
1963
1933
  }
@@ -1970,8 +1940,8 @@ function deserializeFunctionBody(pos) {
1970
1940
  let node = {
1971
1941
  type: "BlockStatement",
1972
1942
  body: null,
1973
- start: deserializeU32(pos),
1974
- end: deserializeU32(pos + 4),
1943
+ start: deserializeI32(pos),
1944
+ end: deserializeI32(pos + 4),
1975
1945
  },
1976
1946
  body = deserializeVecDirective(pos + 16);
1977
1947
  body.push(...deserializeVecStatement(pos + 40));
@@ -1990,9 +1960,9 @@ function deserializeArrowFunctionExpression(pos) {
1990
1960
  returnType: null,
1991
1961
  body: null,
1992
1962
  id: null,
1993
- generator: null,
1994
- start: deserializeU32(pos),
1995
- end: deserializeU32(pos + 4),
1963
+ generator: false,
1964
+ start: deserializeI32(pos),
1965
+ end: deserializeI32(pos + 4),
1996
1966
  },
1997
1967
  body = deserializeBoxFunctionBody(pos + 40);
1998
1968
  expression === true && (body = body.body[0].expression);
@@ -2000,7 +1970,6 @@ function deserializeArrowFunctionExpression(pos) {
2000
1970
  node.params = deserializeBoxFormalParameters(pos + 24);
2001
1971
  node.returnType = deserializeOptionBoxTSTypeAnnotation(pos + 32);
2002
1972
  node.body = body;
2003
- node.generator = false;
2004
1973
  return node;
2005
1974
  }
2006
1975
 
@@ -2009,8 +1978,8 @@ function deserializeYieldExpression(pos) {
2009
1978
  type: "YieldExpression",
2010
1979
  delegate: deserializeBool(pos + 12),
2011
1980
  argument: null,
2012
- start: deserializeU32(pos),
2013
- end: deserializeU32(pos + 4),
1981
+ start: deserializeI32(pos),
1982
+ end: deserializeI32(pos + 4),
2014
1983
  };
2015
1984
  node.argument = deserializeOptionExpression(pos + 16);
2016
1985
  return node;
@@ -2028,8 +1997,8 @@ function deserializeClass(pos) {
2028
1997
  body: null,
2029
1998
  abstract: deserializeBool(pos + 137),
2030
1999
  declare: deserializeBool(pos + 138),
2031
- start: deserializeU32(pos),
2032
- end: deserializeU32(pos + 4),
2000
+ start: deserializeI32(pos),
2001
+ end: deserializeI32(pos + 4),
2033
2002
  };
2034
2003
  node.decorators = deserializeVecDecorator(pos + 16);
2035
2004
  node.id = deserializeOptionBindingIdentifier(pos + 40);
@@ -2056,8 +2025,8 @@ function deserializeClassBody(pos) {
2056
2025
  let node = {
2057
2026
  type: "ClassBody",
2058
2027
  body: null,
2059
- start: deserializeU32(pos),
2060
- end: deserializeU32(pos + 4),
2028
+ start: deserializeI32(pos),
2029
+ end: deserializeI32(pos + 4),
2061
2030
  };
2062
2031
  node.body = deserializeVecClassElement(pos + 16);
2063
2032
  return node;
@@ -2092,8 +2061,8 @@ function deserializeMethodDefinition(pos) {
2092
2061
  override: deserializeBool(pos + 64),
2093
2062
  optional: deserializeBool(pos + 65),
2094
2063
  accessibility: deserializeOptionTSAccessibility(pos + 66),
2095
- start: deserializeU32(pos),
2096
- end: deserializeU32(pos + 4),
2064
+ start: deserializeI32(pos),
2065
+ end: deserializeI32(pos + 4),
2097
2066
  };
2098
2067
  node.decorators = deserializeVecDecorator(pos + 16);
2099
2068
  node.key = deserializePropertyKey(pos + 40);
@@ -2127,8 +2096,8 @@ function deserializePropertyDefinition(pos) {
2127
2096
  definite: deserializeBool(pos + 82),
2128
2097
  readonly: deserializeBool(pos + 83),
2129
2098
  accessibility: deserializeOptionTSAccessibility(pos + 84),
2130
- start: deserializeU32(pos),
2131
- end: deserializeU32(pos + 4),
2099
+ start: deserializeI32(pos),
2100
+ end: deserializeI32(pos + 4),
2132
2101
  };
2133
2102
  node.decorators = deserializeVecDecorator(pos + 16);
2134
2103
  node.key = deserializePropertyKey(pos + 40);
@@ -2167,8 +2136,8 @@ function deserializePrivateIdentifier(pos) {
2167
2136
  return {
2168
2137
  type: "PrivateIdentifier",
2169
2138
  name: deserializeStr(pos + 16),
2170
- start: deserializeU32(pos),
2171
- end: deserializeU32(pos + 4),
2139
+ start: deserializeI32(pos),
2140
+ end: deserializeI32(pos + 4),
2172
2141
  };
2173
2142
  }
2174
2143
 
@@ -2176,8 +2145,8 @@ function deserializeStaticBlock(pos) {
2176
2145
  let node = {
2177
2146
  type: "StaticBlock",
2178
2147
  body: null,
2179
- start: deserializeU32(pos),
2180
- end: deserializeU32(pos + 4),
2148
+ start: deserializeI32(pos),
2149
+ end: deserializeI32(pos + 4),
2181
2150
  };
2182
2151
  node.body = deserializeVecStatement(pos + 16);
2183
2152
  return node;
@@ -2206,19 +2175,16 @@ function deserializeAccessorProperty(pos) {
2206
2175
  override: deserializeBool(pos + 15),
2207
2176
  definite: deserializeBool(pos + 80),
2208
2177
  accessibility: deserializeOptionTSAccessibility(pos + 81),
2209
- declare: null,
2210
- optional: null,
2211
- readonly: null,
2212
- start: deserializeU32(pos),
2213
- end: deserializeU32(pos + 4),
2178
+ declare: false,
2179
+ optional: false,
2180
+ readonly: false,
2181
+ start: deserializeI32(pos),
2182
+ end: deserializeI32(pos + 4),
2214
2183
  };
2215
2184
  node.decorators = deserializeVecDecorator(pos + 16);
2216
2185
  node.key = deserializePropertyKey(pos + 40);
2217
2186
  node.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 56);
2218
2187
  node.value = deserializeOptionExpression(pos + 64);
2219
- node.declare = false;
2220
- node.optional = false;
2221
- node.readonly = false;
2222
2188
  return node;
2223
2189
  }
2224
2190
 
@@ -2228,8 +2194,8 @@ function deserializeImportExpression(pos) {
2228
2194
  source: null,
2229
2195
  options: null,
2230
2196
  phase: deserializeOptionImportPhase(pos + 12),
2231
- start: deserializeU32(pos),
2232
- end: deserializeU32(pos + 4),
2197
+ start: deserializeI32(pos),
2198
+ end: deserializeI32(pos + 4),
2233
2199
  };
2234
2200
  node.source = deserializeExpression(pos + 16);
2235
2201
  node.options = deserializeOptionExpression(pos + 32);
@@ -2244,8 +2210,8 @@ function deserializeImportDeclaration(pos) {
2244
2210
  phase: deserializeOptionImportPhase(pos + 12),
2245
2211
  attributes: null,
2246
2212
  importKind: deserializeImportOrExportKind(pos + 13),
2247
- start: deserializeU32(pos),
2248
- end: deserializeU32(pos + 4),
2213
+ start: deserializeI32(pos),
2214
+ end: deserializeI32(pos + 4),
2249
2215
  },
2250
2216
  specifiers = deserializeOptionVecImportDeclarationSpecifier(pos + 16);
2251
2217
  specifiers === null && (specifiers = []);
@@ -2286,8 +2252,8 @@ function deserializeImportSpecifier(pos) {
2286
2252
  imported: null,
2287
2253
  local: null,
2288
2254
  importKind: deserializeImportOrExportKind(pos + 12),
2289
- start: deserializeU32(pos),
2290
- end: deserializeU32(pos + 4),
2255
+ start: deserializeI32(pos),
2256
+ end: deserializeI32(pos + 4),
2291
2257
  };
2292
2258
  node.imported = deserializeModuleExportName(pos + 16);
2293
2259
  node.local = deserializeBindingIdentifier(pos + 72);
@@ -2298,8 +2264,8 @@ function deserializeImportDefaultSpecifier(pos) {
2298
2264
  let node = {
2299
2265
  type: "ImportDefaultSpecifier",
2300
2266
  local: null,
2301
- start: deserializeU32(pos),
2302
- end: deserializeU32(pos + 4),
2267
+ start: deserializeI32(pos),
2268
+ end: deserializeI32(pos + 4),
2303
2269
  };
2304
2270
  node.local = deserializeBindingIdentifier(pos + 16);
2305
2271
  return node;
@@ -2309,8 +2275,8 @@ function deserializeImportNamespaceSpecifier(pos) {
2309
2275
  let node = {
2310
2276
  type: "ImportNamespaceSpecifier",
2311
2277
  local: null,
2312
- start: deserializeU32(pos),
2313
- end: deserializeU32(pos + 4),
2278
+ start: deserializeI32(pos),
2279
+ end: deserializeI32(pos + 4),
2314
2280
  };
2315
2281
  node.local = deserializeBindingIdentifier(pos + 16);
2316
2282
  return node;
@@ -2325,8 +2291,8 @@ function deserializeImportAttribute(pos) {
2325
2291
  type: "ImportAttribute",
2326
2292
  key: null,
2327
2293
  value: null,
2328
- start: deserializeU32(pos),
2329
- end: deserializeU32(pos + 4),
2294
+ start: deserializeI32(pos),
2295
+ end: deserializeI32(pos + 4),
2330
2296
  };
2331
2297
  node.key = deserializeImportAttributeKey(pos + 16);
2332
2298
  node.value = deserializeStringLiteral(pos + 72);
@@ -2352,8 +2318,8 @@ function deserializeExportNamedDeclaration(pos) {
2352
2318
  source: null,
2353
2319
  exportKind: deserializeImportOrExportKind(pos + 12),
2354
2320
  attributes: null,
2355
- start: deserializeU32(pos),
2356
- end: deserializeU32(pos + 4),
2321
+ start: deserializeI32(pos),
2322
+ end: deserializeI32(pos + 4),
2357
2323
  },
2358
2324
  withClause = deserializeOptionBoxWithClause(pos + 104);
2359
2325
  node.declaration = deserializeOptionDeclaration(pos + 16);
@@ -2367,12 +2333,11 @@ function deserializeExportDefaultDeclaration(pos) {
2367
2333
  let node = {
2368
2334
  type: "ExportDefaultDeclaration",
2369
2335
  declaration: null,
2370
- exportKind: null,
2371
- start: deserializeU32(pos),
2372
- end: deserializeU32(pos + 4),
2336
+ exportKind: "value",
2337
+ start: deserializeI32(pos),
2338
+ end: deserializeI32(pos + 4),
2373
2339
  };
2374
2340
  node.declaration = deserializeExportDefaultDeclarationKind(pos + 16);
2375
- node.exportKind = "value";
2376
2341
  return node;
2377
2342
  }
2378
2343
 
@@ -2383,8 +2348,8 @@ function deserializeExportAllDeclaration(pos) {
2383
2348
  source: null,
2384
2349
  attributes: null,
2385
2350
  exportKind: deserializeImportOrExportKind(pos + 12),
2386
- start: deserializeU32(pos),
2387
- end: deserializeU32(pos + 4),
2351
+ start: deserializeI32(pos),
2352
+ end: deserializeI32(pos + 4),
2388
2353
  },
2389
2354
  withClause = deserializeOptionBoxWithClause(pos + 120);
2390
2355
  node.exported = deserializeOptionModuleExportName(pos + 16);
@@ -2399,8 +2364,8 @@ function deserializeExportSpecifier(pos) {
2399
2364
  local: null,
2400
2365
  exported: null,
2401
2366
  exportKind: deserializeImportOrExportKind(pos + 12),
2402
- start: deserializeU32(pos),
2403
- end: deserializeU32(pos + 4),
2367
+ start: deserializeI32(pos),
2368
+ end: deserializeI32(pos + 4),
2404
2369
  };
2405
2370
  node.local = deserializeModuleExportName(pos + 16);
2406
2371
  node.exported = deserializeModuleExportName(pos + 72);
@@ -2524,8 +2489,8 @@ function deserializeV8IntrinsicExpression(pos) {
2524
2489
  type: "V8IntrinsicExpression",
2525
2490
  name: null,
2526
2491
  arguments: null,
2527
- start: deserializeU32(pos),
2528
- end: deserializeU32(pos + 4),
2492
+ start: deserializeI32(pos),
2493
+ end: deserializeI32(pos + 4),
2529
2494
  };
2530
2495
  node.name = deserializeIdentifierName(pos + 16);
2531
2496
  node.arguments = deserializeVecArgument(pos + 48);
@@ -2534,8 +2499,8 @@ function deserializeV8IntrinsicExpression(pos) {
2534
2499
 
2535
2500
  function deserializeBooleanLiteral(pos) {
2536
2501
  let value = deserializeBool(pos + 12),
2537
- start = deserializeU32(pos),
2538
- end = deserializeU32(pos + 4),
2502
+ start = deserializeI32(pos),
2503
+ end = deserializeI32(pos + 4),
2539
2504
  node = {
2540
2505
  type: "Literal",
2541
2506
  value,
@@ -2548,36 +2513,44 @@ function deserializeBooleanLiteral(pos) {
2548
2513
  }
2549
2514
 
2550
2515
  function deserializeNullLiteral(pos) {
2551
- let start = deserializeU32(pos),
2552
- end = deserializeU32(pos + 4),
2553
- node = {
2554
- type: "Literal",
2555
- value: null,
2556
- raw: null,
2557
- start,
2558
- end,
2559
- };
2560
- node.raw = start === 0 && end === 0 ? null : "null";
2561
- return node;
2516
+ let start = deserializeI32(pos),
2517
+ end = deserializeI32(pos + 4);
2518
+ return {
2519
+ type: "Literal",
2520
+ value: null,
2521
+ raw: start === 0 && end === 0 ? null : "null",
2522
+ start,
2523
+ end,
2524
+ };
2562
2525
  }
2563
2526
 
2564
2527
  function deserializeNumericLiteral(pos) {
2528
+ let start = deserializeI32(pos),
2529
+ end = deserializeI32(pos + 4);
2565
2530
  return {
2566
2531
  type: "Literal",
2567
2532
  value: deserializeF64(pos + 32),
2568
- raw: deserializeOptionStr(pos + 16),
2569
- start: deserializeU32(pos),
2570
- end: deserializeU32(pos + 4),
2533
+ raw:
2534
+ int32[(pos >> 2) + 4] === 0 && int32[(pos >> 2) + 5] === 0
2535
+ ? null
2536
+ : sourceText.slice(start, end),
2537
+ start,
2538
+ end,
2571
2539
  };
2572
2540
  }
2573
2541
 
2574
2542
  function deserializeStringLiteral(pos) {
2575
- let node = {
2543
+ let start = deserializeI32(pos),
2544
+ end = deserializeI32(pos + 4),
2545
+ node = {
2576
2546
  type: "Literal",
2577
2547
  value: null,
2578
- raw: deserializeOptionStr(pos + 32),
2579
- start: deserializeU32(pos),
2580
- end: deserializeU32(pos + 4),
2548
+ raw:
2549
+ int32[(pos >> 2) + 8] === 0 && int32[(pos >> 2) + 9] === 0
2550
+ ? null
2551
+ : sourceText.slice(start, end),
2552
+ start,
2553
+ end,
2581
2554
  },
2582
2555
  value = deserializeStr(pos + 16);
2583
2556
  deserializeBool(pos + 12) &&
@@ -2587,28 +2560,35 @@ function deserializeStringLiteral(pos) {
2587
2560
  }
2588
2561
 
2589
2562
  function deserializeBigIntLiteral(pos) {
2590
- let node = {
2591
- type: "Literal",
2592
- value: null,
2593
- raw: deserializeOptionStr(pos + 32),
2594
- bigint: null,
2595
- start: deserializeU32(pos),
2596
- end: deserializeU32(pos + 4),
2597
- },
2563
+ let start = deserializeI32(pos),
2564
+ end = deserializeI32(pos + 4),
2598
2565
  bigint = deserializeStr(pos + 16);
2599
- node.value = BigInt(bigint);
2600
- node.bigint = bigint;
2601
- return node;
2566
+ return {
2567
+ type: "Literal",
2568
+ value: BigInt(bigint),
2569
+ raw:
2570
+ int32[(pos >> 2) + 8] === 0 && int32[(pos >> 2) + 9] === 0
2571
+ ? null
2572
+ : sourceText.slice(start, end),
2573
+ bigint,
2574
+ start,
2575
+ end,
2576
+ };
2602
2577
  }
2603
2578
 
2604
2579
  function deserializeRegExpLiteral(pos) {
2605
- let node = {
2580
+ let start = deserializeI32(pos),
2581
+ end = deserializeI32(pos + 4),
2582
+ node = {
2606
2583
  type: "Literal",
2607
2584
  value: null,
2608
- raw: deserializeOptionStr(pos + 48),
2585
+ raw:
2586
+ int32[(pos >> 2) + 12] === 0 && int32[(pos >> 2) + 13] === 0
2587
+ ? null
2588
+ : sourceText.slice(start, end),
2609
2589
  regex: null,
2610
- start: deserializeU32(pos),
2611
- end: deserializeU32(pos + 4),
2590
+ start,
2591
+ end,
2612
2592
  },
2613
2593
  regex = deserializeRegExp(pos + 16),
2614
2594
  value = null;
@@ -2648,8 +2628,8 @@ function deserializeJSXElement(pos) {
2648
2628
  openingElement: null,
2649
2629
  children: null,
2650
2630
  closingElement: null,
2651
- start: deserializeU32(pos),
2652
- end: deserializeU32(pos + 4),
2631
+ start: deserializeI32(pos),
2632
+ end: deserializeI32(pos + 4),
2653
2633
  },
2654
2634
  closingElement = deserializeOptionBoxJSXClosingElement(pos + 48),
2655
2635
  openingElement = deserializeBoxJSXOpeningElement(pos + 16);
@@ -2666,14 +2646,13 @@ function deserializeJSXOpeningElement(pos) {
2666
2646
  name: null,
2667
2647
  typeArguments: null,
2668
2648
  attributes: null,
2669
- selfClosing: null,
2670
- start: deserializeU32(pos),
2671
- end: deserializeU32(pos + 4),
2649
+ selfClosing: false,
2650
+ start: deserializeI32(pos),
2651
+ end: deserializeI32(pos + 4),
2672
2652
  };
2673
2653
  node.name = deserializeJSXElementName(pos + 16);
2674
2654
  node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 32);
2675
2655
  node.attributes = deserializeVecJSXAttributeItem(pos + 40);
2676
- node.selfClosing = false;
2677
2656
  return node;
2678
2657
  }
2679
2658
 
@@ -2681,8 +2660,8 @@ function deserializeJSXClosingElement(pos) {
2681
2660
  let node = {
2682
2661
  type: "JSXClosingElement",
2683
2662
  name: null,
2684
- start: deserializeU32(pos),
2685
- end: deserializeU32(pos + 4),
2663
+ start: deserializeI32(pos),
2664
+ end: deserializeI32(pos + 4),
2686
2665
  };
2687
2666
  node.name = deserializeJSXElementName(pos + 16);
2688
2667
  return node;
@@ -2694,8 +2673,8 @@ function deserializeJSXFragment(pos) {
2694
2673
  openingFragment: null,
2695
2674
  children: null,
2696
2675
  closingFragment: null,
2697
- start: deserializeU32(pos),
2698
- end: deserializeU32(pos + 4),
2676
+ start: deserializeI32(pos),
2677
+ end: deserializeI32(pos + 4),
2699
2678
  };
2700
2679
  node.openingFragment = deserializeJSXOpeningFragment(pos + 16);
2701
2680
  node.children = deserializeVecJSXChild(pos + 32);
@@ -2706,16 +2685,16 @@ function deserializeJSXFragment(pos) {
2706
2685
  function deserializeJSXOpeningFragment(pos) {
2707
2686
  return {
2708
2687
  type: "JSXOpeningFragment",
2709
- start: deserializeU32(pos),
2710
- end: deserializeU32(pos + 4),
2688
+ start: deserializeI32(pos),
2689
+ end: deserializeI32(pos + 4),
2711
2690
  };
2712
2691
  }
2713
2692
 
2714
2693
  function deserializeJSXClosingFragment(pos) {
2715
2694
  return {
2716
2695
  type: "JSXClosingFragment",
2717
- start: deserializeU32(pos),
2718
- end: deserializeU32(pos + 4),
2696
+ start: deserializeI32(pos),
2697
+ end: deserializeI32(pos + 4),
2719
2698
  };
2720
2699
  }
2721
2700
 
@@ -2753,8 +2732,8 @@ function deserializeJSXNamespacedName(pos) {
2753
2732
  type: "JSXNamespacedName",
2754
2733
  namespace: null,
2755
2734
  name: null,
2756
- start: deserializeU32(pos),
2757
- end: deserializeU32(pos + 4),
2735
+ start: deserializeI32(pos),
2736
+ end: deserializeI32(pos + 4),
2758
2737
  };
2759
2738
  node.namespace = deserializeJSXIdentifier(pos + 16);
2760
2739
  node.name = deserializeJSXIdentifier(pos + 48);
@@ -2766,8 +2745,8 @@ function deserializeJSXMemberExpression(pos) {
2766
2745
  type: "JSXMemberExpression",
2767
2746
  object: null,
2768
2747
  property: null,
2769
- start: deserializeU32(pos),
2770
- end: deserializeU32(pos + 4),
2748
+ start: deserializeI32(pos),
2749
+ end: deserializeI32(pos + 4),
2771
2750
  };
2772
2751
  node.object = deserializeJSXMemberExpressionObject(pos + 16);
2773
2752
  node.property = deserializeJSXIdentifier(pos + 32);
@@ -2803,8 +2782,8 @@ function deserializeJSXExpressionContainer(pos) {
2803
2782
  let node = {
2804
2783
  type: "JSXExpressionContainer",
2805
2784
  expression: null,
2806
- start: deserializeU32(pos),
2807
- end: deserializeU32(pos + 4),
2785
+ start: deserializeI32(pos),
2786
+ end: deserializeI32(pos + 4),
2808
2787
  };
2809
2788
  node.expression = deserializeJSXExpression(pos + 16);
2810
2789
  return node;
@@ -2908,8 +2887,8 @@ function deserializeJSXExpression(pos) {
2908
2887
  function deserializeJSXEmptyExpression(pos) {
2909
2888
  return {
2910
2889
  type: "JSXEmptyExpression",
2911
- start: deserializeU32(pos),
2912
- end: deserializeU32(pos + 4),
2890
+ start: deserializeI32(pos),
2891
+ end: deserializeI32(pos + 4),
2913
2892
  };
2914
2893
  }
2915
2894
 
@@ -2929,8 +2908,8 @@ function deserializeJSXAttribute(pos) {
2929
2908
  type: "JSXAttribute",
2930
2909
  name: null,
2931
2910
  value: null,
2932
- start: deserializeU32(pos),
2933
- end: deserializeU32(pos + 4),
2911
+ start: deserializeI32(pos),
2912
+ end: deserializeI32(pos + 4),
2934
2913
  };
2935
2914
  node.name = deserializeJSXAttributeName(pos + 16);
2936
2915
  node.value = deserializeOptionJSXAttributeValue(pos + 32);
@@ -2941,8 +2920,8 @@ function deserializeJSXSpreadAttribute(pos) {
2941
2920
  let node = {
2942
2921
  type: "JSXSpreadAttribute",
2943
2922
  argument: null,
2944
- start: deserializeU32(pos),
2945
- end: deserializeU32(pos + 4),
2923
+ start: deserializeI32(pos),
2924
+ end: deserializeI32(pos + 4),
2946
2925
  };
2947
2926
  node.argument = deserializeExpression(pos + 16);
2948
2927
  return node;
@@ -2978,8 +2957,8 @@ function deserializeJSXIdentifier(pos) {
2978
2957
  return {
2979
2958
  type: "JSXIdentifier",
2980
2959
  name: deserializeStr(pos + 16),
2981
- start: deserializeU32(pos),
2982
- end: deserializeU32(pos + 4),
2960
+ start: deserializeI32(pos),
2961
+ end: deserializeI32(pos + 4),
2983
2962
  };
2984
2963
  }
2985
2964
 
@@ -3004,36 +2983,38 @@ function deserializeJSXSpreadChild(pos) {
3004
2983
  let node = {
3005
2984
  type: "JSXSpreadChild",
3006
2985
  expression: null,
3007
- start: deserializeU32(pos),
3008
- end: deserializeU32(pos + 4),
2986
+ start: deserializeI32(pos),
2987
+ end: deserializeI32(pos + 4),
3009
2988
  };
3010
2989
  node.expression = deserializeExpression(pos + 16);
3011
2990
  return node;
3012
2991
  }
3013
2992
 
3014
2993
  function deserializeJSXText(pos) {
2994
+ let start = deserializeI32(pos),
2995
+ end = deserializeI32(pos + 4);
3015
2996
  return {
3016
2997
  type: "JSXText",
3017
2998
  value: deserializeStr(pos + 16),
3018
- raw: deserializeOptionStr(pos + 32),
3019
- start: deserializeU32(pos),
3020
- end: deserializeU32(pos + 4),
2999
+ raw:
3000
+ int32[(pos >> 2) + 8] === 0 && int32[(pos >> 2) + 9] === 0
3001
+ ? null
3002
+ : sourceText.slice(start, end),
3003
+ start,
3004
+ end,
3021
3005
  };
3022
3006
  }
3023
3007
 
3024
3008
  function deserializeTSThisParameter(pos) {
3025
3009
  let node = {
3026
3010
  type: "Identifier",
3027
- decorators: null,
3028
- name: null,
3029
- optional: null,
3011
+ decorators: [],
3012
+ name: "this",
3013
+ optional: false,
3030
3014
  typeAnnotation: null,
3031
- start: deserializeU32(pos),
3032
- end: deserializeU32(pos + 4),
3015
+ start: deserializeI32(pos),
3016
+ end: deserializeI32(pos + 4),
3033
3017
  };
3034
- node.decorators = [];
3035
- node.name = "this";
3036
- node.optional = false;
3037
3018
  node.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 24);
3038
3019
  return node;
3039
3020
  }
@@ -3045,8 +3026,8 @@ function deserializeTSEnumDeclaration(pos) {
3045
3026
  body: null,
3046
3027
  const: deserializeBool(pos + 12),
3047
3028
  declare: deserializeBool(pos + 13),
3048
- start: deserializeU32(pos),
3049
- end: deserializeU32(pos + 4),
3029
+ start: deserializeI32(pos),
3030
+ end: deserializeI32(pos + 4),
3050
3031
  };
3051
3032
  node.id = deserializeBindingIdentifier(pos + 16);
3052
3033
  node.body = deserializeTSEnumBody(pos + 48);
@@ -3057,8 +3038,8 @@ function deserializeTSEnumBody(pos) {
3057
3038
  let node = {
3058
3039
  type: "TSEnumBody",
3059
3040
  members: null,
3060
- start: deserializeU32(pos),
3061
- end: deserializeU32(pos + 4),
3041
+ start: deserializeI32(pos),
3042
+ end: deserializeI32(pos + 4),
3062
3043
  };
3063
3044
  node.members = deserializeVecTSEnumMember(pos + 16);
3064
3045
  return node;
@@ -3069,13 +3050,12 @@ function deserializeTSEnumMember(pos) {
3069
3050
  type: "TSEnumMember",
3070
3051
  id: null,
3071
3052
  initializer: null,
3072
- computed: null,
3073
- start: deserializeU32(pos),
3074
- end: deserializeU32(pos + 4),
3053
+ computed: deserializeU8(pos + 16) > 1,
3054
+ start: deserializeI32(pos),
3055
+ end: deserializeI32(pos + 4),
3075
3056
  };
3076
3057
  node.id = deserializeTSEnumMemberName(pos + 16);
3077
3058
  node.initializer = deserializeOptionExpression(pos + 32);
3078
- node.computed = deserializeU8(pos + 16) > 1;
3079
3059
  return node;
3080
3060
  }
3081
3061
 
@@ -3098,8 +3078,8 @@ function deserializeTSTypeAnnotation(pos) {
3098
3078
  let node = {
3099
3079
  type: "TSTypeAnnotation",
3100
3080
  typeAnnotation: null,
3101
- start: deserializeU32(pos),
3102
- end: deserializeU32(pos + 4),
3081
+ start: deserializeI32(pos),
3082
+ end: deserializeI32(pos + 4),
3103
3083
  };
3104
3084
  node.typeAnnotation = deserializeTSType(pos + 16);
3105
3085
  return node;
@@ -3109,8 +3089,8 @@ function deserializeTSLiteralType(pos) {
3109
3089
  let node = {
3110
3090
  type: "TSLiteralType",
3111
3091
  literal: null,
3112
- start: deserializeU32(pos),
3113
- end: deserializeU32(pos + 4),
3092
+ start: deserializeI32(pos),
3093
+ end: deserializeI32(pos + 4),
3114
3094
  };
3115
3095
  node.literal = deserializeTSLiteral(pos + 16);
3116
3096
  return node;
@@ -3223,8 +3203,8 @@ function deserializeTSConditionalType(pos) {
3223
3203
  extendsType: null,
3224
3204
  trueType: null,
3225
3205
  falseType: null,
3226
- start: deserializeU32(pos),
3227
- end: deserializeU32(pos + 4),
3206
+ start: deserializeI32(pos),
3207
+ end: deserializeI32(pos + 4),
3228
3208
  };
3229
3209
  node.checkType = deserializeTSType(pos + 16);
3230
3210
  node.extendsType = deserializeTSType(pos + 32);
@@ -3237,8 +3217,8 @@ function deserializeTSUnionType(pos) {
3237
3217
  let node = {
3238
3218
  type: "TSUnionType",
3239
3219
  types: null,
3240
- start: deserializeU32(pos),
3241
- end: deserializeU32(pos + 4),
3220
+ start: deserializeI32(pos),
3221
+ end: deserializeI32(pos + 4),
3242
3222
  };
3243
3223
  node.types = deserializeVecTSType(pos + 16);
3244
3224
  return node;
@@ -3248,8 +3228,8 @@ function deserializeTSIntersectionType(pos) {
3248
3228
  let node = {
3249
3229
  type: "TSIntersectionType",
3250
3230
  types: null,
3251
- start: deserializeU32(pos),
3252
- end: deserializeU32(pos + 4),
3231
+ start: deserializeI32(pos),
3232
+ end: deserializeI32(pos + 4),
3253
3233
  };
3254
3234
  node.types = deserializeVecTSType(pos + 16);
3255
3235
  return node;
@@ -3260,8 +3240,8 @@ function deserializeTSParenthesizedType(pos) {
3260
3240
  node = {
3261
3241
  type: "TSParenthesizedType",
3262
3242
  typeAnnotation: null,
3263
- start: deserializeU32(pos),
3264
- end: deserializeU32(pos + 4),
3243
+ start: deserializeI32(pos),
3244
+ end: deserializeI32(pos + 4),
3265
3245
  };
3266
3246
  node.typeAnnotation = deserializeTSType(pos + 16);
3267
3247
  return node;
@@ -3272,8 +3252,8 @@ function deserializeTSTypeOperator(pos) {
3272
3252
  type: "TSTypeOperator",
3273
3253
  operator: deserializeTSTypeOperatorOperator(pos + 12),
3274
3254
  typeAnnotation: null,
3275
- start: deserializeU32(pos),
3276
- end: deserializeU32(pos + 4),
3255
+ start: deserializeI32(pos),
3256
+ end: deserializeI32(pos + 4),
3277
3257
  };
3278
3258
  node.typeAnnotation = deserializeTSType(pos + 16);
3279
3259
  return node;
@@ -3296,8 +3276,8 @@ function deserializeTSArrayType(pos) {
3296
3276
  let node = {
3297
3277
  type: "TSArrayType",
3298
3278
  elementType: null,
3299
- start: deserializeU32(pos),
3300
- end: deserializeU32(pos + 4),
3279
+ start: deserializeI32(pos),
3280
+ end: deserializeI32(pos + 4),
3301
3281
  };
3302
3282
  node.elementType = deserializeTSType(pos + 16);
3303
3283
  return node;
@@ -3308,8 +3288,8 @@ function deserializeTSIndexedAccessType(pos) {
3308
3288
  type: "TSIndexedAccessType",
3309
3289
  objectType: null,
3310
3290
  indexType: null,
3311
- start: deserializeU32(pos),
3312
- end: deserializeU32(pos + 4),
3291
+ start: deserializeI32(pos),
3292
+ end: deserializeI32(pos + 4),
3313
3293
  };
3314
3294
  node.objectType = deserializeTSType(pos + 16);
3315
3295
  node.indexType = deserializeTSType(pos + 32);
@@ -3320,8 +3300,8 @@ function deserializeTSTupleType(pos) {
3320
3300
  let node = {
3321
3301
  type: "TSTupleType",
3322
3302
  elementTypes: null,
3323
- start: deserializeU32(pos),
3324
- end: deserializeU32(pos + 4),
3303
+ start: deserializeI32(pos),
3304
+ end: deserializeI32(pos + 4),
3325
3305
  };
3326
3306
  node.elementTypes = deserializeVecTSTupleElement(pos + 16);
3327
3307
  return node;
@@ -3333,8 +3313,8 @@ function deserializeTSNamedTupleMember(pos) {
3333
3313
  label: null,
3334
3314
  elementType: null,
3335
3315
  optional: deserializeBool(pos + 12),
3336
- start: deserializeU32(pos),
3337
- end: deserializeU32(pos + 4),
3316
+ start: deserializeI32(pos),
3317
+ end: deserializeI32(pos + 4),
3338
3318
  };
3339
3319
  node.label = deserializeIdentifierName(pos + 16);
3340
3320
  node.elementType = deserializeTSTupleElement(pos + 48);
@@ -3345,8 +3325,8 @@ function deserializeTSOptionalType(pos) {
3345
3325
  let node = {
3346
3326
  type: "TSOptionalType",
3347
3327
  typeAnnotation: null,
3348
- start: deserializeU32(pos),
3349
- end: deserializeU32(pos + 4),
3328
+ start: deserializeI32(pos),
3329
+ end: deserializeI32(pos + 4),
3350
3330
  };
3351
3331
  node.typeAnnotation = deserializeTSType(pos + 16);
3352
3332
  return node;
@@ -3356,8 +3336,8 @@ function deserializeTSRestType(pos) {
3356
3336
  let node = {
3357
3337
  type: "TSRestType",
3358
3338
  typeAnnotation: null,
3359
- start: deserializeU32(pos),
3360
- end: deserializeU32(pos + 4),
3339
+ start: deserializeI32(pos),
3340
+ end: deserializeI32(pos + 4),
3361
3341
  };
3362
3342
  node.typeAnnotation = deserializeTSType(pos + 16);
3363
3343
  return node;
@@ -3451,112 +3431,112 @@ function deserializeTSTupleElement(pos) {
3451
3431
  function deserializeTSAnyKeyword(pos) {
3452
3432
  return {
3453
3433
  type: "TSAnyKeyword",
3454
- start: deserializeU32(pos),
3455
- end: deserializeU32(pos + 4),
3434
+ start: deserializeI32(pos),
3435
+ end: deserializeI32(pos + 4),
3456
3436
  };
3457
3437
  }
3458
3438
 
3459
3439
  function deserializeTSStringKeyword(pos) {
3460
3440
  return {
3461
3441
  type: "TSStringKeyword",
3462
- start: deserializeU32(pos),
3463
- end: deserializeU32(pos + 4),
3442
+ start: deserializeI32(pos),
3443
+ end: deserializeI32(pos + 4),
3464
3444
  };
3465
3445
  }
3466
3446
 
3467
3447
  function deserializeTSBooleanKeyword(pos) {
3468
3448
  return {
3469
3449
  type: "TSBooleanKeyword",
3470
- start: deserializeU32(pos),
3471
- end: deserializeU32(pos + 4),
3450
+ start: deserializeI32(pos),
3451
+ end: deserializeI32(pos + 4),
3472
3452
  };
3473
3453
  }
3474
3454
 
3475
3455
  function deserializeTSNumberKeyword(pos) {
3476
3456
  return {
3477
3457
  type: "TSNumberKeyword",
3478
- start: deserializeU32(pos),
3479
- end: deserializeU32(pos + 4),
3458
+ start: deserializeI32(pos),
3459
+ end: deserializeI32(pos + 4),
3480
3460
  };
3481
3461
  }
3482
3462
 
3483
3463
  function deserializeTSNeverKeyword(pos) {
3484
3464
  return {
3485
3465
  type: "TSNeverKeyword",
3486
- start: deserializeU32(pos),
3487
- end: deserializeU32(pos + 4),
3466
+ start: deserializeI32(pos),
3467
+ end: deserializeI32(pos + 4),
3488
3468
  };
3489
3469
  }
3490
3470
 
3491
3471
  function deserializeTSIntrinsicKeyword(pos) {
3492
3472
  return {
3493
3473
  type: "TSIntrinsicKeyword",
3494
- start: deserializeU32(pos),
3495
- end: deserializeU32(pos + 4),
3474
+ start: deserializeI32(pos),
3475
+ end: deserializeI32(pos + 4),
3496
3476
  };
3497
3477
  }
3498
3478
 
3499
3479
  function deserializeTSUnknownKeyword(pos) {
3500
3480
  return {
3501
3481
  type: "TSUnknownKeyword",
3502
- start: deserializeU32(pos),
3503
- end: deserializeU32(pos + 4),
3482
+ start: deserializeI32(pos),
3483
+ end: deserializeI32(pos + 4),
3504
3484
  };
3505
3485
  }
3506
3486
 
3507
3487
  function deserializeTSNullKeyword(pos) {
3508
3488
  return {
3509
3489
  type: "TSNullKeyword",
3510
- start: deserializeU32(pos),
3511
- end: deserializeU32(pos + 4),
3490
+ start: deserializeI32(pos),
3491
+ end: deserializeI32(pos + 4),
3512
3492
  };
3513
3493
  }
3514
3494
 
3515
3495
  function deserializeTSUndefinedKeyword(pos) {
3516
3496
  return {
3517
3497
  type: "TSUndefinedKeyword",
3518
- start: deserializeU32(pos),
3519
- end: deserializeU32(pos + 4),
3498
+ start: deserializeI32(pos),
3499
+ end: deserializeI32(pos + 4),
3520
3500
  };
3521
3501
  }
3522
3502
 
3523
3503
  function deserializeTSVoidKeyword(pos) {
3524
3504
  return {
3525
3505
  type: "TSVoidKeyword",
3526
- start: deserializeU32(pos),
3527
- end: deserializeU32(pos + 4),
3506
+ start: deserializeI32(pos),
3507
+ end: deserializeI32(pos + 4),
3528
3508
  };
3529
3509
  }
3530
3510
 
3531
3511
  function deserializeTSSymbolKeyword(pos) {
3532
3512
  return {
3533
3513
  type: "TSSymbolKeyword",
3534
- start: deserializeU32(pos),
3535
- end: deserializeU32(pos + 4),
3514
+ start: deserializeI32(pos),
3515
+ end: deserializeI32(pos + 4),
3536
3516
  };
3537
3517
  }
3538
3518
 
3539
3519
  function deserializeTSThisType(pos) {
3540
3520
  return {
3541
3521
  type: "TSThisType",
3542
- start: deserializeU32(pos),
3543
- end: deserializeU32(pos + 4),
3522
+ start: deserializeI32(pos),
3523
+ end: deserializeI32(pos + 4),
3544
3524
  };
3545
3525
  }
3546
3526
 
3547
3527
  function deserializeTSObjectKeyword(pos) {
3548
3528
  return {
3549
3529
  type: "TSObjectKeyword",
3550
- start: deserializeU32(pos),
3551
- end: deserializeU32(pos + 4),
3530
+ start: deserializeI32(pos),
3531
+ end: deserializeI32(pos + 4),
3552
3532
  };
3553
3533
  }
3554
3534
 
3555
3535
  function deserializeTSBigIntKeyword(pos) {
3556
3536
  return {
3557
3537
  type: "TSBigIntKeyword",
3558
- start: deserializeU32(pos),
3559
- end: deserializeU32(pos + 4),
3538
+ start: deserializeI32(pos),
3539
+ end: deserializeI32(pos + 4),
3560
3540
  };
3561
3541
  }
3562
3542
 
@@ -3565,8 +3545,8 @@ function deserializeTSTypeReference(pos) {
3565
3545
  type: "TSTypeReference",
3566
3546
  typeName: null,
3567
3547
  typeArguments: null,
3568
- start: deserializeU32(pos),
3569
- end: deserializeU32(pos + 4),
3548
+ start: deserializeI32(pos),
3549
+ end: deserializeI32(pos + 4),
3570
3550
  };
3571
3551
  node.typeName = deserializeTSTypeName(pos + 16);
3572
3552
  node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 32);
@@ -3591,8 +3571,8 @@ function deserializeTSQualifiedName(pos) {
3591
3571
  type: "TSQualifiedName",
3592
3572
  left: null,
3593
3573
  right: null,
3594
- start: deserializeU32(pos),
3595
- end: deserializeU32(pos + 4),
3574
+ start: deserializeI32(pos),
3575
+ end: deserializeI32(pos + 4),
3596
3576
  };
3597
3577
  node.left = deserializeTSTypeName(pos + 16);
3598
3578
  node.right = deserializeIdentifierName(pos + 32);
@@ -3603,8 +3583,8 @@ function deserializeTSTypeParameterInstantiation(pos) {
3603
3583
  let node = {
3604
3584
  type: "TSTypeParameterInstantiation",
3605
3585
  params: null,
3606
- start: deserializeU32(pos),
3607
- end: deserializeU32(pos + 4),
3586
+ start: deserializeI32(pos),
3587
+ end: deserializeI32(pos + 4),
3608
3588
  };
3609
3589
  node.params = deserializeVecTSType(pos + 16);
3610
3590
  return node;
@@ -3619,8 +3599,8 @@ function deserializeTSTypeParameter(pos) {
3619
3599
  in: deserializeBool(pos + 12),
3620
3600
  out: deserializeBool(pos + 13),
3621
3601
  const: deserializeBool(pos + 14),
3622
- start: deserializeU32(pos),
3623
- end: deserializeU32(pos + 4),
3602
+ start: deserializeI32(pos),
3603
+ end: deserializeI32(pos + 4),
3624
3604
  };
3625
3605
  node.name = deserializeBindingIdentifier(pos + 16);
3626
3606
  node.constraint = deserializeOptionTSType(pos + 48);
@@ -3632,8 +3612,8 @@ function deserializeTSTypeParameterDeclaration(pos) {
3632
3612
  let node = {
3633
3613
  type: "TSTypeParameterDeclaration",
3634
3614
  params: null,
3635
- start: deserializeU32(pos),
3636
- end: deserializeU32(pos + 4),
3615
+ start: deserializeI32(pos),
3616
+ end: deserializeI32(pos + 4),
3637
3617
  };
3638
3618
  node.params = deserializeVecTSTypeParameter(pos + 16);
3639
3619
  return node;
@@ -3646,8 +3626,8 @@ function deserializeTSTypeAliasDeclaration(pos) {
3646
3626
  typeParameters: null,
3647
3627
  typeAnnotation: null,
3648
3628
  declare: deserializeBool(pos + 72),
3649
- start: deserializeU32(pos),
3650
- end: deserializeU32(pos + 4),
3629
+ start: deserializeI32(pos),
3630
+ end: deserializeI32(pos + 4),
3651
3631
  };
3652
3632
  node.id = deserializeBindingIdentifier(pos + 16);
3653
3633
  node.typeParameters = deserializeOptionBoxTSTypeParameterDeclaration(pos + 48);
@@ -3673,8 +3653,8 @@ function deserializeTSClassImplements(pos) {
3673
3653
  type: "TSClassImplements",
3674
3654
  expression: null,
3675
3655
  typeArguments: null,
3676
- start: deserializeU32(pos),
3677
- end: deserializeU32(pos + 4),
3656
+ start: deserializeI32(pos),
3657
+ end: deserializeI32(pos + 4),
3678
3658
  },
3679
3659
  expression = deserializeTSTypeName(pos + 16);
3680
3660
  if (expression.type === "TSQualifiedName") {
@@ -3716,8 +3696,8 @@ function deserializeTSInterfaceDeclaration(pos) {
3716
3696
  extends: null,
3717
3697
  body: null,
3718
3698
  declare: deserializeBool(pos + 88),
3719
- start: deserializeU32(pos),
3720
- end: deserializeU32(pos + 4),
3699
+ start: deserializeI32(pos),
3700
+ end: deserializeI32(pos + 4),
3721
3701
  };
3722
3702
  node.id = deserializeBindingIdentifier(pos + 16);
3723
3703
  node.typeParameters = deserializeOptionBoxTSTypeParameterDeclaration(pos + 48);
@@ -3730,8 +3710,8 @@ function deserializeTSInterfaceBody(pos) {
3730
3710
  let node = {
3731
3711
  type: "TSInterfaceBody",
3732
3712
  body: null,
3733
- start: deserializeU32(pos),
3734
- end: deserializeU32(pos + 4),
3713
+ start: deserializeI32(pos),
3714
+ end: deserializeI32(pos + 4),
3735
3715
  };
3736
3716
  node.body = deserializeVecTSSignature(pos + 16);
3737
3717
  return node;
@@ -3746,13 +3726,12 @@ function deserializeTSPropertySignature(pos) {
3746
3726
  key: null,
3747
3727
  typeAnnotation: null,
3748
3728
  accessibility: null,
3749
- static: null,
3750
- start: deserializeU32(pos),
3751
- end: deserializeU32(pos + 4),
3729
+ static: false,
3730
+ start: deserializeI32(pos),
3731
+ end: deserializeI32(pos + 4),
3752
3732
  };
3753
3733
  node.key = deserializePropertyKey(pos + 16);
3754
3734
  node.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 32);
3755
- node.static = false;
3756
3735
  return node;
3757
3736
  }
3758
3737
 
@@ -3781,8 +3760,8 @@ function deserializeTSIndexSignature(pos) {
3781
3760
  readonly: deserializeBool(pos + 12),
3782
3761
  static: deserializeBool(pos + 13),
3783
3762
  accessibility: null,
3784
- start: deserializeU32(pos),
3785
- end: deserializeU32(pos + 4),
3763
+ start: deserializeI32(pos),
3764
+ end: deserializeI32(pos + 4),
3786
3765
  };
3787
3766
  node.parameters = deserializeVecTSIndexSignatureName(pos + 16);
3788
3767
  node.typeAnnotation = deserializeBoxTSTypeAnnotation(pos + 40);
@@ -3795,8 +3774,8 @@ function deserializeTSCallSignatureDeclaration(pos) {
3795
3774
  typeParameters: null,
3796
3775
  params: null,
3797
3776
  returnType: null,
3798
- start: deserializeU32(pos),
3799
- end: deserializeU32(pos + 4),
3777
+ start: deserializeI32(pos),
3778
+ end: deserializeI32(pos + 4),
3800
3779
  },
3801
3780
  params = deserializeBoxFormalParameters(pos + 32),
3802
3781
  thisParam = deserializeOptionBoxTSThisParameter(pos + 24);
@@ -3831,10 +3810,10 @@ function deserializeTSMethodSignature(pos) {
3831
3810
  params: null,
3832
3811
  returnType: null,
3833
3812
  accessibility: null,
3834
- readonly: null,
3835
- static: null,
3836
- start: deserializeU32(pos),
3837
- end: deserializeU32(pos + 4),
3813
+ readonly: false,
3814
+ static: false,
3815
+ start: deserializeI32(pos),
3816
+ end: deserializeI32(pos + 4),
3838
3817
  },
3839
3818
  params = deserializeBoxFormalParameters(pos + 48),
3840
3819
  thisParam = deserializeOptionBoxTSThisParameter(pos + 40);
@@ -3843,8 +3822,6 @@ function deserializeTSMethodSignature(pos) {
3843
3822
  node.typeParameters = deserializeOptionBoxTSTypeParameterDeclaration(pos + 32);
3844
3823
  node.params = params;
3845
3824
  node.returnType = deserializeOptionBoxTSTypeAnnotation(pos + 56);
3846
- node.readonly = false;
3847
- node.static = false;
3848
3825
  return node;
3849
3826
  }
3850
3827
 
@@ -3854,8 +3831,8 @@ function deserializeTSConstructSignatureDeclaration(pos) {
3854
3831
  typeParameters: null,
3855
3832
  params: null,
3856
3833
  returnType: null,
3857
- start: deserializeU32(pos),
3858
- end: deserializeU32(pos + 4),
3834
+ start: deserializeI32(pos),
3835
+ end: deserializeI32(pos + 4),
3859
3836
  };
3860
3837
  node.typeParameters = deserializeOptionBoxTSTypeParameterDeclaration(pos + 16);
3861
3838
  node.params = deserializeBoxFormalParameters(pos + 24);
@@ -3866,15 +3843,13 @@ function deserializeTSConstructSignatureDeclaration(pos) {
3866
3843
  function deserializeTSIndexSignatureName(pos) {
3867
3844
  let node = {
3868
3845
  type: "Identifier",
3869
- decorators: null,
3846
+ decorators: [],
3870
3847
  name: deserializeStr(pos + 16),
3871
- optional: null,
3848
+ optional: false,
3872
3849
  typeAnnotation: null,
3873
- start: deserializeU32(pos),
3874
- end: deserializeU32(pos + 4),
3850
+ start: deserializeI32(pos),
3851
+ end: deserializeI32(pos + 4),
3875
3852
  };
3876
- node.decorators = [];
3877
- node.optional = false;
3878
3853
  node.typeAnnotation = deserializeBoxTSTypeAnnotation(pos + 32);
3879
3854
  return node;
3880
3855
  }
@@ -3884,8 +3859,8 @@ function deserializeTSInterfaceHeritage(pos) {
3884
3859
  type: "TSInterfaceHeritage",
3885
3860
  expression: null,
3886
3861
  typeArguments: null,
3887
- start: deserializeU32(pos),
3888
- end: deserializeU32(pos + 4),
3862
+ start: deserializeI32(pos),
3863
+ end: deserializeI32(pos + 4),
3889
3864
  };
3890
3865
  node.expression = deserializeExpression(pos + 16);
3891
3866
  node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 32);
@@ -3898,8 +3873,8 @@ function deserializeTSTypePredicate(pos) {
3898
3873
  parameterName: null,
3899
3874
  asserts: deserializeBool(pos + 12),
3900
3875
  typeAnnotation: null,
3901
- start: deserializeU32(pos),
3902
- end: deserializeU32(pos + 4),
3876
+ start: deserializeI32(pos),
3877
+ end: deserializeI32(pos + 4),
3903
3878
  };
3904
3879
  node.parameterName = deserializeTSTypePredicateName(pos + 16);
3905
3880
  node.typeAnnotation = deserializeOptionBoxTSTypeAnnotation(pos + 40);
@@ -3919,8 +3894,8 @@ function deserializeTSTypePredicateName(pos) {
3919
3894
 
3920
3895
  function deserializeTSModuleDeclaration(pos) {
3921
3896
  let kind = deserializeTSModuleDeclarationKind(pos + 88),
3922
- start = deserializeU32(pos),
3923
- end = deserializeU32(pos + 4),
3897
+ start = deserializeI32(pos),
3898
+ end = deserializeI32(pos + 4),
3924
3899
  declare = deserializeBool(pos + 89),
3925
3900
  node,
3926
3901
  body = deserializeOptionTSModuleDeclarationBody(pos + 72);
@@ -4024,11 +3999,11 @@ function deserializeTSGlobalDeclaration(pos) {
4024
3999
  type: "TSModuleDeclaration",
4025
4000
  id: null,
4026
4001
  body: null,
4027
- kind: null,
4002
+ kind: "global",
4028
4003
  declare: deserializeBool(pos + 88),
4029
- global: null,
4030
- start: deserializeU32(pos),
4031
- end: deserializeU32(pos + 4),
4004
+ global: true,
4005
+ start: deserializeI32(pos),
4006
+ end: deserializeI32(pos + 4),
4032
4007
  };
4033
4008
  node.id = {
4034
4009
  type: "Identifier",
@@ -4036,12 +4011,10 @@ function deserializeTSGlobalDeclaration(pos) {
4036
4011
  name: "global",
4037
4012
  optional: false,
4038
4013
  typeAnnotation: null,
4039
- start: deserializeU32(pos + 16),
4040
- end: deserializeU32(pos + 20),
4014
+ start: deserializeI32(pos + 16),
4015
+ end: deserializeI32(pos + 20),
4041
4016
  };
4042
4017
  node.body = deserializeTSModuleBlock(pos + 24);
4043
- node.kind = "global";
4044
- node.global = true;
4045
4018
  return node;
4046
4019
  }
4047
4020
 
@@ -4049,8 +4022,8 @@ function deserializeTSModuleBlock(pos) {
4049
4022
  let node = {
4050
4023
  type: "TSModuleBlock",
4051
4024
  body: null,
4052
- start: deserializeU32(pos),
4053
- end: deserializeU32(pos + 4),
4025
+ start: deserializeI32(pos),
4026
+ end: deserializeI32(pos + 4),
4054
4027
  },
4055
4028
  body = deserializeVecDirective(pos + 16);
4056
4029
  body.push(...deserializeVecStatement(pos + 40));
@@ -4062,8 +4035,8 @@ function deserializeTSTypeLiteral(pos) {
4062
4035
  let node = {
4063
4036
  type: "TSTypeLiteral",
4064
4037
  members: null,
4065
- start: deserializeU32(pos),
4066
- end: deserializeU32(pos + 4),
4038
+ start: deserializeI32(pos),
4039
+ end: deserializeI32(pos + 4),
4067
4040
  };
4068
4041
  node.members = deserializeVecTSSignature(pos + 16);
4069
4042
  return node;
@@ -4073,8 +4046,8 @@ function deserializeTSInferType(pos) {
4073
4046
  let node = {
4074
4047
  type: "TSInferType",
4075
4048
  typeParameter: null,
4076
- start: deserializeU32(pos),
4077
- end: deserializeU32(pos + 4),
4049
+ start: deserializeI32(pos),
4050
+ end: deserializeI32(pos + 4),
4078
4051
  };
4079
4052
  node.typeParameter = deserializeBoxTSTypeParameter(pos + 16);
4080
4053
  return node;
@@ -4085,8 +4058,8 @@ function deserializeTSTypeQuery(pos) {
4085
4058
  type: "TSTypeQuery",
4086
4059
  exprName: null,
4087
4060
  typeArguments: null,
4088
- start: deserializeU32(pos),
4089
- end: deserializeU32(pos + 4),
4061
+ start: deserializeI32(pos),
4062
+ end: deserializeI32(pos + 4),
4090
4063
  };
4091
4064
  node.exprName = deserializeTSTypeQueryExprName(pos + 16);
4092
4065
  node.typeArguments = deserializeOptionBoxTSTypeParameterInstantiation(pos + 32);
@@ -4115,8 +4088,8 @@ function deserializeTSImportType(pos) {
4115
4088
  options: null,
4116
4089
  qualifier: null,
4117
4090
  typeArguments: null,
4118
- start: deserializeU32(pos),
4119
- end: deserializeU32(pos + 4),
4091
+ start: deserializeI32(pos),
4092
+ end: deserializeI32(pos + 4),
4120
4093
  };
4121
4094
  node.source = deserializeStringLiteral(pos + 16);
4122
4095
  node.options = deserializeOptionBoxObjectExpression(pos + 64);
@@ -4141,8 +4114,8 @@ function deserializeTSImportTypeQualifiedName(pos) {
4141
4114
  type: "TSQualifiedName",
4142
4115
  left: null,
4143
4116
  right: null,
4144
- start: deserializeU32(pos),
4145
- end: deserializeU32(pos + 4),
4117
+ start: deserializeI32(pos),
4118
+ end: deserializeI32(pos + 4),
4146
4119
  };
4147
4120
  node.left = deserializeTSImportTypeQualifier(pos + 16);
4148
4121
  node.right = deserializeIdentifierName(pos + 32);
@@ -4155,8 +4128,8 @@ function deserializeTSFunctionType(pos) {
4155
4128
  typeParameters: null,
4156
4129
  params: null,
4157
4130
  returnType: null,
4158
- start: deserializeU32(pos),
4159
- end: deserializeU32(pos + 4),
4131
+ start: deserializeI32(pos),
4132
+ end: deserializeI32(pos + 4),
4160
4133
  },
4161
4134
  params = deserializeBoxFormalParameters(pos + 32),
4162
4135
  thisParam = deserializeOptionBoxTSThisParameter(pos + 24);
@@ -4174,8 +4147,8 @@ function deserializeTSConstructorType(pos) {
4174
4147
  typeParameters: null,
4175
4148
  params: null,
4176
4149
  returnType: null,
4177
- start: deserializeU32(pos),
4178
- end: deserializeU32(pos + 4),
4150
+ start: deserializeI32(pos),
4151
+ end: deserializeI32(pos + 4),
4179
4152
  };
4180
4153
  node.typeParameters = deserializeOptionBoxTSTypeParameterDeclaration(pos + 16);
4181
4154
  node.params = deserializeBoxFormalParameters(pos + 24);
@@ -4192,8 +4165,8 @@ function deserializeTSMappedType(pos) {
4192
4165
  typeAnnotation: null,
4193
4166
  optional: null,
4194
4167
  readonly: deserializeOptionTSMappedTypeModifierOperator(pos + 97),
4195
- start: deserializeU32(pos),
4196
- end: deserializeU32(pos + 4),
4168
+ start: deserializeI32(pos),
4169
+ end: deserializeI32(pos + 4),
4197
4170
  },
4198
4171
  optional = deserializeOptionTSMappedTypeModifierOperator(pos + 96);
4199
4172
  optional === null && (optional = false);
@@ -4223,8 +4196,8 @@ function deserializeTSTemplateLiteralType(pos) {
4223
4196
  type: "TSTemplateLiteralType",
4224
4197
  quasis: null,
4225
4198
  types: null,
4226
- start: deserializeU32(pos),
4227
- end: deserializeU32(pos + 4),
4199
+ start: deserializeI32(pos),
4200
+ end: deserializeI32(pos + 4),
4228
4201
  };
4229
4202
  node.quasis = deserializeVecTemplateElement(pos + 16);
4230
4203
  node.types = deserializeVecTSType(pos + 40);
@@ -4236,8 +4209,8 @@ function deserializeTSAsExpression(pos) {
4236
4209
  type: "TSAsExpression",
4237
4210
  expression: null,
4238
4211
  typeAnnotation: null,
4239
- start: deserializeU32(pos),
4240
- end: deserializeU32(pos + 4),
4212
+ start: deserializeI32(pos),
4213
+ end: deserializeI32(pos + 4),
4241
4214
  };
4242
4215
  node.expression = deserializeExpression(pos + 16);
4243
4216
  node.typeAnnotation = deserializeTSType(pos + 32);
@@ -4249,8 +4222,8 @@ function deserializeTSSatisfiesExpression(pos) {
4249
4222
  type: "TSSatisfiesExpression",
4250
4223
  expression: null,
4251
4224
  typeAnnotation: null,
4252
- start: deserializeU32(pos),
4253
- end: deserializeU32(pos + 4),
4225
+ start: deserializeI32(pos),
4226
+ end: deserializeI32(pos + 4),
4254
4227
  };
4255
4228
  node.expression = deserializeExpression(pos + 16);
4256
4229
  node.typeAnnotation = deserializeTSType(pos + 32);
@@ -4262,8 +4235,8 @@ function deserializeTSTypeAssertion(pos) {
4262
4235
  type: "TSTypeAssertion",
4263
4236
  typeAnnotation: null,
4264
4237
  expression: null,
4265
- start: deserializeU32(pos),
4266
- end: deserializeU32(pos + 4),
4238
+ start: deserializeI32(pos),
4239
+ end: deserializeI32(pos + 4),
4267
4240
  };
4268
4241
  node.typeAnnotation = deserializeTSType(pos + 16);
4269
4242
  node.expression = deserializeExpression(pos + 32);
@@ -4276,8 +4249,8 @@ function deserializeTSImportEqualsDeclaration(pos) {
4276
4249
  id: null,
4277
4250
  moduleReference: null,
4278
4251
  importKind: deserializeImportOrExportKind(pos + 12),
4279
- start: deserializeU32(pos),
4280
- end: deserializeU32(pos + 4),
4252
+ start: deserializeI32(pos),
4253
+ end: deserializeI32(pos + 4),
4281
4254
  };
4282
4255
  node.id = deserializeBindingIdentifier(pos + 16);
4283
4256
  node.moduleReference = deserializeTSModuleReference(pos + 48);
@@ -4301,8 +4274,8 @@ function deserializeTSExternalModuleReference(pos) {
4301
4274
  let node = {
4302
4275
  type: "TSExternalModuleReference",
4303
4276
  expression: null,
4304
- start: deserializeU32(pos),
4305
- end: deserializeU32(pos + 4),
4277
+ start: deserializeI32(pos),
4278
+ end: deserializeI32(pos + 4),
4306
4279
  };
4307
4280
  node.expression = deserializeStringLiteral(pos + 16);
4308
4281
  return node;
@@ -4312,8 +4285,8 @@ function deserializeTSNonNullExpression(pos) {
4312
4285
  let node = {
4313
4286
  type: "TSNonNullExpression",
4314
4287
  expression: null,
4315
- start: deserializeU32(pos),
4316
- end: deserializeU32(pos + 4),
4288
+ start: deserializeI32(pos),
4289
+ end: deserializeI32(pos + 4),
4317
4290
  };
4318
4291
  node.expression = deserializeExpression(pos + 16);
4319
4292
  return node;
@@ -4323,8 +4296,8 @@ function deserializeDecorator(pos) {
4323
4296
  let node = {
4324
4297
  type: "Decorator",
4325
4298
  expression: null,
4326
- start: deserializeU32(pos),
4327
- end: deserializeU32(pos + 4),
4299
+ start: deserializeI32(pos),
4300
+ end: deserializeI32(pos + 4),
4328
4301
  };
4329
4302
  node.expression = deserializeExpression(pos + 16);
4330
4303
  return node;
@@ -4334,8 +4307,8 @@ function deserializeTSExportAssignment(pos) {
4334
4307
  let node = {
4335
4308
  type: "TSExportAssignment",
4336
4309
  expression: null,
4337
- start: deserializeU32(pos),
4338
- end: deserializeU32(pos + 4),
4310
+ start: deserializeI32(pos),
4311
+ end: deserializeI32(pos + 4),
4339
4312
  };
4340
4313
  node.expression = deserializeExpression(pos + 16);
4341
4314
  return node;
@@ -4345,8 +4318,8 @@ function deserializeTSNamespaceExportDeclaration(pos) {
4345
4318
  let node = {
4346
4319
  type: "TSNamespaceExportDeclaration",
4347
4320
  id: null,
4348
- start: deserializeU32(pos),
4349
- end: deserializeU32(pos + 4),
4321
+ start: deserializeI32(pos),
4322
+ end: deserializeI32(pos + 4),
4350
4323
  };
4351
4324
  node.id = deserializeIdentifierName(pos + 16);
4352
4325
  return node;
@@ -4357,8 +4330,8 @@ function deserializeTSInstantiationExpression(pos) {
4357
4330
  type: "TSInstantiationExpression",
4358
4331
  expression: null,
4359
4332
  typeArguments: null,
4360
- start: deserializeU32(pos),
4361
- end: deserializeU32(pos + 4),
4333
+ start: deserializeI32(pos),
4334
+ end: deserializeI32(pos + 4),
4362
4335
  };
4363
4336
  node.expression = deserializeExpression(pos + 16);
4364
4337
  node.typeArguments = deserializeBoxTSTypeParameterInstantiation(pos + 32);
@@ -4381,8 +4354,8 @@ function deserializeJSDocNullableType(pos) {
4381
4354
  type: "TSJSDocNullableType",
4382
4355
  typeAnnotation: null,
4383
4356
  postfix: deserializeBool(pos + 12),
4384
- start: deserializeU32(pos),
4385
- end: deserializeU32(pos + 4),
4357
+ start: deserializeI32(pos),
4358
+ end: deserializeI32(pos + 4),
4386
4359
  };
4387
4360
  node.typeAnnotation = deserializeTSType(pos + 16);
4388
4361
  return node;
@@ -4393,8 +4366,8 @@ function deserializeJSDocNonNullableType(pos) {
4393
4366
  type: "TSJSDocNonNullableType",
4394
4367
  typeAnnotation: null,
4395
4368
  postfix: deserializeBool(pos + 12),
4396
- start: deserializeU32(pos),
4397
- end: deserializeU32(pos + 4),
4369
+ start: deserializeI32(pos),
4370
+ end: deserializeI32(pos + 4),
4398
4371
  };
4399
4372
  node.typeAnnotation = deserializeTSType(pos + 16);
4400
4373
  return node;
@@ -4403,8 +4376,8 @@ function deserializeJSDocNonNullableType(pos) {
4403
4376
  function deserializeJSDocUnknownType(pos) {
4404
4377
  return {
4405
4378
  type: "TSJSDocUnknownType",
4406
- start: deserializeU32(pos),
4407
- end: deserializeU32(pos + 4),
4379
+ start: deserializeI32(pos),
4380
+ end: deserializeI32(pos + 4),
4408
4381
  };
4409
4382
  }
4410
4383
 
@@ -4423,8 +4396,8 @@ function deserializeCommentKind(pos) {
4423
4396
 
4424
4397
  function deserializeComment(pos) {
4425
4398
  let type = deserializeCommentKind(pos + 12),
4426
- start = deserializeU32(pos),
4427
- end = deserializeU32(pos + 4);
4399
+ start = deserializeI32(pos),
4400
+ end = deserializeI32(pos + 4);
4428
4401
  return {
4429
4402
  type,
4430
4403
  value: sourceText.slice(start + 2, end - (type === "Line" ? 0 : 2)),
@@ -4448,16 +4421,16 @@ function deserializeModuleKind(pos) {
4448
4421
 
4449
4422
  function deserializeSpan(pos) {
4450
4423
  return {
4451
- start: deserializeU32(pos),
4452
- end: deserializeU32(pos + 4),
4424
+ start: deserializeI32(pos),
4425
+ end: deserializeI32(pos + 4),
4453
4426
  };
4454
4427
  }
4455
4428
 
4456
4429
  function deserializeNameSpan(pos) {
4457
4430
  return {
4458
4431
  value: deserializeStr(pos + 8),
4459
- start: deserializeU32(pos),
4460
- end: deserializeU32(pos + 4),
4432
+ start: deserializeI32(pos),
4433
+ end: deserializeI32(pos + 4),
4461
4434
  };
4462
4435
  }
4463
4436
 
@@ -4506,8 +4479,8 @@ function deserializeExportEntry(pos) {
4506
4479
  exportName: deserializeExportExportName(pos + 72),
4507
4480
  localName: deserializeExportLocalName(pos + 104),
4508
4481
  isType: deserializeBool(pos + 136),
4509
- start: deserializeU32(pos),
4510
- end: deserializeU32(pos + 4),
4482
+ start: deserializeI32(pos),
4483
+ end: deserializeI32(pos + 4),
4511
4484
  };
4512
4485
  }
4513
4486
 
@@ -4610,8 +4583,8 @@ function deserializeExportLocalName(pos) {
4610
4583
  function deserializeDynamicImport(pos) {
4611
4584
  return {
4612
4585
  moduleRequest: deserializeSpan(pos + 8),
4613
- start: deserializeU32(pos),
4614
- end: deserializeU32(pos + 4),
4586
+ start: deserializeI32(pos),
4587
+ end: deserializeI32(pos + 4),
4615
4588
  };
4616
4589
  }
4617
4590
 
@@ -4785,8 +4758,8 @@ function deserializeErrorSeverity(pos) {
4785
4758
  function deserializeErrorLabel(pos) {
4786
4759
  return {
4787
4760
  message: deserializeOptionStr(pos + 8),
4788
- start: deserializeU32(pos),
4789
- end: deserializeU32(pos + 4),
4761
+ start: deserializeI32(pos),
4762
+ end: deserializeI32(pos + 4),
4790
4763
  };
4791
4764
  }
4792
4765
 
@@ -4804,48 +4777,52 @@ function deserializeStaticImport(pos) {
4804
4777
  return {
4805
4778
  moduleRequest: deserializeNameSpan(pos + 8),
4806
4779
  entries: deserializeVecImportEntry(pos + 32),
4807
- start: deserializeU32(pos),
4808
- end: deserializeU32(pos + 4),
4780
+ start: deserializeI32(pos),
4781
+ end: deserializeI32(pos + 4),
4809
4782
  };
4810
4783
  }
4811
4784
 
4812
4785
  function deserializeStaticExport(pos) {
4813
4786
  return {
4814
4787
  entries: deserializeVecExportEntry(pos + 8),
4815
- start: deserializeU32(pos),
4816
- end: deserializeU32(pos + 4),
4788
+ start: deserializeI32(pos),
4789
+ end: deserializeI32(pos + 4),
4817
4790
  };
4818
4791
  }
4819
4792
 
4820
4793
  function deserializeStr(pos) {
4821
4794
  let pos32 = pos >> 2,
4822
- len = uint32[pos32 + 2];
4795
+ len = int32[pos32 + 2];
4823
4796
  if (len === 0) return "";
4824
- pos = uint32[pos32];
4825
- if (sourceIsAscii && pos < sourceEndPos) return sourceText.substr(pos, len);
4826
- // Longer strings use `TextDecoder`
4827
- // TODO: Find best switch-over point
4797
+ pos = int32[pos32];
4828
4798
  let end = pos + len;
4829
- if (len > 50) return decodeStr(uint8.subarray(pos, end));
4830
- // Shorter strings decode by hand to avoid native call
4831
- let out = "",
4832
- c;
4833
- do {
4834
- c = uint8[pos++];
4835
- if (c < 128) out += fromCodePoint(c);
4836
- else {
4837
- out += decodeStr(uint8.subarray(pos - 1, end));
4838
- break;
4839
- }
4840
- } while (pos < end);
4841
- return out;
4799
+ if (end <= firstNonAsciiPos) return sourceTextLatin.substr(pos, len);
4800
+ // Use `utf8Slice` for strings longer than 64 bytes
4801
+ if (len > 64) return utf8Slice.call(uint8, pos, end);
4802
+ if (pos < sourceEndPos) {
4803
+ // Check if all bytes are ASCII, use `utf8Slice` if not
4804
+ for (let i = pos; i < end; i++) if (uint8[i] >= 128) return utf8Slice.call(uint8, pos, end);
4805
+ // String is all ASCII, so slice from `sourceTextLatin`
4806
+ return sourceTextLatin.substr(pos, len);
4807
+ }
4808
+ // String is not in source region - use `fromCharCode.apply` with a temp array of correct length.
4809
+ // Copy bytes into temp array.
4810
+ // If any byte is non-ASCII, use `utf8Slice`.
4811
+ let arr = stringDecodeArrays[len];
4812
+ for (let i = 0; i < len; i++) {
4813
+ let b = uint8[pos + i];
4814
+ if (b >= 128) return utf8Slice.call(uint8, pos, end);
4815
+ arr[i] = b;
4816
+ }
4817
+ // Call `fromCharCode` with temp array
4818
+ return fromCharCode.apply(null, arr);
4842
4819
  }
4843
4820
 
4844
4821
  function deserializeVecComment(pos) {
4845
4822
  let arr = [],
4846
4823
  pos32 = pos >> 2;
4847
- pos = uint32[pos32];
4848
- let endPos = pos + uint32[pos32 + 2] * 16;
4824
+ pos = int32[pos32];
4825
+ let endPos = pos + (int32[pos32 + 2] << 4);
4849
4826
  for (; pos !== endPos; ) {
4850
4827
  arr.push(deserializeComment(pos));
4851
4828
  pos += 16;
@@ -4854,15 +4831,16 @@ function deserializeVecComment(pos) {
4854
4831
  }
4855
4832
 
4856
4833
  function deserializeOptionHashbang(pos) {
4857
- if (uint32[(pos + 16) >> 2] === 0 && uint32[(pos + 20) >> 2] === 0) return null;
4858
- return deserializeHashbang(pos);
4834
+ return int32[(pos >> 2) + 4] === 0 && int32[(pos >> 2) + 5] === 0
4835
+ ? null
4836
+ : deserializeHashbang(pos);
4859
4837
  }
4860
4838
 
4861
4839
  function deserializeVecDirective(pos) {
4862
4840
  let arr = [],
4863
4841
  pos32 = pos >> 2;
4864
- pos = uint32[pos32];
4865
- let endPos = pos + uint32[pos32 + 2] * 80;
4842
+ pos = int32[pos32];
4843
+ let endPos = pos + int32[pos32 + 2] * 80;
4866
4844
  for (; pos !== endPos; ) {
4867
4845
  arr.push(deserializeDirective(pos));
4868
4846
  pos += 80;
@@ -4873,8 +4851,8 @@ function deserializeVecDirective(pos) {
4873
4851
  function deserializeVecStatement(pos) {
4874
4852
  let arr = [],
4875
4853
  pos32 = pos >> 2;
4876
- pos = uint32[pos32];
4877
- let endPos = pos + uint32[pos32 + 2] * 16;
4854
+ pos = int32[pos32];
4855
+ let endPos = pos + (int32[pos32 + 2] << 4);
4878
4856
  for (; pos !== endPos; ) {
4879
4857
  arr.push(deserializeStatement(pos));
4880
4858
  pos += 16;
@@ -4883,170 +4861,170 @@ function deserializeVecStatement(pos) {
4883
4861
  }
4884
4862
 
4885
4863
  function deserializeBoxBooleanLiteral(pos) {
4886
- return deserializeBooleanLiteral(uint32[pos >> 2]);
4864
+ return deserializeBooleanLiteral(int32[pos >> 2]);
4887
4865
  }
4888
4866
 
4889
4867
  function deserializeBoxNullLiteral(pos) {
4890
- return deserializeNullLiteral(uint32[pos >> 2]);
4868
+ return deserializeNullLiteral(int32[pos >> 2]);
4891
4869
  }
4892
4870
 
4893
4871
  function deserializeBoxNumericLiteral(pos) {
4894
- return deserializeNumericLiteral(uint32[pos >> 2]);
4872
+ return deserializeNumericLiteral(int32[pos >> 2]);
4895
4873
  }
4896
4874
 
4897
4875
  function deserializeBoxBigIntLiteral(pos) {
4898
- return deserializeBigIntLiteral(uint32[pos >> 2]);
4876
+ return deserializeBigIntLiteral(int32[pos >> 2]);
4899
4877
  }
4900
4878
 
4901
4879
  function deserializeBoxRegExpLiteral(pos) {
4902
- return deserializeRegExpLiteral(uint32[pos >> 2]);
4880
+ return deserializeRegExpLiteral(int32[pos >> 2]);
4903
4881
  }
4904
4882
 
4905
4883
  function deserializeBoxStringLiteral(pos) {
4906
- return deserializeStringLiteral(uint32[pos >> 2]);
4884
+ return deserializeStringLiteral(int32[pos >> 2]);
4907
4885
  }
4908
4886
 
4909
4887
  function deserializeBoxTemplateLiteral(pos) {
4910
- return deserializeTemplateLiteral(uint32[pos >> 2]);
4888
+ return deserializeTemplateLiteral(int32[pos >> 2]);
4911
4889
  }
4912
4890
 
4913
4891
  function deserializeBoxIdentifierReference(pos) {
4914
- return deserializeIdentifierReference(uint32[pos >> 2]);
4892
+ return deserializeIdentifierReference(int32[pos >> 2]);
4915
4893
  }
4916
4894
 
4917
4895
  function deserializeBoxMetaProperty(pos) {
4918
- return deserializeMetaProperty(uint32[pos >> 2]);
4896
+ return deserializeMetaProperty(int32[pos >> 2]);
4919
4897
  }
4920
4898
 
4921
4899
  function deserializeBoxSuper(pos) {
4922
- return deserializeSuper(uint32[pos >> 2]);
4900
+ return deserializeSuper(int32[pos >> 2]);
4923
4901
  }
4924
4902
 
4925
4903
  function deserializeBoxArrayExpression(pos) {
4926
- return deserializeArrayExpression(uint32[pos >> 2]);
4904
+ return deserializeArrayExpression(int32[pos >> 2]);
4927
4905
  }
4928
4906
 
4929
4907
  function deserializeBoxArrowFunctionExpression(pos) {
4930
- return deserializeArrowFunctionExpression(uint32[pos >> 2]);
4908
+ return deserializeArrowFunctionExpression(int32[pos >> 2]);
4931
4909
  }
4932
4910
 
4933
4911
  function deserializeBoxAssignmentExpression(pos) {
4934
- return deserializeAssignmentExpression(uint32[pos >> 2]);
4912
+ return deserializeAssignmentExpression(int32[pos >> 2]);
4935
4913
  }
4936
4914
 
4937
4915
  function deserializeBoxAwaitExpression(pos) {
4938
- return deserializeAwaitExpression(uint32[pos >> 2]);
4916
+ return deserializeAwaitExpression(int32[pos >> 2]);
4939
4917
  }
4940
4918
 
4941
4919
  function deserializeBoxBinaryExpression(pos) {
4942
- return deserializeBinaryExpression(uint32[pos >> 2]);
4920
+ return deserializeBinaryExpression(int32[pos >> 2]);
4943
4921
  }
4944
4922
 
4945
4923
  function deserializeBoxCallExpression(pos) {
4946
- return deserializeCallExpression(uint32[pos >> 2]);
4924
+ return deserializeCallExpression(int32[pos >> 2]);
4947
4925
  }
4948
4926
 
4949
4927
  function deserializeBoxChainExpression(pos) {
4950
- return deserializeChainExpression(uint32[pos >> 2]);
4928
+ return deserializeChainExpression(int32[pos >> 2]);
4951
4929
  }
4952
4930
 
4953
4931
  function deserializeBoxClass(pos) {
4954
- return deserializeClass(uint32[pos >> 2]);
4932
+ return deserializeClass(int32[pos >> 2]);
4955
4933
  }
4956
4934
 
4957
4935
  function deserializeBoxConditionalExpression(pos) {
4958
- return deserializeConditionalExpression(uint32[pos >> 2]);
4936
+ return deserializeConditionalExpression(int32[pos >> 2]);
4959
4937
  }
4960
4938
 
4961
4939
  function deserializeBoxFunction(pos) {
4962
- return deserializeFunction(uint32[pos >> 2]);
4940
+ return deserializeFunction(int32[pos >> 2]);
4963
4941
  }
4964
4942
 
4965
4943
  function deserializeBoxImportExpression(pos) {
4966
- return deserializeImportExpression(uint32[pos >> 2]);
4944
+ return deserializeImportExpression(int32[pos >> 2]);
4967
4945
  }
4968
4946
 
4969
4947
  function deserializeBoxLogicalExpression(pos) {
4970
- return deserializeLogicalExpression(uint32[pos >> 2]);
4948
+ return deserializeLogicalExpression(int32[pos >> 2]);
4971
4949
  }
4972
4950
 
4973
4951
  function deserializeBoxNewExpression(pos) {
4974
- return deserializeNewExpression(uint32[pos >> 2]);
4952
+ return deserializeNewExpression(int32[pos >> 2]);
4975
4953
  }
4976
4954
 
4977
4955
  function deserializeBoxObjectExpression(pos) {
4978
- return deserializeObjectExpression(uint32[pos >> 2]);
4956
+ return deserializeObjectExpression(int32[pos >> 2]);
4979
4957
  }
4980
4958
 
4981
4959
  function deserializeBoxParenthesizedExpression(pos) {
4982
- return deserializeParenthesizedExpression(uint32[pos >> 2]);
4960
+ return deserializeParenthesizedExpression(int32[pos >> 2]);
4983
4961
  }
4984
4962
 
4985
4963
  function deserializeBoxSequenceExpression(pos) {
4986
- return deserializeSequenceExpression(uint32[pos >> 2]);
4964
+ return deserializeSequenceExpression(int32[pos >> 2]);
4987
4965
  }
4988
4966
 
4989
4967
  function deserializeBoxTaggedTemplateExpression(pos) {
4990
- return deserializeTaggedTemplateExpression(uint32[pos >> 2]);
4968
+ return deserializeTaggedTemplateExpression(int32[pos >> 2]);
4991
4969
  }
4992
4970
 
4993
4971
  function deserializeBoxThisExpression(pos) {
4994
- return deserializeThisExpression(uint32[pos >> 2]);
4972
+ return deserializeThisExpression(int32[pos >> 2]);
4995
4973
  }
4996
4974
 
4997
4975
  function deserializeBoxUnaryExpression(pos) {
4998
- return deserializeUnaryExpression(uint32[pos >> 2]);
4976
+ return deserializeUnaryExpression(int32[pos >> 2]);
4999
4977
  }
5000
4978
 
5001
4979
  function deserializeBoxUpdateExpression(pos) {
5002
- return deserializeUpdateExpression(uint32[pos >> 2]);
4980
+ return deserializeUpdateExpression(int32[pos >> 2]);
5003
4981
  }
5004
4982
 
5005
4983
  function deserializeBoxYieldExpression(pos) {
5006
- return deserializeYieldExpression(uint32[pos >> 2]);
4984
+ return deserializeYieldExpression(int32[pos >> 2]);
5007
4985
  }
5008
4986
 
5009
4987
  function deserializeBoxPrivateInExpression(pos) {
5010
- return deserializePrivateInExpression(uint32[pos >> 2]);
4988
+ return deserializePrivateInExpression(int32[pos >> 2]);
5011
4989
  }
5012
4990
 
5013
4991
  function deserializeBoxJSXElement(pos) {
5014
- return deserializeJSXElement(uint32[pos >> 2]);
4992
+ return deserializeJSXElement(int32[pos >> 2]);
5015
4993
  }
5016
4994
 
5017
4995
  function deserializeBoxJSXFragment(pos) {
5018
- return deserializeJSXFragment(uint32[pos >> 2]);
4996
+ return deserializeJSXFragment(int32[pos >> 2]);
5019
4997
  }
5020
4998
 
5021
4999
  function deserializeBoxTSAsExpression(pos) {
5022
- return deserializeTSAsExpression(uint32[pos >> 2]);
5000
+ return deserializeTSAsExpression(int32[pos >> 2]);
5023
5001
  }
5024
5002
 
5025
5003
  function deserializeBoxTSSatisfiesExpression(pos) {
5026
- return deserializeTSSatisfiesExpression(uint32[pos >> 2]);
5004
+ return deserializeTSSatisfiesExpression(int32[pos >> 2]);
5027
5005
  }
5028
5006
 
5029
5007
  function deserializeBoxTSTypeAssertion(pos) {
5030
- return deserializeTSTypeAssertion(uint32[pos >> 2]);
5008
+ return deserializeTSTypeAssertion(int32[pos >> 2]);
5031
5009
  }
5032
5010
 
5033
5011
  function deserializeBoxTSNonNullExpression(pos) {
5034
- return deserializeTSNonNullExpression(uint32[pos >> 2]);
5012
+ return deserializeTSNonNullExpression(int32[pos >> 2]);
5035
5013
  }
5036
5014
 
5037
5015
  function deserializeBoxTSInstantiationExpression(pos) {
5038
- return deserializeTSInstantiationExpression(uint32[pos >> 2]);
5016
+ return deserializeTSInstantiationExpression(int32[pos >> 2]);
5039
5017
  }
5040
5018
 
5041
5019
  function deserializeBoxV8IntrinsicExpression(pos) {
5042
- return deserializeV8IntrinsicExpression(uint32[pos >> 2]);
5020
+ return deserializeV8IntrinsicExpression(int32[pos >> 2]);
5043
5021
  }
5044
5022
 
5045
5023
  function deserializeVecArrayExpressionElement(pos) {
5046
5024
  let arr = [],
5047
5025
  pos32 = pos >> 2;
5048
- pos = uint32[pos32];
5049
- let endPos = pos + uint32[pos32 + 2] * 24;
5026
+ pos = int32[pos32];
5027
+ let endPos = pos + int32[pos32 + 2] * 24;
5050
5028
  for (; pos !== endPos; ) {
5051
5029
  arr.push(deserializeArrayExpressionElement(pos));
5052
5030
  pos += 24;
@@ -5055,14 +5033,14 @@ function deserializeVecArrayExpressionElement(pos) {
5055
5033
  }
5056
5034
 
5057
5035
  function deserializeBoxSpreadElement(pos) {
5058
- return deserializeSpreadElement(uint32[pos >> 2]);
5036
+ return deserializeSpreadElement(int32[pos >> 2]);
5059
5037
  }
5060
5038
 
5061
5039
  function deserializeVecObjectPropertyKind(pos) {
5062
5040
  let arr = [],
5063
5041
  pos32 = pos >> 2;
5064
- pos = uint32[pos32];
5065
- let endPos = pos + uint32[pos32 + 2] * 16;
5042
+ pos = int32[pos32];
5043
+ let endPos = pos + (int32[pos32 + 2] << 4);
5066
5044
  for (; pos !== endPos; ) {
5067
5045
  arr.push(deserializeObjectPropertyKind(pos));
5068
5046
  pos += 16;
@@ -5071,7 +5049,7 @@ function deserializeVecObjectPropertyKind(pos) {
5071
5049
  }
5072
5050
 
5073
5051
  function deserializeBoxObjectProperty(pos) {
5074
- return deserializeObjectProperty(uint32[pos >> 2]);
5052
+ return deserializeObjectProperty(int32[pos >> 2]);
5075
5053
  }
5076
5054
 
5077
5055
  function deserializeBool(pos) {
@@ -5079,18 +5057,18 @@ function deserializeBool(pos) {
5079
5057
  }
5080
5058
 
5081
5059
  function deserializeBoxIdentifierName(pos) {
5082
- return deserializeIdentifierName(uint32[pos >> 2]);
5060
+ return deserializeIdentifierName(int32[pos >> 2]);
5083
5061
  }
5084
5062
 
5085
5063
  function deserializeBoxPrivateIdentifier(pos) {
5086
- return deserializePrivateIdentifier(uint32[pos >> 2]);
5064
+ return deserializePrivateIdentifier(int32[pos >> 2]);
5087
5065
  }
5088
5066
 
5089
5067
  function deserializeVecTemplateElement(pos) {
5090
5068
  let arr = [],
5091
5069
  pos32 = pos >> 2;
5092
- pos = uint32[pos32];
5093
- let endPos = pos + uint32[pos32 + 2] * 48;
5070
+ pos = int32[pos32];
5071
+ let endPos = pos + int32[pos32 + 2] * 48;
5094
5072
  for (; pos !== endPos; ) {
5095
5073
  arr.push(deserializeTemplateElement(pos));
5096
5074
  pos += 48;
@@ -5101,8 +5079,8 @@ function deserializeVecTemplateElement(pos) {
5101
5079
  function deserializeVecExpression(pos) {
5102
5080
  let arr = [],
5103
5081
  pos32 = pos >> 2;
5104
- pos = uint32[pos32];
5105
- let endPos = pos + uint32[pos32 + 2] * 16;
5082
+ pos = int32[pos32];
5083
+ let endPos = pos + (int32[pos32 + 2] << 4);
5106
5084
  for (; pos !== endPos; ) {
5107
5085
  arr.push(deserializeExpression(pos));
5108
5086
  pos += 16;
@@ -5111,36 +5089,36 @@ function deserializeVecExpression(pos) {
5111
5089
  }
5112
5090
 
5113
5091
  function deserializeBoxTSTypeParameterInstantiation(pos) {
5114
- return deserializeTSTypeParameterInstantiation(uint32[pos >> 2]);
5092
+ return deserializeTSTypeParameterInstantiation(int32[pos >> 2]);
5115
5093
  }
5116
5094
 
5117
5095
  function deserializeOptionBoxTSTypeParameterInstantiation(pos) {
5118
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5119
- return deserializeBoxTSTypeParameterInstantiation(pos);
5096
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5097
+ ? null
5098
+ : deserializeBoxTSTypeParameterInstantiation(pos);
5120
5099
  }
5121
5100
 
5122
5101
  function deserializeOptionStr(pos) {
5123
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5124
- return deserializeStr(pos);
5102
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0 ? null : deserializeStr(pos);
5125
5103
  }
5126
5104
 
5127
5105
  function deserializeBoxComputedMemberExpression(pos) {
5128
- return deserializeComputedMemberExpression(uint32[pos >> 2]);
5106
+ return deserializeComputedMemberExpression(int32[pos >> 2]);
5129
5107
  }
5130
5108
 
5131
5109
  function deserializeBoxStaticMemberExpression(pos) {
5132
- return deserializeStaticMemberExpression(uint32[pos >> 2]);
5110
+ return deserializeStaticMemberExpression(int32[pos >> 2]);
5133
5111
  }
5134
5112
 
5135
5113
  function deserializeBoxPrivateFieldExpression(pos) {
5136
- return deserializePrivateFieldExpression(uint32[pos >> 2]);
5114
+ return deserializePrivateFieldExpression(int32[pos >> 2]);
5137
5115
  }
5138
5116
 
5139
5117
  function deserializeVecArgument(pos) {
5140
5118
  let arr = [],
5141
5119
  pos32 = pos >> 2;
5142
- pos = uint32[pos32];
5143
- let endPos = pos + uint32[pos32 + 2] * 16;
5120
+ pos = int32[pos32];
5121
+ let endPos = pos + (int32[pos32 + 2] << 4);
5144
5122
  for (; pos !== endPos; ) {
5145
5123
  arr.push(deserializeArgument(pos));
5146
5124
  pos += 16;
@@ -5149,23 +5127,22 @@ function deserializeVecArgument(pos) {
5149
5127
  }
5150
5128
 
5151
5129
  function deserializeBoxArrayAssignmentTarget(pos) {
5152
- return deserializeArrayAssignmentTarget(uint32[pos >> 2]);
5130
+ return deserializeArrayAssignmentTarget(int32[pos >> 2]);
5153
5131
  }
5154
5132
 
5155
5133
  function deserializeBoxObjectAssignmentTarget(pos) {
5156
- return deserializeObjectAssignmentTarget(uint32[pos >> 2]);
5134
+ return deserializeObjectAssignmentTarget(int32[pos >> 2]);
5157
5135
  }
5158
5136
 
5159
5137
  function deserializeOptionAssignmentTargetMaybeDefault(pos) {
5160
- if (uint8[pos] === 51) return null;
5161
- return deserializeAssignmentTargetMaybeDefault(pos);
5138
+ return uint8[pos] === 51 ? null : deserializeAssignmentTargetMaybeDefault(pos);
5162
5139
  }
5163
5140
 
5164
5141
  function deserializeVecOptionAssignmentTargetMaybeDefault(pos) {
5165
5142
  let arr = [],
5166
5143
  pos32 = pos >> 2;
5167
- pos = uint32[pos32];
5168
- let endPos = pos + uint32[pos32 + 2] * 16;
5144
+ pos = int32[pos32];
5145
+ let endPos = pos + (int32[pos32 + 2] << 4);
5169
5146
  for (; pos !== endPos; ) {
5170
5147
  arr.push(deserializeOptionAssignmentTargetMaybeDefault(pos));
5171
5148
  pos += 16;
@@ -5174,19 +5151,20 @@ function deserializeVecOptionAssignmentTargetMaybeDefault(pos) {
5174
5151
  }
5175
5152
 
5176
5153
  function deserializeBoxAssignmentTargetRest(pos) {
5177
- return deserializeAssignmentTargetRest(uint32[pos >> 2]);
5154
+ return deserializeAssignmentTargetRest(int32[pos >> 2]);
5178
5155
  }
5179
5156
 
5180
5157
  function deserializeOptionBoxAssignmentTargetRest(pos) {
5181
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5182
- return deserializeBoxAssignmentTargetRest(pos);
5158
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5159
+ ? null
5160
+ : deserializeBoxAssignmentTargetRest(pos);
5183
5161
  }
5184
5162
 
5185
5163
  function deserializeVecAssignmentTargetProperty(pos) {
5186
5164
  let arr = [],
5187
5165
  pos32 = pos >> 2;
5188
- pos = uint32[pos32];
5189
- let endPos = pos + uint32[pos32 + 2] * 16;
5166
+ pos = int32[pos32];
5167
+ let endPos = pos + (int32[pos32 + 2] << 4);
5190
5168
  for (; pos !== endPos; ) {
5191
5169
  arr.push(deserializeAssignmentTargetProperty(pos));
5192
5170
  pos += 16;
@@ -5195,127 +5173,126 @@ function deserializeVecAssignmentTargetProperty(pos) {
5195
5173
  }
5196
5174
 
5197
5175
  function deserializeBoxAssignmentTargetWithDefault(pos) {
5198
- return deserializeAssignmentTargetWithDefault(uint32[pos >> 2]);
5176
+ return deserializeAssignmentTargetWithDefault(int32[pos >> 2]);
5199
5177
  }
5200
5178
 
5201
5179
  function deserializeBoxAssignmentTargetPropertyIdentifier(pos) {
5202
- return deserializeAssignmentTargetPropertyIdentifier(uint32[pos >> 2]);
5180
+ return deserializeAssignmentTargetPropertyIdentifier(int32[pos >> 2]);
5203
5181
  }
5204
5182
 
5205
5183
  function deserializeBoxAssignmentTargetPropertyProperty(pos) {
5206
- return deserializeAssignmentTargetPropertyProperty(uint32[pos >> 2]);
5184
+ return deserializeAssignmentTargetPropertyProperty(int32[pos >> 2]);
5207
5185
  }
5208
5186
 
5209
5187
  function deserializeOptionExpression(pos) {
5210
- if (uint8[pos] === 51) return null;
5211
- return deserializeExpression(pos);
5188
+ return uint8[pos] === 51 ? null : deserializeExpression(pos);
5212
5189
  }
5213
5190
 
5214
5191
  function deserializeBoxBlockStatement(pos) {
5215
- return deserializeBlockStatement(uint32[pos >> 2]);
5192
+ return deserializeBlockStatement(int32[pos >> 2]);
5216
5193
  }
5217
5194
 
5218
5195
  function deserializeBoxBreakStatement(pos) {
5219
- return deserializeBreakStatement(uint32[pos >> 2]);
5196
+ return deserializeBreakStatement(int32[pos >> 2]);
5220
5197
  }
5221
5198
 
5222
5199
  function deserializeBoxContinueStatement(pos) {
5223
- return deserializeContinueStatement(uint32[pos >> 2]);
5200
+ return deserializeContinueStatement(int32[pos >> 2]);
5224
5201
  }
5225
5202
 
5226
5203
  function deserializeBoxDebuggerStatement(pos) {
5227
- return deserializeDebuggerStatement(uint32[pos >> 2]);
5204
+ return deserializeDebuggerStatement(int32[pos >> 2]);
5228
5205
  }
5229
5206
 
5230
5207
  function deserializeBoxDoWhileStatement(pos) {
5231
- return deserializeDoWhileStatement(uint32[pos >> 2]);
5208
+ return deserializeDoWhileStatement(int32[pos >> 2]);
5232
5209
  }
5233
5210
 
5234
5211
  function deserializeBoxEmptyStatement(pos) {
5235
- return deserializeEmptyStatement(uint32[pos >> 2]);
5212
+ return deserializeEmptyStatement(int32[pos >> 2]);
5236
5213
  }
5237
5214
 
5238
5215
  function deserializeBoxExpressionStatement(pos) {
5239
- return deserializeExpressionStatement(uint32[pos >> 2]);
5216
+ return deserializeExpressionStatement(int32[pos >> 2]);
5240
5217
  }
5241
5218
 
5242
5219
  function deserializeBoxForInStatement(pos) {
5243
- return deserializeForInStatement(uint32[pos >> 2]);
5220
+ return deserializeForInStatement(int32[pos >> 2]);
5244
5221
  }
5245
5222
 
5246
5223
  function deserializeBoxForOfStatement(pos) {
5247
- return deserializeForOfStatement(uint32[pos >> 2]);
5224
+ return deserializeForOfStatement(int32[pos >> 2]);
5248
5225
  }
5249
5226
 
5250
5227
  function deserializeBoxForStatement(pos) {
5251
- return deserializeForStatement(uint32[pos >> 2]);
5228
+ return deserializeForStatement(int32[pos >> 2]);
5252
5229
  }
5253
5230
 
5254
5231
  function deserializeBoxIfStatement(pos) {
5255
- return deserializeIfStatement(uint32[pos >> 2]);
5232
+ return deserializeIfStatement(int32[pos >> 2]);
5256
5233
  }
5257
5234
 
5258
5235
  function deserializeBoxLabeledStatement(pos) {
5259
- return deserializeLabeledStatement(uint32[pos >> 2]);
5236
+ return deserializeLabeledStatement(int32[pos >> 2]);
5260
5237
  }
5261
5238
 
5262
5239
  function deserializeBoxReturnStatement(pos) {
5263
- return deserializeReturnStatement(uint32[pos >> 2]);
5240
+ return deserializeReturnStatement(int32[pos >> 2]);
5264
5241
  }
5265
5242
 
5266
5243
  function deserializeBoxSwitchStatement(pos) {
5267
- return deserializeSwitchStatement(uint32[pos >> 2]);
5244
+ return deserializeSwitchStatement(int32[pos >> 2]);
5268
5245
  }
5269
5246
 
5270
5247
  function deserializeBoxThrowStatement(pos) {
5271
- return deserializeThrowStatement(uint32[pos >> 2]);
5248
+ return deserializeThrowStatement(int32[pos >> 2]);
5272
5249
  }
5273
5250
 
5274
5251
  function deserializeBoxTryStatement(pos) {
5275
- return deserializeTryStatement(uint32[pos >> 2]);
5252
+ return deserializeTryStatement(int32[pos >> 2]);
5276
5253
  }
5277
5254
 
5278
5255
  function deserializeBoxWhileStatement(pos) {
5279
- return deserializeWhileStatement(uint32[pos >> 2]);
5256
+ return deserializeWhileStatement(int32[pos >> 2]);
5280
5257
  }
5281
5258
 
5282
5259
  function deserializeBoxWithStatement(pos) {
5283
- return deserializeWithStatement(uint32[pos >> 2]);
5260
+ return deserializeWithStatement(int32[pos >> 2]);
5284
5261
  }
5285
5262
 
5286
5263
  function deserializeBoxVariableDeclaration(pos) {
5287
- return deserializeVariableDeclaration(uint32[pos >> 2]);
5264
+ return deserializeVariableDeclaration(int32[pos >> 2]);
5288
5265
  }
5289
5266
 
5290
5267
  function deserializeBoxTSTypeAliasDeclaration(pos) {
5291
- return deserializeTSTypeAliasDeclaration(uint32[pos >> 2]);
5268
+ return deserializeTSTypeAliasDeclaration(int32[pos >> 2]);
5292
5269
  }
5293
5270
 
5294
5271
  function deserializeBoxTSInterfaceDeclaration(pos) {
5295
- return deserializeTSInterfaceDeclaration(uint32[pos >> 2]);
5272
+ return deserializeTSInterfaceDeclaration(int32[pos >> 2]);
5296
5273
  }
5297
5274
 
5298
5275
  function deserializeBoxTSEnumDeclaration(pos) {
5299
- return deserializeTSEnumDeclaration(uint32[pos >> 2]);
5276
+ return deserializeTSEnumDeclaration(int32[pos >> 2]);
5300
5277
  }
5301
5278
 
5302
5279
  function deserializeBoxTSModuleDeclaration(pos) {
5303
- return deserializeTSModuleDeclaration(uint32[pos >> 2]);
5280
+ return deserializeTSModuleDeclaration(int32[pos >> 2]);
5304
5281
  }
5305
5282
 
5306
5283
  function deserializeBoxTSGlobalDeclaration(pos) {
5307
- return deserializeTSGlobalDeclaration(uint32[pos >> 2]);
5284
+ return deserializeTSGlobalDeclaration(int32[pos >> 2]);
5308
5285
  }
5309
5286
 
5310
5287
  function deserializeBoxTSImportEqualsDeclaration(pos) {
5311
- return deserializeTSImportEqualsDeclaration(uint32[pos >> 2]);
5288
+ return deserializeTSImportEqualsDeclaration(int32[pos >> 2]);
5312
5289
  }
5313
5290
 
5314
5291
  function deserializeVecVariableDeclarator(pos) {
5315
5292
  let arr = [],
5316
5293
  pos32 = pos >> 2;
5317
- pos = uint32[pos32];
5318
- let endPos = pos + uint32[pos32 + 2] * 56;
5294
+ pos = int32[pos32];
5295
+ let endPos = pos + int32[pos32 + 2] * 56;
5319
5296
  for (; pos !== endPos; ) {
5320
5297
  arr.push(deserializeVariableDeclarator(pos));
5321
5298
  pos += 56;
@@ -5324,34 +5301,34 @@ function deserializeVecVariableDeclarator(pos) {
5324
5301
  }
5325
5302
 
5326
5303
  function deserializeBoxTSTypeAnnotation(pos) {
5327
- return deserializeTSTypeAnnotation(uint32[pos >> 2]);
5304
+ return deserializeTSTypeAnnotation(int32[pos >> 2]);
5328
5305
  }
5329
5306
 
5330
5307
  function deserializeOptionBoxTSTypeAnnotation(pos) {
5331
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5332
- return deserializeBoxTSTypeAnnotation(pos);
5308
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5309
+ ? null
5310
+ : deserializeBoxTSTypeAnnotation(pos);
5333
5311
  }
5334
5312
 
5335
5313
  function deserializeOptionStatement(pos) {
5336
- if (uint8[pos] === 70) return null;
5337
- return deserializeStatement(pos);
5314
+ return uint8[pos] === 70 ? null : deserializeStatement(pos);
5338
5315
  }
5339
5316
 
5340
5317
  function deserializeOptionForStatementInit(pos) {
5341
- if (uint8[pos] === 65) return null;
5342
- return deserializeForStatementInit(pos);
5318
+ return uint8[pos] === 65 ? null : deserializeForStatementInit(pos);
5343
5319
  }
5344
5320
 
5345
5321
  function deserializeOptionLabelIdentifier(pos) {
5346
- if (uint32[(pos + 16) >> 2] === 0 && uint32[(pos + 20) >> 2] === 0) return null;
5347
- return deserializeLabelIdentifier(pos);
5322
+ return int32[(pos >> 2) + 4] === 0 && int32[(pos >> 2) + 5] === 0
5323
+ ? null
5324
+ : deserializeLabelIdentifier(pos);
5348
5325
  }
5349
5326
 
5350
5327
  function deserializeVecSwitchCase(pos) {
5351
5328
  let arr = [],
5352
5329
  pos32 = pos >> 2;
5353
- pos = uint32[pos32];
5354
- let endPos = pos + uint32[pos32 + 2] * 56;
5330
+ pos = int32[pos32];
5331
+ let endPos = pos + int32[pos32 + 2] * 56;
5355
5332
  for (; pos !== endPos; ) {
5356
5333
  arr.push(deserializeSwitchCase(pos));
5357
5334
  pos += 56;
@@ -5360,45 +5337,46 @@ function deserializeVecSwitchCase(pos) {
5360
5337
  }
5361
5338
 
5362
5339
  function deserializeBoxCatchClause(pos) {
5363
- return deserializeCatchClause(uint32[pos >> 2]);
5340
+ return deserializeCatchClause(int32[pos >> 2]);
5364
5341
  }
5365
5342
 
5366
5343
  function deserializeOptionBoxCatchClause(pos) {
5367
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5368
- return deserializeBoxCatchClause(pos);
5344
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5345
+ ? null
5346
+ : deserializeBoxCatchClause(pos);
5369
5347
  }
5370
5348
 
5371
5349
  function deserializeOptionBoxBlockStatement(pos) {
5372
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5373
- return deserializeBoxBlockStatement(pos);
5350
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5351
+ ? null
5352
+ : deserializeBoxBlockStatement(pos);
5374
5353
  }
5375
5354
 
5376
5355
  function deserializeOptionCatchParameter(pos) {
5377
- if (uint8[pos + 16] === 4) return null;
5378
- return deserializeCatchParameter(pos);
5356
+ return uint8[pos + 16] === 4 ? null : deserializeCatchParameter(pos);
5379
5357
  }
5380
5358
 
5381
5359
  function deserializeBoxBindingIdentifier(pos) {
5382
- return deserializeBindingIdentifier(uint32[pos >> 2]);
5360
+ return deserializeBindingIdentifier(int32[pos >> 2]);
5383
5361
  }
5384
5362
 
5385
5363
  function deserializeBoxObjectPattern(pos) {
5386
- return deserializeObjectPattern(uint32[pos >> 2]);
5364
+ return deserializeObjectPattern(int32[pos >> 2]);
5387
5365
  }
5388
5366
 
5389
5367
  function deserializeBoxArrayPattern(pos) {
5390
- return deserializeArrayPattern(uint32[pos >> 2]);
5368
+ return deserializeArrayPattern(int32[pos >> 2]);
5391
5369
  }
5392
5370
 
5393
5371
  function deserializeBoxAssignmentPattern(pos) {
5394
- return deserializeAssignmentPattern(uint32[pos >> 2]);
5372
+ return deserializeAssignmentPattern(int32[pos >> 2]);
5395
5373
  }
5396
5374
 
5397
5375
  function deserializeVecBindingProperty(pos) {
5398
5376
  let arr = [],
5399
5377
  pos32 = pos >> 2;
5400
- pos = uint32[pos32];
5401
- let endPos = pos + uint32[pos32 + 2] * 48;
5378
+ pos = int32[pos32];
5379
+ let endPos = pos + int32[pos32 + 2] * 48;
5402
5380
  for (; pos !== endPos; ) {
5403
5381
  arr.push(deserializeBindingProperty(pos));
5404
5382
  pos += 48;
@@ -5407,24 +5385,24 @@ function deserializeVecBindingProperty(pos) {
5407
5385
  }
5408
5386
 
5409
5387
  function deserializeBoxBindingRestElement(pos) {
5410
- return deserializeBindingRestElement(uint32[pos >> 2]);
5388
+ return deserializeBindingRestElement(int32[pos >> 2]);
5411
5389
  }
5412
5390
 
5413
5391
  function deserializeOptionBoxBindingRestElement(pos) {
5414
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5415
- return deserializeBoxBindingRestElement(pos);
5392
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5393
+ ? null
5394
+ : deserializeBoxBindingRestElement(pos);
5416
5395
  }
5417
5396
 
5418
5397
  function deserializeOptionBindingPattern(pos) {
5419
- if (uint8[pos] === 4) return null;
5420
- return deserializeBindingPattern(pos);
5398
+ return uint8[pos] === 4 ? null : deserializeBindingPattern(pos);
5421
5399
  }
5422
5400
 
5423
5401
  function deserializeVecOptionBindingPattern(pos) {
5424
5402
  let arr = [],
5425
5403
  pos32 = pos >> 2;
5426
- pos = uint32[pos32];
5427
- let endPos = pos + uint32[pos32 + 2] * 16;
5404
+ pos = int32[pos32];
5405
+ let endPos = pos + (int32[pos32 + 2] << 4);
5428
5406
  for (; pos !== endPos; ) {
5429
5407
  arr.push(deserializeOptionBindingPattern(pos));
5430
5408
  pos += 16;
@@ -5433,46 +5411,50 @@ function deserializeVecOptionBindingPattern(pos) {
5433
5411
  }
5434
5412
 
5435
5413
  function deserializeOptionBindingIdentifier(pos) {
5436
- if (uint32[(pos + 16) >> 2] === 0 && uint32[(pos + 20) >> 2] === 0) return null;
5437
- return deserializeBindingIdentifier(pos);
5414
+ return int32[(pos >> 2) + 4] === 0 && int32[(pos >> 2) + 5] === 0
5415
+ ? null
5416
+ : deserializeBindingIdentifier(pos);
5438
5417
  }
5439
5418
 
5440
5419
  function deserializeBoxTSTypeParameterDeclaration(pos) {
5441
- return deserializeTSTypeParameterDeclaration(uint32[pos >> 2]);
5420
+ return deserializeTSTypeParameterDeclaration(int32[pos >> 2]);
5442
5421
  }
5443
5422
 
5444
5423
  function deserializeOptionBoxTSTypeParameterDeclaration(pos) {
5445
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5446
- return deserializeBoxTSTypeParameterDeclaration(pos);
5424
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5425
+ ? null
5426
+ : deserializeBoxTSTypeParameterDeclaration(pos);
5447
5427
  }
5448
5428
 
5449
5429
  function deserializeBoxTSThisParameter(pos) {
5450
- return deserializeTSThisParameter(uint32[pos >> 2]);
5430
+ return deserializeTSThisParameter(int32[pos >> 2]);
5451
5431
  }
5452
5432
 
5453
5433
  function deserializeOptionBoxTSThisParameter(pos) {
5454
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5455
- return deserializeBoxTSThisParameter(pos);
5434
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5435
+ ? null
5436
+ : deserializeBoxTSThisParameter(pos);
5456
5437
  }
5457
5438
 
5458
5439
  function deserializeBoxFormalParameters(pos) {
5459
- return deserializeFormalParameters(uint32[pos >> 2]);
5440
+ return deserializeFormalParameters(int32[pos >> 2]);
5460
5441
  }
5461
5442
 
5462
5443
  function deserializeBoxFunctionBody(pos) {
5463
- return deserializeFunctionBody(uint32[pos >> 2]);
5444
+ return deserializeFunctionBody(int32[pos >> 2]);
5464
5445
  }
5465
5446
 
5466
5447
  function deserializeOptionBoxFunctionBody(pos) {
5467
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5468
- return deserializeBoxFunctionBody(pos);
5448
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5449
+ ? null
5450
+ : deserializeBoxFunctionBody(pos);
5469
5451
  }
5470
5452
 
5471
5453
  function deserializeVecFormalParameter(pos) {
5472
5454
  let arr = [],
5473
5455
  pos32 = pos >> 2;
5474
- pos = uint32[pos32];
5475
- let endPos = pos + uint32[pos32 + 2] * 72;
5456
+ pos = int32[pos32];
5457
+ let endPos = pos + int32[pos32 + 2] * 72;
5476
5458
  for (; pos !== endPos; ) {
5477
5459
  arr.push(deserializeFormalParameter(pos));
5478
5460
  pos += 72;
@@ -5483,8 +5465,8 @@ function deserializeVecFormalParameter(pos) {
5483
5465
  function deserializeVecDecorator(pos) {
5484
5466
  let arr = [],
5485
5467
  pos32 = pos >> 2;
5486
- pos = uint32[pos32];
5487
- let endPos = pos + uint32[pos32 + 2] * 32;
5468
+ pos = int32[pos32];
5469
+ let endPos = pos + (int32[pos32 + 2] << 5);
5488
5470
  for (; pos !== endPos; ) {
5489
5471
  arr.push(deserializeDecorator(pos));
5490
5472
  pos += 32;
@@ -5493,24 +5475,24 @@ function deserializeVecDecorator(pos) {
5493
5475
  }
5494
5476
 
5495
5477
  function deserializeBoxExpression(pos) {
5496
- return deserializeExpression(uint32[pos >> 2]);
5478
+ return deserializeExpression(int32[pos >> 2]);
5497
5479
  }
5498
5480
 
5499
5481
  function deserializeOptionBoxExpression(pos) {
5500
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5501
- return deserializeBoxExpression(pos);
5482
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5483
+ ? null
5484
+ : deserializeBoxExpression(pos);
5502
5485
  }
5503
5486
 
5504
5487
  function deserializeOptionTSAccessibility(pos) {
5505
- if (uint8[pos] === 3) return null;
5506
- return deserializeTSAccessibility(pos);
5488
+ return uint8[pos] === 3 ? null : deserializeTSAccessibility(pos);
5507
5489
  }
5508
5490
 
5509
5491
  function deserializeVecTSClassImplements(pos) {
5510
5492
  let arr = [],
5511
5493
  pos32 = pos >> 2;
5512
- pos = uint32[pos32];
5513
- let endPos = pos + uint32[pos32 + 2] * 40;
5494
+ pos = int32[pos32];
5495
+ let endPos = pos + int32[pos32 + 2] * 40;
5514
5496
  for (; pos !== endPos; ) {
5515
5497
  arr.push(deserializeTSClassImplements(pos));
5516
5498
  pos += 40;
@@ -5519,14 +5501,14 @@ function deserializeVecTSClassImplements(pos) {
5519
5501
  }
5520
5502
 
5521
5503
  function deserializeBoxClassBody(pos) {
5522
- return deserializeClassBody(uint32[pos >> 2]);
5504
+ return deserializeClassBody(int32[pos >> 2]);
5523
5505
  }
5524
5506
 
5525
5507
  function deserializeVecClassElement(pos) {
5526
5508
  let arr = [],
5527
5509
  pos32 = pos >> 2;
5528
- pos = uint32[pos32];
5529
- let endPos = pos + uint32[pos32 + 2] * 16;
5510
+ pos = int32[pos32];
5511
+ let endPos = pos + (int32[pos32 + 2] << 4);
5530
5512
  for (; pos !== endPos; ) {
5531
5513
  arr.push(deserializeClassElement(pos));
5532
5514
  pos += 16;
@@ -5535,59 +5517,58 @@ function deserializeVecClassElement(pos) {
5535
5517
  }
5536
5518
 
5537
5519
  function deserializeBoxStaticBlock(pos) {
5538
- return deserializeStaticBlock(uint32[pos >> 2]);
5520
+ return deserializeStaticBlock(int32[pos >> 2]);
5539
5521
  }
5540
5522
 
5541
5523
  function deserializeBoxMethodDefinition(pos) {
5542
- return deserializeMethodDefinition(uint32[pos >> 2]);
5524
+ return deserializeMethodDefinition(int32[pos >> 2]);
5543
5525
  }
5544
5526
 
5545
5527
  function deserializeBoxPropertyDefinition(pos) {
5546
- return deserializePropertyDefinition(uint32[pos >> 2]);
5528
+ return deserializePropertyDefinition(int32[pos >> 2]);
5547
5529
  }
5548
5530
 
5549
5531
  function deserializeBoxAccessorProperty(pos) {
5550
- return deserializeAccessorProperty(uint32[pos >> 2]);
5532
+ return deserializeAccessorProperty(int32[pos >> 2]);
5551
5533
  }
5552
5534
 
5553
5535
  function deserializeBoxTSIndexSignature(pos) {
5554
- return deserializeTSIndexSignature(uint32[pos >> 2]);
5536
+ return deserializeTSIndexSignature(int32[pos >> 2]);
5555
5537
  }
5556
5538
 
5557
5539
  function deserializeBoxImportDeclaration(pos) {
5558
- return deserializeImportDeclaration(uint32[pos >> 2]);
5540
+ return deserializeImportDeclaration(int32[pos >> 2]);
5559
5541
  }
5560
5542
 
5561
5543
  function deserializeBoxExportAllDeclaration(pos) {
5562
- return deserializeExportAllDeclaration(uint32[pos >> 2]);
5544
+ return deserializeExportAllDeclaration(int32[pos >> 2]);
5563
5545
  }
5564
5546
 
5565
5547
  function deserializeBoxExportDefaultDeclaration(pos) {
5566
- return deserializeExportDefaultDeclaration(uint32[pos >> 2]);
5548
+ return deserializeExportDefaultDeclaration(int32[pos >> 2]);
5567
5549
  }
5568
5550
 
5569
5551
  function deserializeBoxExportNamedDeclaration(pos) {
5570
- return deserializeExportNamedDeclaration(uint32[pos >> 2]);
5552
+ return deserializeExportNamedDeclaration(int32[pos >> 2]);
5571
5553
  }
5572
5554
 
5573
5555
  function deserializeBoxTSExportAssignment(pos) {
5574
- return deserializeTSExportAssignment(uint32[pos >> 2]);
5556
+ return deserializeTSExportAssignment(int32[pos >> 2]);
5575
5557
  }
5576
5558
 
5577
5559
  function deserializeBoxTSNamespaceExportDeclaration(pos) {
5578
- return deserializeTSNamespaceExportDeclaration(uint32[pos >> 2]);
5560
+ return deserializeTSNamespaceExportDeclaration(int32[pos >> 2]);
5579
5561
  }
5580
5562
 
5581
5563
  function deserializeOptionImportPhase(pos) {
5582
- if (uint8[pos] === 2) return null;
5583
- return deserializeImportPhase(pos);
5564
+ return uint8[pos] === 2 ? null : deserializeImportPhase(pos);
5584
5565
  }
5585
5566
 
5586
5567
  function deserializeVecImportDeclarationSpecifier(pos) {
5587
5568
  let arr = [],
5588
5569
  pos32 = pos >> 2;
5589
- pos = uint32[pos32];
5590
- let endPos = pos + uint32[pos32 + 2] * 16;
5570
+ pos = int32[pos32];
5571
+ let endPos = pos + (int32[pos32 + 2] << 4);
5591
5572
  for (; pos !== endPos; ) {
5592
5573
  arr.push(deserializeImportDeclarationSpecifier(pos));
5593
5574
  pos += 16;
@@ -5596,36 +5577,38 @@ function deserializeVecImportDeclarationSpecifier(pos) {
5596
5577
  }
5597
5578
 
5598
5579
  function deserializeOptionVecImportDeclarationSpecifier(pos) {
5599
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5600
- return deserializeVecImportDeclarationSpecifier(pos);
5580
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5581
+ ? null
5582
+ : deserializeVecImportDeclarationSpecifier(pos);
5601
5583
  }
5602
5584
 
5603
5585
  function deserializeBoxWithClause(pos) {
5604
- return deserializeWithClause(uint32[pos >> 2]);
5586
+ return deserializeWithClause(int32[pos >> 2]);
5605
5587
  }
5606
5588
 
5607
5589
  function deserializeOptionBoxWithClause(pos) {
5608
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5609
- return deserializeBoxWithClause(pos);
5590
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5591
+ ? null
5592
+ : deserializeBoxWithClause(pos);
5610
5593
  }
5611
5594
 
5612
5595
  function deserializeBoxImportSpecifier(pos) {
5613
- return deserializeImportSpecifier(uint32[pos >> 2]);
5596
+ return deserializeImportSpecifier(int32[pos >> 2]);
5614
5597
  }
5615
5598
 
5616
5599
  function deserializeBoxImportDefaultSpecifier(pos) {
5617
- return deserializeImportDefaultSpecifier(uint32[pos >> 2]);
5600
+ return deserializeImportDefaultSpecifier(int32[pos >> 2]);
5618
5601
  }
5619
5602
 
5620
5603
  function deserializeBoxImportNamespaceSpecifier(pos) {
5621
- return deserializeImportNamespaceSpecifier(uint32[pos >> 2]);
5604
+ return deserializeImportNamespaceSpecifier(int32[pos >> 2]);
5622
5605
  }
5623
5606
 
5624
5607
  function deserializeVecImportAttribute(pos) {
5625
5608
  let arr = [],
5626
5609
  pos32 = pos >> 2;
5627
- pos = uint32[pos32];
5628
- let endPos = pos + uint32[pos32 + 2] * 120;
5610
+ pos = int32[pos32];
5611
+ let endPos = pos + int32[pos32 + 2] * 120;
5629
5612
  for (; pos !== endPos; ) {
5630
5613
  arr.push(deserializeImportAttribute(pos));
5631
5614
  pos += 120;
@@ -5634,15 +5617,14 @@ function deserializeVecImportAttribute(pos) {
5634
5617
  }
5635
5618
 
5636
5619
  function deserializeOptionDeclaration(pos) {
5637
- if (uint8[pos] === 31) return null;
5638
- return deserializeDeclaration(pos);
5620
+ return uint8[pos] === 31 ? null : deserializeDeclaration(pos);
5639
5621
  }
5640
5622
 
5641
5623
  function deserializeVecExportSpecifier(pos) {
5642
5624
  let arr = [],
5643
5625
  pos32 = pos >> 2;
5644
- pos = uint32[pos32];
5645
- let endPos = pos + uint32[pos32 + 2] * 128;
5626
+ pos = int32[pos32];
5627
+ let endPos = pos + (int32[pos32 + 2] << 7);
5646
5628
  for (; pos !== endPos; ) {
5647
5629
  arr.push(deserializeExportSpecifier(pos));
5648
5630
  pos += 128;
@@ -5651,13 +5633,11 @@ function deserializeVecExportSpecifier(pos) {
5651
5633
  }
5652
5634
 
5653
5635
  function deserializeOptionStringLiteral(pos) {
5654
- if (uint8[pos + 12] === 2) return null;
5655
- return deserializeStringLiteral(pos);
5636
+ return uint8[pos + 12] === 2 ? null : deserializeStringLiteral(pos);
5656
5637
  }
5657
5638
 
5658
5639
  function deserializeOptionModuleExportName(pos) {
5659
- if (uint8[pos] === 3) return null;
5660
- return deserializeModuleExportName(pos);
5640
+ return uint8[pos] === 3 ? null : deserializeModuleExportName(pos);
5661
5641
  }
5662
5642
 
5663
5643
  function deserializeF64(pos) {
@@ -5669,14 +5649,14 @@ function deserializeU8(pos) {
5669
5649
  }
5670
5650
 
5671
5651
  function deserializeBoxJSXOpeningElement(pos) {
5672
- return deserializeJSXOpeningElement(uint32[pos >> 2]);
5652
+ return deserializeJSXOpeningElement(int32[pos >> 2]);
5673
5653
  }
5674
5654
 
5675
5655
  function deserializeVecJSXChild(pos) {
5676
5656
  let arr = [],
5677
5657
  pos32 = pos >> 2;
5678
- pos = uint32[pos32];
5679
- let endPos = pos + uint32[pos32 + 2] * 16;
5658
+ pos = int32[pos32];
5659
+ let endPos = pos + (int32[pos32 + 2] << 4);
5680
5660
  for (; pos !== endPos; ) {
5681
5661
  arr.push(deserializeJSXChild(pos));
5682
5662
  pos += 16;
@@ -5685,19 +5665,20 @@ function deserializeVecJSXChild(pos) {
5685
5665
  }
5686
5666
 
5687
5667
  function deserializeBoxJSXClosingElement(pos) {
5688
- return deserializeJSXClosingElement(uint32[pos >> 2]);
5668
+ return deserializeJSXClosingElement(int32[pos >> 2]);
5689
5669
  }
5690
5670
 
5691
5671
  function deserializeOptionBoxJSXClosingElement(pos) {
5692
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
5693
- return deserializeBoxJSXClosingElement(pos);
5672
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
5673
+ ? null
5674
+ : deserializeBoxJSXClosingElement(pos);
5694
5675
  }
5695
5676
 
5696
5677
  function deserializeVecJSXAttributeItem(pos) {
5697
5678
  let arr = [],
5698
5679
  pos32 = pos >> 2;
5699
- pos = uint32[pos32];
5700
- let endPos = pos + uint32[pos32 + 2] * 16;
5680
+ pos = int32[pos32];
5681
+ let endPos = pos + (int32[pos32 + 2] << 4);
5701
5682
  for (; pos !== endPos; ) {
5702
5683
  arr.push(deserializeJSXAttributeItem(pos));
5703
5684
  pos += 16;
@@ -5706,47 +5687,46 @@ function deserializeVecJSXAttributeItem(pos) {
5706
5687
  }
5707
5688
 
5708
5689
  function deserializeBoxJSXIdentifier(pos) {
5709
- return deserializeJSXIdentifier(uint32[pos >> 2]);
5690
+ return deserializeJSXIdentifier(int32[pos >> 2]);
5710
5691
  }
5711
5692
 
5712
5693
  function deserializeBoxJSXNamespacedName(pos) {
5713
- return deserializeJSXNamespacedName(uint32[pos >> 2]);
5694
+ return deserializeJSXNamespacedName(int32[pos >> 2]);
5714
5695
  }
5715
5696
 
5716
5697
  function deserializeBoxJSXMemberExpression(pos) {
5717
- return deserializeJSXMemberExpression(uint32[pos >> 2]);
5698
+ return deserializeJSXMemberExpression(int32[pos >> 2]);
5718
5699
  }
5719
5700
 
5720
5701
  function deserializeBoxJSXAttribute(pos) {
5721
- return deserializeJSXAttribute(uint32[pos >> 2]);
5702
+ return deserializeJSXAttribute(int32[pos >> 2]);
5722
5703
  }
5723
5704
 
5724
5705
  function deserializeBoxJSXSpreadAttribute(pos) {
5725
- return deserializeJSXSpreadAttribute(uint32[pos >> 2]);
5706
+ return deserializeJSXSpreadAttribute(int32[pos >> 2]);
5726
5707
  }
5727
5708
 
5728
5709
  function deserializeOptionJSXAttributeValue(pos) {
5729
- if (uint8[pos] === 4) return null;
5730
- return deserializeJSXAttributeValue(pos);
5710
+ return uint8[pos] === 4 ? null : deserializeJSXAttributeValue(pos);
5731
5711
  }
5732
5712
 
5733
5713
  function deserializeBoxJSXExpressionContainer(pos) {
5734
- return deserializeJSXExpressionContainer(uint32[pos >> 2]);
5714
+ return deserializeJSXExpressionContainer(int32[pos >> 2]);
5735
5715
  }
5736
5716
 
5737
5717
  function deserializeBoxJSXText(pos) {
5738
- return deserializeJSXText(uint32[pos >> 2]);
5718
+ return deserializeJSXText(int32[pos >> 2]);
5739
5719
  }
5740
5720
 
5741
5721
  function deserializeBoxJSXSpreadChild(pos) {
5742
- return deserializeJSXSpreadChild(uint32[pos >> 2]);
5722
+ return deserializeJSXSpreadChild(int32[pos >> 2]);
5743
5723
  }
5744
5724
 
5745
5725
  function deserializeVecTSEnumMember(pos) {
5746
5726
  let arr = [],
5747
5727
  pos32 = pos >> 2;
5748
- pos = uint32[pos32];
5749
- let endPos = pos + uint32[pos32 + 2] * 48;
5728
+ pos = int32[pos32];
5729
+ let endPos = pos + int32[pos32 + 2] * 48;
5750
5730
  for (; pos !== endPos; ) {
5751
5731
  arr.push(deserializeTSEnumMember(pos));
5752
5732
  pos += 48;
@@ -5755,158 +5735,158 @@ function deserializeVecTSEnumMember(pos) {
5755
5735
  }
5756
5736
 
5757
5737
  function deserializeBoxTSAnyKeyword(pos) {
5758
- return deserializeTSAnyKeyword(uint32[pos >> 2]);
5738
+ return deserializeTSAnyKeyword(int32[pos >> 2]);
5759
5739
  }
5760
5740
 
5761
5741
  function deserializeBoxTSBigIntKeyword(pos) {
5762
- return deserializeTSBigIntKeyword(uint32[pos >> 2]);
5742
+ return deserializeTSBigIntKeyword(int32[pos >> 2]);
5763
5743
  }
5764
5744
 
5765
5745
  function deserializeBoxTSBooleanKeyword(pos) {
5766
- return deserializeTSBooleanKeyword(uint32[pos >> 2]);
5746
+ return deserializeTSBooleanKeyword(int32[pos >> 2]);
5767
5747
  }
5768
5748
 
5769
5749
  function deserializeBoxTSIntrinsicKeyword(pos) {
5770
- return deserializeTSIntrinsicKeyword(uint32[pos >> 2]);
5750
+ return deserializeTSIntrinsicKeyword(int32[pos >> 2]);
5771
5751
  }
5772
5752
 
5773
5753
  function deserializeBoxTSNeverKeyword(pos) {
5774
- return deserializeTSNeverKeyword(uint32[pos >> 2]);
5754
+ return deserializeTSNeverKeyword(int32[pos >> 2]);
5775
5755
  }
5776
5756
 
5777
5757
  function deserializeBoxTSNullKeyword(pos) {
5778
- return deserializeTSNullKeyword(uint32[pos >> 2]);
5758
+ return deserializeTSNullKeyword(int32[pos >> 2]);
5779
5759
  }
5780
5760
 
5781
5761
  function deserializeBoxTSNumberKeyword(pos) {
5782
- return deserializeTSNumberKeyword(uint32[pos >> 2]);
5762
+ return deserializeTSNumberKeyword(int32[pos >> 2]);
5783
5763
  }
5784
5764
 
5785
5765
  function deserializeBoxTSObjectKeyword(pos) {
5786
- return deserializeTSObjectKeyword(uint32[pos >> 2]);
5766
+ return deserializeTSObjectKeyword(int32[pos >> 2]);
5787
5767
  }
5788
5768
 
5789
5769
  function deserializeBoxTSStringKeyword(pos) {
5790
- return deserializeTSStringKeyword(uint32[pos >> 2]);
5770
+ return deserializeTSStringKeyword(int32[pos >> 2]);
5791
5771
  }
5792
5772
 
5793
5773
  function deserializeBoxTSSymbolKeyword(pos) {
5794
- return deserializeTSSymbolKeyword(uint32[pos >> 2]);
5774
+ return deserializeTSSymbolKeyword(int32[pos >> 2]);
5795
5775
  }
5796
5776
 
5797
5777
  function deserializeBoxTSUndefinedKeyword(pos) {
5798
- return deserializeTSUndefinedKeyword(uint32[pos >> 2]);
5778
+ return deserializeTSUndefinedKeyword(int32[pos >> 2]);
5799
5779
  }
5800
5780
 
5801
5781
  function deserializeBoxTSUnknownKeyword(pos) {
5802
- return deserializeTSUnknownKeyword(uint32[pos >> 2]);
5782
+ return deserializeTSUnknownKeyword(int32[pos >> 2]);
5803
5783
  }
5804
5784
 
5805
5785
  function deserializeBoxTSVoidKeyword(pos) {
5806
- return deserializeTSVoidKeyword(uint32[pos >> 2]);
5786
+ return deserializeTSVoidKeyword(int32[pos >> 2]);
5807
5787
  }
5808
5788
 
5809
5789
  function deserializeBoxTSArrayType(pos) {
5810
- return deserializeTSArrayType(uint32[pos >> 2]);
5790
+ return deserializeTSArrayType(int32[pos >> 2]);
5811
5791
  }
5812
5792
 
5813
5793
  function deserializeBoxTSConditionalType(pos) {
5814
- return deserializeTSConditionalType(uint32[pos >> 2]);
5794
+ return deserializeTSConditionalType(int32[pos >> 2]);
5815
5795
  }
5816
5796
 
5817
5797
  function deserializeBoxTSConstructorType(pos) {
5818
- return deserializeTSConstructorType(uint32[pos >> 2]);
5798
+ return deserializeTSConstructorType(int32[pos >> 2]);
5819
5799
  }
5820
5800
 
5821
5801
  function deserializeBoxTSFunctionType(pos) {
5822
- return deserializeTSFunctionType(uint32[pos >> 2]);
5802
+ return deserializeTSFunctionType(int32[pos >> 2]);
5823
5803
  }
5824
5804
 
5825
5805
  function deserializeBoxTSImportType(pos) {
5826
- return deserializeTSImportType(uint32[pos >> 2]);
5806
+ return deserializeTSImportType(int32[pos >> 2]);
5827
5807
  }
5828
5808
 
5829
5809
  function deserializeBoxTSIndexedAccessType(pos) {
5830
- return deserializeTSIndexedAccessType(uint32[pos >> 2]);
5810
+ return deserializeTSIndexedAccessType(int32[pos >> 2]);
5831
5811
  }
5832
5812
 
5833
5813
  function deserializeBoxTSInferType(pos) {
5834
- return deserializeTSInferType(uint32[pos >> 2]);
5814
+ return deserializeTSInferType(int32[pos >> 2]);
5835
5815
  }
5836
5816
 
5837
5817
  function deserializeBoxTSIntersectionType(pos) {
5838
- return deserializeTSIntersectionType(uint32[pos >> 2]);
5818
+ return deserializeTSIntersectionType(int32[pos >> 2]);
5839
5819
  }
5840
5820
 
5841
5821
  function deserializeBoxTSLiteralType(pos) {
5842
- return deserializeTSLiteralType(uint32[pos >> 2]);
5822
+ return deserializeTSLiteralType(int32[pos >> 2]);
5843
5823
  }
5844
5824
 
5845
5825
  function deserializeBoxTSMappedType(pos) {
5846
- return deserializeTSMappedType(uint32[pos >> 2]);
5826
+ return deserializeTSMappedType(int32[pos >> 2]);
5847
5827
  }
5848
5828
 
5849
5829
  function deserializeBoxTSNamedTupleMember(pos) {
5850
- return deserializeTSNamedTupleMember(uint32[pos >> 2]);
5830
+ return deserializeTSNamedTupleMember(int32[pos >> 2]);
5851
5831
  }
5852
5832
 
5853
5833
  function deserializeBoxTSTemplateLiteralType(pos) {
5854
- return deserializeTSTemplateLiteralType(uint32[pos >> 2]);
5834
+ return deserializeTSTemplateLiteralType(int32[pos >> 2]);
5855
5835
  }
5856
5836
 
5857
5837
  function deserializeBoxTSThisType(pos) {
5858
- return deserializeTSThisType(uint32[pos >> 2]);
5838
+ return deserializeTSThisType(int32[pos >> 2]);
5859
5839
  }
5860
5840
 
5861
5841
  function deserializeBoxTSTupleType(pos) {
5862
- return deserializeTSTupleType(uint32[pos >> 2]);
5842
+ return deserializeTSTupleType(int32[pos >> 2]);
5863
5843
  }
5864
5844
 
5865
5845
  function deserializeBoxTSTypeLiteral(pos) {
5866
- return deserializeTSTypeLiteral(uint32[pos >> 2]);
5846
+ return deserializeTSTypeLiteral(int32[pos >> 2]);
5867
5847
  }
5868
5848
 
5869
5849
  function deserializeBoxTSTypeOperator(pos) {
5870
- return deserializeTSTypeOperator(uint32[pos >> 2]);
5850
+ return deserializeTSTypeOperator(int32[pos >> 2]);
5871
5851
  }
5872
5852
 
5873
5853
  function deserializeBoxTSTypePredicate(pos) {
5874
- return deserializeTSTypePredicate(uint32[pos >> 2]);
5854
+ return deserializeTSTypePredicate(int32[pos >> 2]);
5875
5855
  }
5876
5856
 
5877
5857
  function deserializeBoxTSTypeQuery(pos) {
5878
- return deserializeTSTypeQuery(uint32[pos >> 2]);
5858
+ return deserializeTSTypeQuery(int32[pos >> 2]);
5879
5859
  }
5880
5860
 
5881
5861
  function deserializeBoxTSTypeReference(pos) {
5882
- return deserializeTSTypeReference(uint32[pos >> 2]);
5862
+ return deserializeTSTypeReference(int32[pos >> 2]);
5883
5863
  }
5884
5864
 
5885
5865
  function deserializeBoxTSUnionType(pos) {
5886
- return deserializeTSUnionType(uint32[pos >> 2]);
5866
+ return deserializeTSUnionType(int32[pos >> 2]);
5887
5867
  }
5888
5868
 
5889
5869
  function deserializeBoxTSParenthesizedType(pos) {
5890
- return deserializeTSParenthesizedType(uint32[pos >> 2]);
5870
+ return deserializeTSParenthesizedType(int32[pos >> 2]);
5891
5871
  }
5892
5872
 
5893
5873
  function deserializeBoxJSDocNullableType(pos) {
5894
- return deserializeJSDocNullableType(uint32[pos >> 2]);
5874
+ return deserializeJSDocNullableType(int32[pos >> 2]);
5895
5875
  }
5896
5876
 
5897
5877
  function deserializeBoxJSDocNonNullableType(pos) {
5898
- return deserializeJSDocNonNullableType(uint32[pos >> 2]);
5878
+ return deserializeJSDocNonNullableType(int32[pos >> 2]);
5899
5879
  }
5900
5880
 
5901
5881
  function deserializeBoxJSDocUnknownType(pos) {
5902
- return deserializeJSDocUnknownType(uint32[pos >> 2]);
5882
+ return deserializeJSDocUnknownType(int32[pos >> 2]);
5903
5883
  }
5904
5884
 
5905
5885
  function deserializeVecTSType(pos) {
5906
5886
  let arr = [],
5907
5887
  pos32 = pos >> 2;
5908
- pos = uint32[pos32];
5909
- let endPos = pos + uint32[pos32 + 2] * 16;
5888
+ pos = int32[pos32];
5889
+ let endPos = pos + (int32[pos32 + 2] << 4);
5910
5890
  for (; pos !== endPos; ) {
5911
5891
  arr.push(deserializeTSType(pos));
5912
5892
  pos += 16;
@@ -5917,8 +5897,8 @@ function deserializeVecTSType(pos) {
5917
5897
  function deserializeVecTSTupleElement(pos) {
5918
5898
  let arr = [],
5919
5899
  pos32 = pos >> 2;
5920
- pos = uint32[pos32];
5921
- let endPos = pos + uint32[pos32 + 2] * 16;
5900
+ pos = int32[pos32];
5901
+ let endPos = pos + (int32[pos32 + 2] << 4);
5922
5902
  for (; pos !== endPos; ) {
5923
5903
  arr.push(deserializeTSTupleElement(pos));
5924
5904
  pos += 16;
@@ -5927,27 +5907,26 @@ function deserializeVecTSTupleElement(pos) {
5927
5907
  }
5928
5908
 
5929
5909
  function deserializeBoxTSOptionalType(pos) {
5930
- return deserializeTSOptionalType(uint32[pos >> 2]);
5910
+ return deserializeTSOptionalType(int32[pos >> 2]);
5931
5911
  }
5932
5912
 
5933
5913
  function deserializeBoxTSRestType(pos) {
5934
- return deserializeTSRestType(uint32[pos >> 2]);
5914
+ return deserializeTSRestType(int32[pos >> 2]);
5935
5915
  }
5936
5916
 
5937
5917
  function deserializeBoxTSQualifiedName(pos) {
5938
- return deserializeTSQualifiedName(uint32[pos >> 2]);
5918
+ return deserializeTSQualifiedName(int32[pos >> 2]);
5939
5919
  }
5940
5920
 
5941
5921
  function deserializeOptionTSType(pos) {
5942
- if (uint8[pos] === 38) return null;
5943
- return deserializeTSType(pos);
5922
+ return uint8[pos] === 38 ? null : deserializeTSType(pos);
5944
5923
  }
5945
5924
 
5946
5925
  function deserializeVecTSTypeParameter(pos) {
5947
5926
  let arr = [],
5948
5927
  pos32 = pos >> 2;
5949
- pos = uint32[pos32];
5950
- let endPos = pos + uint32[pos32 + 2] * 80;
5928
+ pos = int32[pos32];
5929
+ let endPos = pos + int32[pos32 + 2] * 80;
5951
5930
  for (; pos !== endPos; ) {
5952
5931
  arr.push(deserializeTSTypeParameter(pos));
5953
5932
  pos += 80;
@@ -5958,8 +5937,8 @@ function deserializeVecTSTypeParameter(pos) {
5958
5937
  function deserializeVecTSInterfaceHeritage(pos) {
5959
5938
  let arr = [],
5960
5939
  pos32 = pos >> 2;
5961
- pos = uint32[pos32];
5962
- let endPos = pos + uint32[pos32 + 2] * 40;
5940
+ pos = int32[pos32];
5941
+ let endPos = pos + int32[pos32 + 2] * 40;
5963
5942
  for (; pos !== endPos; ) {
5964
5943
  arr.push(deserializeTSInterfaceHeritage(pos));
5965
5944
  pos += 40;
@@ -5968,14 +5947,14 @@ function deserializeVecTSInterfaceHeritage(pos) {
5968
5947
  }
5969
5948
 
5970
5949
  function deserializeBoxTSInterfaceBody(pos) {
5971
- return deserializeTSInterfaceBody(uint32[pos >> 2]);
5950
+ return deserializeTSInterfaceBody(int32[pos >> 2]);
5972
5951
  }
5973
5952
 
5974
5953
  function deserializeVecTSSignature(pos) {
5975
5954
  let arr = [],
5976
5955
  pos32 = pos >> 2;
5977
- pos = uint32[pos32];
5978
- let endPos = pos + uint32[pos32 + 2] * 16;
5956
+ pos = int32[pos32];
5957
+ let endPos = pos + (int32[pos32 + 2] << 4);
5979
5958
  for (; pos !== endPos; ) {
5980
5959
  arr.push(deserializeTSSignature(pos));
5981
5960
  pos += 16;
@@ -5984,26 +5963,26 @@ function deserializeVecTSSignature(pos) {
5984
5963
  }
5985
5964
 
5986
5965
  function deserializeBoxTSPropertySignature(pos) {
5987
- return deserializeTSPropertySignature(uint32[pos >> 2]);
5966
+ return deserializeTSPropertySignature(int32[pos >> 2]);
5988
5967
  }
5989
5968
 
5990
5969
  function deserializeBoxTSCallSignatureDeclaration(pos) {
5991
- return deserializeTSCallSignatureDeclaration(uint32[pos >> 2]);
5970
+ return deserializeTSCallSignatureDeclaration(int32[pos >> 2]);
5992
5971
  }
5993
5972
 
5994
5973
  function deserializeBoxTSConstructSignatureDeclaration(pos) {
5995
- return deserializeTSConstructSignatureDeclaration(uint32[pos >> 2]);
5974
+ return deserializeTSConstructSignatureDeclaration(int32[pos >> 2]);
5996
5975
  }
5997
5976
 
5998
5977
  function deserializeBoxTSMethodSignature(pos) {
5999
- return deserializeTSMethodSignature(uint32[pos >> 2]);
5978
+ return deserializeTSMethodSignature(int32[pos >> 2]);
6000
5979
  }
6001
5980
 
6002
5981
  function deserializeVecTSIndexSignatureName(pos) {
6003
5982
  let arr = [],
6004
5983
  pos32 = pos >> 2;
6005
- pos = uint32[pos32];
6006
- let endPos = pos + uint32[pos32 + 2] * 40;
5984
+ pos = int32[pos32];
5985
+ let endPos = pos + int32[pos32 + 2] * 40;
6007
5986
  for (; pos !== endPos; ) {
6008
5987
  arr.push(deserializeTSIndexSignatureName(pos));
6009
5988
  pos += 40;
@@ -6012,55 +5991,54 @@ function deserializeVecTSIndexSignatureName(pos) {
6012
5991
  }
6013
5992
 
6014
5993
  function deserializeOptionTSModuleDeclarationBody(pos) {
6015
- if (uint8[pos] === 2) return null;
6016
- return deserializeTSModuleDeclarationBody(pos);
5994
+ return uint8[pos] === 2 ? null : deserializeTSModuleDeclarationBody(pos);
6017
5995
  }
6018
5996
 
6019
5997
  function deserializeBoxTSModuleBlock(pos) {
6020
- return deserializeTSModuleBlock(uint32[pos >> 2]);
5998
+ return deserializeTSModuleBlock(int32[pos >> 2]);
6021
5999
  }
6022
6000
 
6023
6001
  function deserializeBoxTSTypeParameter(pos) {
6024
- return deserializeTSTypeParameter(uint32[pos >> 2]);
6002
+ return deserializeTSTypeParameter(int32[pos >> 2]);
6025
6003
  }
6026
6004
 
6027
6005
  function deserializeOptionBoxObjectExpression(pos) {
6028
- if (uint32[pos >> 2] === 0 && uint32[(pos + 4) >> 2] === 0) return null;
6029
- return deserializeBoxObjectExpression(pos);
6006
+ return int32[pos >> 2] === 0 && int32[(pos >> 2) + 1] === 0
6007
+ ? null
6008
+ : deserializeBoxObjectExpression(pos);
6030
6009
  }
6031
6010
 
6032
6011
  function deserializeOptionTSImportTypeQualifier(pos) {
6033
- if (uint8[pos] === 2) return null;
6034
- return deserializeTSImportTypeQualifier(pos);
6012
+ return uint8[pos] === 2 ? null : deserializeTSImportTypeQualifier(pos);
6035
6013
  }
6036
6014
 
6037
6015
  function deserializeBoxTSImportTypeQualifiedName(pos) {
6038
- return deserializeTSImportTypeQualifiedName(uint32[pos >> 2]);
6016
+ return deserializeTSImportTypeQualifiedName(int32[pos >> 2]);
6039
6017
  }
6040
6018
 
6041
6019
  function deserializeOptionTSMappedTypeModifierOperator(pos) {
6042
- if (uint8[pos] === 3) return null;
6043
- return deserializeTSMappedTypeModifierOperator(pos);
6020
+ return uint8[pos] === 3 ? null : deserializeTSMappedTypeModifierOperator(pos);
6044
6021
  }
6045
6022
 
6046
6023
  function deserializeBoxTSExternalModuleReference(pos) {
6047
- return deserializeTSExternalModuleReference(uint32[pos >> 2]);
6024
+ return deserializeTSExternalModuleReference(int32[pos >> 2]);
6048
6025
  }
6049
6026
 
6050
- function deserializeU32(pos) {
6051
- return uint32[pos >> 2];
6027
+ function deserializeI32(pos) {
6028
+ return int32[pos >> 2];
6052
6029
  }
6053
6030
 
6054
6031
  function deserializeOptionNameSpan(pos) {
6055
- if (uint32[(pos + 8) >> 2] === 0 && uint32[(pos + 12) >> 2] === 0) return null;
6056
- return deserializeNameSpan(pos);
6032
+ return int32[(pos >> 2) + 2] === 0 && int32[(pos >> 2) + 3] === 0
6033
+ ? null
6034
+ : deserializeNameSpan(pos);
6057
6035
  }
6058
6036
 
6059
6037
  function deserializeVecError(pos) {
6060
6038
  let arr = [],
6061
6039
  pos32 = pos >> 2;
6062
- pos = uint32[pos32];
6063
- let endPos = pos + uint32[pos32 + 2] * 80;
6040
+ pos = int32[pos32];
6041
+ let endPos = pos + int32[pos32 + 2] * 80;
6064
6042
  for (; pos !== endPos; ) {
6065
6043
  arr.push(deserializeError(pos));
6066
6044
  pos += 80;
@@ -6071,8 +6049,8 @@ function deserializeVecError(pos) {
6071
6049
  function deserializeVecErrorLabel(pos) {
6072
6050
  let arr = [],
6073
6051
  pos32 = pos >> 2;
6074
- pos = uint32[pos32];
6075
- let endPos = pos + uint32[pos32 + 2] * 24;
6052
+ pos = int32[pos32];
6053
+ let endPos = pos + int32[pos32 + 2] * 24;
6076
6054
  for (; pos !== endPos; ) {
6077
6055
  arr.push(deserializeErrorLabel(pos));
6078
6056
  pos += 24;
@@ -6083,8 +6061,8 @@ function deserializeVecErrorLabel(pos) {
6083
6061
  function deserializeVecStaticImport(pos) {
6084
6062
  let arr = [],
6085
6063
  pos32 = pos >> 2;
6086
- pos = uint32[pos32];
6087
- let endPos = pos + uint32[pos32 + 2] * 56;
6064
+ pos = int32[pos32];
6065
+ let endPos = pos + int32[pos32 + 2] * 56;
6088
6066
  for (; pos !== endPos; ) {
6089
6067
  arr.push(deserializeStaticImport(pos));
6090
6068
  pos += 56;
@@ -6095,8 +6073,8 @@ function deserializeVecStaticImport(pos) {
6095
6073
  function deserializeVecStaticExport(pos) {
6096
6074
  let arr = [],
6097
6075
  pos32 = pos >> 2;
6098
- pos = uint32[pos32];
6099
- let endPos = pos + uint32[pos32 + 2] * 32;
6076
+ pos = int32[pos32];
6077
+ let endPos = pos + (int32[pos32 + 2] << 5);
6100
6078
  for (; pos !== endPos; ) {
6101
6079
  arr.push(deserializeStaticExport(pos));
6102
6080
  pos += 32;
@@ -6107,8 +6085,8 @@ function deserializeVecStaticExport(pos) {
6107
6085
  function deserializeVecDynamicImport(pos) {
6108
6086
  let arr = [],
6109
6087
  pos32 = pos >> 2;
6110
- pos = uint32[pos32];
6111
- let endPos = pos + uint32[pos32 + 2] * 16;
6088
+ pos = int32[pos32];
6089
+ let endPos = pos + (int32[pos32 + 2] << 4);
6112
6090
  for (; pos !== endPos; ) {
6113
6091
  arr.push(deserializeDynamicImport(pos));
6114
6092
  pos += 16;
@@ -6119,8 +6097,8 @@ function deserializeVecDynamicImport(pos) {
6119
6097
  function deserializeVecSpan(pos) {
6120
6098
  let arr = [],
6121
6099
  pos32 = pos >> 2;
6122
- pos = uint32[pos32];
6123
- let endPos = pos + uint32[pos32 + 2] * 8;
6100
+ pos = int32[pos32];
6101
+ let endPos = pos + (int32[pos32 + 2] << 3);
6124
6102
  for (; pos !== endPos; ) {
6125
6103
  arr.push(deserializeSpan(pos));
6126
6104
  pos += 8;
@@ -6131,8 +6109,8 @@ function deserializeVecSpan(pos) {
6131
6109
  function deserializeVecImportEntry(pos) {
6132
6110
  let arr = [],
6133
6111
  pos32 = pos >> 2;
6134
- pos = uint32[pos32];
6135
- let endPos = pos + uint32[pos32 + 2] * 96;
6112
+ pos = int32[pos32];
6113
+ let endPos = pos + int32[pos32 + 2] * 96;
6136
6114
  for (; pos !== endPos; ) {
6137
6115
  arr.push(deserializeImportEntry(pos));
6138
6116
  pos += 96;
@@ -6143,8 +6121,8 @@ function deserializeVecImportEntry(pos) {
6143
6121
  function deserializeVecExportEntry(pos) {
6144
6122
  let arr = [],
6145
6123
  pos32 = pos >> 2;
6146
- pos = uint32[pos32];
6147
- let endPos = pos + uint32[pos32 + 2] * 144;
6124
+ pos = int32[pos32];
6125
+ let endPos = pos + int32[pos32 + 2] * 144;
6148
6126
  for (; pos !== endPos; ) {
6149
6127
  arr.push(deserializeExportEntry(pos));
6150
6128
  pos += 144;