@danielx/civet 0.2.10 → 0.2.13

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 (9) hide show
  1. package/README.md +25 -8
  2. package/dist/browser.js +329 -262
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +11 -11
  5. package/dist/cli.js.map +3 -3
  6. package/dist/main.js +329 -262
  7. package/dist/types.d.ts +3 -1
  8. package/esbuild-plugin.js +26 -0
  9. package/package.json +2 -1
package/dist/main.js CHANGED
@@ -462,7 +462,8 @@ var require_parser = __commonJS({
462
462
  ThinArrowFunction,
463
463
  Block,
464
464
  BracedBlock,
465
- SingleNestedBlockExpression,
465
+ SingleNestedExpression,
466
+ SingleNestedBlockStatement,
466
467
  NestedBlockExpressions,
467
468
  BlockExpression,
468
469
  Literal,
@@ -508,6 +509,7 @@ var require_parser = __commonJS({
508
509
  LoopStatement,
509
510
  DoWhileStatement,
510
511
  WhileStatement,
512
+ WhileClause,
511
513
  ForStatement,
512
514
  ForInOfStatement,
513
515
  ForDeclaration,
@@ -527,6 +529,8 @@ var require_parser = __commonJS({
527
529
  Condition,
528
530
  ExpressionStatement,
529
531
  KeywordStatement,
532
+ MaybeNestedExpression,
533
+ Return,
530
534
  ImportDeclaration,
531
535
  ImportClause,
532
536
  NameSpaceImport,
@@ -672,113 +676,115 @@ var require_parser = __commonJS({
672
676
  var $L24 = $L("[");
673
677
  var $L25 = $L("]");
674
678
  var $L26 = $L(".");
675
- var $L27 = $L("super[");
676
- var $L28 = $L("new.target");
677
- var $L29 = $L("import.meta");
678
- var $L30 = $L("");
679
- var $L31 = $L("...");
680
- var $L32 = $L("function");
681
- var $L33 = $L("->");
682
- var $L34 = $L("true");
683
- var $L35 = $L("false");
684
- var $L36 = $L("null");
685
- var $L37 = $L("undefined");
686
- var $L38 = $L("get");
687
- var $L39 = $L("set");
688
- var $L40 = $L("**=");
689
- var $L41 = $L("*=");
690
- var $L42 = $L("/=");
691
- var $L43 = $L("%=");
692
- var $L44 = $L("+=");
693
- var $L45 = $L("-=");
694
- var $L46 = $L("<<=");
695
- var $L47 = $L(">>>=");
696
- var $L48 = $L(">>=");
697
- var $L49 = $L("&&=");
698
- var $L50 = $L("&=");
699
- var $L51 = $L("^=");
700
- var $L52 = $L("||=");
701
- var $L53 = $L("|=");
702
- var $L54 = $L("??=");
703
- var $L55 = $L("=");
704
- var $L56 = $L("**");
705
- var $L57 = $L("/");
706
- var $L58 = $L("%");
707
- var $L59 = $L("+");
708
- var $L60 = $L("-");
709
- var $L61 = $L("<=");
710
- var $L62 = $L(">=");
711
- var $L63 = $L("<<");
712
- var $L64 = $L(">>>");
713
- var $L65 = $L(">>");
714
- var $L66 = $L(">");
715
- var $L67 = $L("!==");
716
- var $L68 = $L("!=");
717
- var $L69 = $L("is");
718
- var $L70 = $L("===");
719
- var $L71 = $L("==");
720
- var $L72 = $L("and");
721
- var $L73 = $L("&&");
722
- var $L74 = $L("or");
723
- var $L75 = $L("||");
724
- var $L76 = $L("??");
725
- var $L77 = $L("instanceof");
726
- var $L78 = $L("in");
727
- var $L79 = $L("&");
728
- var $L80 = $L("^");
729
- var $L81 = $L("|");
730
- var $L82 = $L("delete");
731
- var $L83 = $L("void");
732
- var $L84 = $L("typeof");
733
- var $L85 = $L("if");
734
- var $L86 = $L("unless");
735
- var $L87 = $L(";");
736
- var $L88 = $L("else");
737
- var $L89 = $L("loop");
738
- var $L90 = $L("do");
739
- var $L91 = $L("while");
740
- var $L92 = $L("for");
741
- var $L93 = $L("var");
742
- var $L94 = $L("await");
743
- var $L95 = $L("of");
744
- var $L96 = $L("let");
745
- var $L97 = $L("const");
746
- var $L98 = $L("switch");
747
- var $L99 = $L("case");
748
- var $L100 = $L("default");
749
- var $L101 = $L("when");
750
- var $L102 = $L("try");
751
- var $L103 = $L("catch");
752
- var $L104 = $L("finally");
753
- var $L105 = $L("break");
754
- var $L106 = $L("continue");
755
- var $L107 = $L("debugger");
756
- var $L108 = $L("return");
757
- var $L109 = $L("throw");
758
- var $L110 = $L("import type");
759
- var $L111 = $L("from");
760
- var $L112 = $L("export");
761
- var $L113 = $L(":=");
762
- var $L114 = $L('"""');
763
- var $L115 = $L('"');
764
- var $L116 = $L("'");
765
- var $L117 = $L("\\");
766
- var $L118 = $L("`");
767
- var $L119 = $L("${");
768
- var $L120 = $L("/*");
769
- var $L121 = $L("*/");
770
- var $L122 = $L("###");
771
- var $L123 = $L("/>");
772
- var $L124 = $L("</");
773
- var $L125 = $L("<>");
774
- var $L126 = $L("</>");
775
- var $L127 = $L("readonly");
776
- var $L128 = $L("asserts");
777
- var $L129 = $L("keyof");
778
- var $L130 = $L("infer");
779
- var $L131 = $L("[]");
780
- var $L132 = $L(" ");
781
- var $L133 = $L(" ");
679
+ var $L27 = $L("::");
680
+ var $L28 = $L("super[");
681
+ var $L29 = $L("new.target");
682
+ var $L30 = $L("import.meta");
683
+ var $L31 = $L("");
684
+ var $L32 = $L("...");
685
+ var $L33 = $L("function");
686
+ var $L34 = $L("->");
687
+ var $L35 = $L("true");
688
+ var $L36 = $L("false");
689
+ var $L37 = $L("null");
690
+ var $L38 = $L("undefined");
691
+ var $L39 = $L("get");
692
+ var $L40 = $L("set");
693
+ var $L41 = $L("**=");
694
+ var $L42 = $L("*=");
695
+ var $L43 = $L("/=");
696
+ var $L44 = $L("%=");
697
+ var $L45 = $L("+=");
698
+ var $L46 = $L("-=");
699
+ var $L47 = $L("<<=");
700
+ var $L48 = $L(">>>=");
701
+ var $L49 = $L(">>=");
702
+ var $L50 = $L("&&=");
703
+ var $L51 = $L("&=");
704
+ var $L52 = $L("^=");
705
+ var $L53 = $L("||=");
706
+ var $L54 = $L("|=");
707
+ var $L55 = $L("??=");
708
+ var $L56 = $L("=");
709
+ var $L57 = $L("**");
710
+ var $L58 = $L("/");
711
+ var $L59 = $L("%");
712
+ var $L60 = $L("+");
713
+ var $L61 = $L("-");
714
+ var $L62 = $L("<=");
715
+ var $L63 = $L(">=");
716
+ var $L64 = $L("<<");
717
+ var $L65 = $L(">>>");
718
+ var $L66 = $L(">>");
719
+ var $L67 = $L(">");
720
+ var $L68 = $L("!==");
721
+ var $L69 = $L("!=");
722
+ var $L70 = $L("is");
723
+ var $L71 = $L("===");
724
+ var $L72 = $L("==");
725
+ var $L73 = $L("and");
726
+ var $L74 = $L("&&");
727
+ var $L75 = $L("or");
728
+ var $L76 = $L("||");
729
+ var $L77 = $L("??");
730
+ var $L78 = $L("instanceof");
731
+ var $L79 = $L("in");
732
+ var $L80 = $L("&");
733
+ var $L81 = $L("^");
734
+ var $L82 = $L("|");
735
+ var $L83 = $L("delete");
736
+ var $L84 = $L("void");
737
+ var $L85 = $L("typeof");
738
+ var $L86 = $L("if");
739
+ var $L87 = $L("unless");
740
+ var $L88 = $L(";");
741
+ var $L89 = $L("else");
742
+ var $L90 = $L("loop");
743
+ var $L91 = $L("do");
744
+ var $L92 = $L("while");
745
+ var $L93 = $L("until");
746
+ var $L94 = $L("for");
747
+ var $L95 = $L("var");
748
+ var $L96 = $L("await");
749
+ var $L97 = $L("of");
750
+ var $L98 = $L("let");
751
+ var $L99 = $L("const");
752
+ var $L100 = $L("switch");
753
+ var $L101 = $L("case");
754
+ var $L102 = $L("default");
755
+ var $L103 = $L("when");
756
+ var $L104 = $L("try");
757
+ var $L105 = $L("catch");
758
+ var $L106 = $L("finally");
759
+ var $L107 = $L("break");
760
+ var $L108 = $L("continue");
761
+ var $L109 = $L("debugger");
762
+ var $L110 = $L("throw");
763
+ var $L111 = $L("return");
764
+ var $L112 = $L("import type");
765
+ var $L113 = $L("from");
766
+ var $L114 = $L("export");
767
+ var $L115 = $L(":=");
768
+ var $L116 = $L('"""');
769
+ var $L117 = $L('"');
770
+ var $L118 = $L("'");
771
+ var $L119 = $L("\\");
772
+ var $L120 = $L("`");
773
+ var $L121 = $L("${");
774
+ var $L122 = $L("/*");
775
+ var $L123 = $L("*/");
776
+ var $L124 = $L("###");
777
+ var $L125 = $L("/>");
778
+ var $L126 = $L("</");
779
+ var $L127 = $L("<>");
780
+ var $L128 = $L("</>");
781
+ var $L129 = $L("readonly");
782
+ var $L130 = $L("asserts");
783
+ var $L131 = $L("keyof");
784
+ var $L132 = $L("infer");
785
+ var $L133 = $L("[]");
786
+ var $L134 = $L(" ");
787
+ var $L135 = $L(" ");
782
788
  var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
783
789
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
784
790
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
@@ -998,7 +1004,7 @@ var require_parser = __commonJS({
998
1004
  return FatArrow$0(state);
999
1005
  }
1000
1006
  }
1001
- var ConciseBody$0 = $S(EOS, SingleNestedBlockExpression);
1007
+ var ConciseBody$0 = $S(EOS, SingleNestedBlockStatement);
1002
1008
  var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
1003
1009
  var ConciseBody$2 = BracedBlock;
1004
1010
  function ConciseBody(state) {
@@ -1188,12 +1194,18 @@ var require_parser = __commonJS({
1188
1194
  var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
1189
1195
  var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L24, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L25, fail, 'CallExpressionRest "]"'));
1190
1196
  var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L26, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
1191
- var CallExpressionRest$3 = TemplateLiteral;
1197
+ var CallExpressionRest$3 = $TS($S($EXPECT($L27, fail, 'CallExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1198
+ var id = $2;
1199
+ if (id)
1200
+ return [".prototype.", id];
1201
+ return ".prototype";
1202
+ });
1203
+ var CallExpressionRest$4 = TemplateLiteral;
1192
1204
  function CallExpressionRest(state) {
1193
1205
  if (state.tokenize) {
1194
- return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state));
1206
+ return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state) || CallExpressionRest$4(state));
1195
1207
  } else {
1196
- return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
1208
+ return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state) || CallExpressionRest$4(state);
1197
1209
  }
1198
1210
  }
1199
1211
  var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L26, fail, 'OptionalShorthand "."'), InsertDot));
@@ -1250,7 +1262,7 @@ var require_parser = __commonJS({
1250
1262
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1251
1263
  }
1252
1264
  }
1253
- var SuperProperty$0 = $S($EXPECT($L27, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
1265
+ var SuperProperty$0 = $S($EXPECT($L28, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L25, fail, 'SuperProperty "]"'));
1254
1266
  function SuperProperty(state) {
1255
1267
  if (state.verbose)
1256
1268
  console.log("ENTER:", "SuperProperty");
@@ -1260,8 +1272,8 @@ var require_parser = __commonJS({
1260
1272
  return SuperProperty$0(state);
1261
1273
  }
1262
1274
  }
1263
- var MetaProperty$0 = $EXPECT($L28, fail, 'MetaProperty "new.target"');
1264
- var MetaProperty$1 = $EXPECT($L29, fail, 'MetaProperty "import.meta"');
1275
+ var MetaProperty$0 = $EXPECT($L29, fail, 'MetaProperty "new.target"');
1276
+ var MetaProperty$1 = $EXPECT($L30, fail, 'MetaProperty "import.meta"');
1265
1277
  function MetaProperty(state) {
1266
1278
  if (state.tokenize) {
1267
1279
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1270,7 +1282,7 @@ var require_parser = __commonJS({
1270
1282
  }
1271
1283
  }
1272
1284
  var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1273
- var Parameters$1 = $T($EXPECT($L30, fail, 'Parameters ""'), function(value) {
1285
+ var Parameters$1 = $T($EXPECT($L31, fail, 'Parameters ""'), function(value) {
1274
1286
  return "()";
1275
1287
  });
1276
1288
  function Parameters(state) {
@@ -1353,7 +1365,7 @@ var require_parser = __commonJS({
1353
1365
  return BindingProperty$0(state) || BindingProperty$1(state);
1354
1366
  }
1355
1367
  }
1356
- var BindingRestProperty$0 = $S($EXPECT($L31, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1368
+ var BindingRestProperty$0 = $S($EXPECT($L32, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1357
1369
  function BindingRestProperty(state) {
1358
1370
  if (state.verbose)
1359
1371
  console.log("ENTER:", "BindingRestProperty");
@@ -1373,7 +1385,7 @@ var require_parser = __commonJS({
1373
1385
  return BindingElement$0(state);
1374
1386
  }
1375
1387
  }
1376
- var BindingRestElement$0 = $S($EXPECT($L31, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1388
+ var BindingRestElement$0 = $S($EXPECT($L32, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1377
1389
  function BindingRestElement(state) {
1378
1390
  if (state.verbose)
1379
1391
  console.log("ENTER:", "BindingRestElement");
@@ -1394,7 +1406,7 @@ var require_parser = __commonJS({
1394
1406
  }
1395
1407
  }
1396
1408
  var FunctionExpression$0 = ThinArrowFunction;
1397
- var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L32, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L9, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1409
+ var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L33, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L9, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1398
1410
  function FunctionExpression(state) {
1399
1411
  if (state.tokenize) {
1400
1412
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1402,7 +1414,7 @@ var require_parser = __commonJS({
1402
1414
  return FunctionExpression$0(state) || FunctionExpression$1(state);
1403
1415
  }
1404
1416
  }
1405
- var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L33, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1417
+ var ThinArrowFunction$0 = $T($S(Parameters, $E(ReturnTypeSuffix), __, $EXPECT($L34, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
1406
1418
  var params = value[0];
1407
1419
  var suffix = value[1];
1408
1420
  var block = value[4];
@@ -1438,19 +1450,34 @@ var require_parser = __commonJS({
1438
1450
  return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
1439
1451
  }
1440
1452
  }
1441
- var SingleNestedBlockExpression$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), $S(PopIndent, $N($EXPECT($L30, fail, 'SingleNestedBlockExpression ""')))), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
1453
+ var SingleNestedExpression$0 = $TS($S(PushIndent, $E($S(Nested, Expression, StatementDelimiter)), $C($S($N($S(Nested, Expression)), PopIndent), $S(PopIndent, $N($EXPECT($L31, fail, 'SingleNestedExpression ""'))))), function($skip, $loc, $0, $1, $2, $3) {
1454
+ var exp = $2;
1455
+ if (exp)
1456
+ return exp;
1457
+ return $skip;
1458
+ });
1459
+ function SingleNestedExpression(state) {
1460
+ if (state.verbose)
1461
+ console.log("ENTER:", "SingleNestedExpression");
1462
+ if (state.tokenize) {
1463
+ return $TOKEN("SingleNestedExpression", state, SingleNestedExpression$0(state));
1464
+ } else {
1465
+ return SingleNestedExpression$0(state);
1466
+ }
1467
+ }
1468
+ var SingleNestedBlockStatement$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), $S(PopIndent, $N($EXPECT($L31, fail, 'SingleNestedBlockStatement ""')))), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
1442
1469
  var exp = $2;
1443
1470
  if (exp)
1444
1471
  return exp;
1445
1472
  return $skip;
1446
1473
  });
1447
- function SingleNestedBlockExpression(state) {
1474
+ function SingleNestedBlockStatement(state) {
1448
1475
  if (state.verbose)
1449
- console.log("ENTER:", "SingleNestedBlockExpression");
1476
+ console.log("ENTER:", "SingleNestedBlockStatement");
1450
1477
  if (state.tokenize) {
1451
- return $TOKEN("SingleNestedBlockExpression", state, SingleNestedBlockExpression$0(state));
1478
+ return $TOKEN("SingleNestedBlockStatement", state, SingleNestedBlockStatement$0(state));
1452
1479
  } else {
1453
- return SingleNestedBlockExpression$0(state);
1480
+ return SingleNestedBlockStatement$0(state);
1454
1481
  }
1455
1482
  }
1456
1483
  var NestedBlockExpressions$0 = $TS($S(PushIndent, $Q(BlockExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
@@ -1480,10 +1507,10 @@ var require_parser = __commonJS({
1480
1507
  }
1481
1508
  var Literal$0 = StringLiteral;
1482
1509
  var Literal$1 = NumericLiteral;
1483
- var Literal$2 = $EXPECT($L34, fail, 'Literal "true"');
1484
- var Literal$3 = $EXPECT($L35, fail, 'Literal "false"');
1485
- var Literal$4 = $EXPECT($L36, fail, 'Literal "null"');
1486
- var Literal$5 = $EXPECT($L37, fail, 'Literal "undefined"');
1510
+ var Literal$2 = $EXPECT($L35, fail, 'Literal "true"');
1511
+ var Literal$3 = $EXPECT($L36, fail, 'Literal "false"');
1512
+ var Literal$4 = $EXPECT($L37, fail, 'Literal "null"');
1513
+ var Literal$5 = $EXPECT($L38, fail, 'Literal "undefined"');
1487
1514
  function Literal(state) {
1488
1515
  if (state.tokenize) {
1489
1516
  return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
@@ -1600,7 +1627,7 @@ var require_parser = __commonJS({
1600
1627
  return InlineElementList$0(state);
1601
1628
  }
1602
1629
  }
1603
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L31, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1630
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L32, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1604
1631
  function ArrayElementExpression(state) {
1605
1632
  if (state.verbose)
1606
1633
  console.log("ENTER:", "ArrayElementExpression");
@@ -1683,7 +1710,7 @@ var require_parser = __commonJS({
1683
1710
  }
1684
1711
  var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L12, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1685
1712
  var PropertyDefinition$1 = MethodDefinition;
1686
- var PropertyDefinition$2 = $S($EXPECT($L31, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1713
+ var PropertyDefinition$2 = $S($EXPECT($L32, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1687
1714
  var PropertyDefinition$3 = IdentifierReference;
1688
1715
  function PropertyDefinition(state) {
1689
1716
  if (state.tokenize) {
@@ -1703,8 +1730,8 @@ var require_parser = __commonJS({
1703
1730
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1704
1731
  }
1705
1732
  }
1706
- var MethodDefinition$0 = $S($EXPECT($L38, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1707
- var MethodDefinition$1 = $S($EXPECT($L39, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1733
+ var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1734
+ var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1708
1735
  var MethodDefinition$2 = AsyncGeneratorMethod;
1709
1736
  var MethodDefinition$3 = AsyncMethod;
1710
1737
  var MethodDefinition$4 = GeneratorMethod;
@@ -1795,22 +1822,22 @@ var require_parser = __commonJS({
1795
1822
  return AsyncGeneratorBody$0(state);
1796
1823
  }
1797
1824
  }
1798
- var AssignmentOp$0 = $EXPECT($L40, fail, 'AssignmentOp "**="');
1799
- var AssignmentOp$1 = $EXPECT($L41, fail, 'AssignmentOp "*="');
1800
- var AssignmentOp$2 = $EXPECT($L42, fail, 'AssignmentOp "/="');
1801
- var AssignmentOp$3 = $EXPECT($L43, fail, 'AssignmentOp "%="');
1802
- var AssignmentOp$4 = $EXPECT($L44, fail, 'AssignmentOp "+="');
1803
- var AssignmentOp$5 = $EXPECT($L45, fail, 'AssignmentOp "-="');
1804
- var AssignmentOp$6 = $EXPECT($L46, fail, 'AssignmentOp "<<="');
1805
- var AssignmentOp$7 = $EXPECT($L47, fail, 'AssignmentOp ">>>="');
1806
- var AssignmentOp$8 = $EXPECT($L48, fail, 'AssignmentOp ">>="');
1807
- var AssignmentOp$9 = $EXPECT($L49, fail, 'AssignmentOp "&&="');
1808
- var AssignmentOp$10 = $EXPECT($L50, fail, 'AssignmentOp "&="');
1809
- var AssignmentOp$11 = $EXPECT($L51, fail, 'AssignmentOp "^="');
1810
- var AssignmentOp$12 = $EXPECT($L52, fail, 'AssignmentOp "||="');
1811
- var AssignmentOp$13 = $EXPECT($L53, fail, 'AssignmentOp "|="');
1812
- var AssignmentOp$14 = $EXPECT($L54, fail, 'AssignmentOp "??="');
1813
- var AssignmentOp$15 = $EXPECT($L55, fail, 'AssignmentOp "="');
1825
+ var AssignmentOp$0 = $EXPECT($L41, fail, 'AssignmentOp "**="');
1826
+ var AssignmentOp$1 = $EXPECT($L42, fail, 'AssignmentOp "*="');
1827
+ var AssignmentOp$2 = $EXPECT($L43, fail, 'AssignmentOp "/="');
1828
+ var AssignmentOp$3 = $EXPECT($L44, fail, 'AssignmentOp "%="');
1829
+ var AssignmentOp$4 = $EXPECT($L45, fail, 'AssignmentOp "+="');
1830
+ var AssignmentOp$5 = $EXPECT($L46, fail, 'AssignmentOp "-="');
1831
+ var AssignmentOp$6 = $EXPECT($L47, fail, 'AssignmentOp "<<="');
1832
+ var AssignmentOp$7 = $EXPECT($L48, fail, 'AssignmentOp ">>>="');
1833
+ var AssignmentOp$8 = $EXPECT($L49, fail, 'AssignmentOp ">>="');
1834
+ var AssignmentOp$9 = $EXPECT($L50, fail, 'AssignmentOp "&&="');
1835
+ var AssignmentOp$10 = $EXPECT($L51, fail, 'AssignmentOp "&="');
1836
+ var AssignmentOp$11 = $EXPECT($L52, fail, 'AssignmentOp "^="');
1837
+ var AssignmentOp$12 = $EXPECT($L53, fail, 'AssignmentOp "||="');
1838
+ var AssignmentOp$13 = $EXPECT($L54, fail, 'AssignmentOp "|="');
1839
+ var AssignmentOp$14 = $EXPECT($L55, fail, 'AssignmentOp "??="');
1840
+ var AssignmentOp$15 = $EXPECT($L56, fail, 'AssignmentOp "="');
1814
1841
  function AssignmentOp(state) {
1815
1842
  if (state.tokenize) {
1816
1843
  return $TOKEN("AssignmentOp", state, AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state));
@@ -1818,48 +1845,48 @@ var require_parser = __commonJS({
1818
1845
  return AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state);
1819
1846
  }
1820
1847
  }
1821
- var BinaryOp$0 = $EXPECT($L56, fail, 'BinaryOp "**"');
1848
+ var BinaryOp$0 = $EXPECT($L57, fail, 'BinaryOp "**"');
1822
1849
  var BinaryOp$1 = $EXPECT($L9, fail, 'BinaryOp "*"');
1823
- var BinaryOp$2 = $EXPECT($L57, fail, 'BinaryOp "/"');
1824
- var BinaryOp$3 = $EXPECT($L58, fail, 'BinaryOp "%"');
1825
- var BinaryOp$4 = $EXPECT($L59, fail, 'BinaryOp "+"');
1826
- var BinaryOp$5 = $EXPECT($L60, fail, 'BinaryOp "-"');
1827
- var BinaryOp$6 = $EXPECT($L61, fail, 'BinaryOp "<="');
1828
- var BinaryOp$7 = $EXPECT($L62, fail, 'BinaryOp ">="');
1829
- var BinaryOp$8 = $EXPECT($L63, fail, 'BinaryOp "<<"');
1850
+ var BinaryOp$2 = $EXPECT($L58, fail, 'BinaryOp "/"');
1851
+ var BinaryOp$3 = $EXPECT($L59, fail, 'BinaryOp "%"');
1852
+ var BinaryOp$4 = $EXPECT($L60, fail, 'BinaryOp "+"');
1853
+ var BinaryOp$5 = $EXPECT($L61, fail, 'BinaryOp "-"');
1854
+ var BinaryOp$6 = $EXPECT($L62, fail, 'BinaryOp "<="');
1855
+ var BinaryOp$7 = $EXPECT($L63, fail, 'BinaryOp ">="');
1856
+ var BinaryOp$8 = $EXPECT($L64, fail, 'BinaryOp "<<"');
1830
1857
  var BinaryOp$9 = $EXPECT($L14, fail, 'BinaryOp "<"');
1831
- var BinaryOp$10 = $EXPECT($L64, fail, 'BinaryOp ">>>"');
1832
- var BinaryOp$11 = $EXPECT($L65, fail, 'BinaryOp ">>"');
1833
- var BinaryOp$12 = $EXPECT($L66, fail, 'BinaryOp ">"');
1834
- var BinaryOp$13 = $EXPECT($L67, fail, 'BinaryOp "!=="');
1835
- var BinaryOp$14 = $TV($EXPECT($L68, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1858
+ var BinaryOp$10 = $EXPECT($L65, fail, 'BinaryOp ">>>"');
1859
+ var BinaryOp$11 = $EXPECT($L66, fail, 'BinaryOp ">>"');
1860
+ var BinaryOp$12 = $EXPECT($L67, fail, 'BinaryOp ">"');
1861
+ var BinaryOp$13 = $EXPECT($L68, fail, 'BinaryOp "!=="');
1862
+ var BinaryOp$14 = $TV($EXPECT($L69, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
1836
1863
  if (global.coffeeCompat)
1837
1864
  return "!==";
1838
1865
  return $1;
1839
1866
  });
1840
- var BinaryOp$15 = $T($S($EXPECT($L69, fail, 'BinaryOp "is"'), NonIdContinue), function(value) {
1867
+ var BinaryOp$15 = $T($S($EXPECT($L70, fail, 'BinaryOp "is"'), NonIdContinue), function(value) {
1841
1868
  return "===";
1842
1869
  });
1843
- var BinaryOp$16 = $EXPECT($L70, fail, 'BinaryOp "==="');
1844
- var BinaryOp$17 = $TV($EXPECT($L71, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1870
+ var BinaryOp$16 = $EXPECT($L71, fail, 'BinaryOp "==="');
1871
+ var BinaryOp$17 = $TV($EXPECT($L72, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
1845
1872
  if (global.coffeeCompat)
1846
1873
  return "===";
1847
1874
  return $1;
1848
1875
  });
1849
- var BinaryOp$18 = $T($S($EXPECT($L72, fail, 'BinaryOp "and"'), NonIdContinue), function(value) {
1876
+ var BinaryOp$18 = $T($S($EXPECT($L73, fail, 'BinaryOp "and"'), NonIdContinue), function(value) {
1850
1877
  return "&&";
1851
1878
  });
1852
- var BinaryOp$19 = $EXPECT($L73, fail, 'BinaryOp "&&"');
1853
- var BinaryOp$20 = $T($S($EXPECT($L74, fail, 'BinaryOp "or"'), NonIdContinue), function(value) {
1879
+ var BinaryOp$19 = $EXPECT($L74, fail, 'BinaryOp "&&"');
1880
+ var BinaryOp$20 = $T($S($EXPECT($L75, fail, 'BinaryOp "or"'), NonIdContinue), function(value) {
1854
1881
  return "||";
1855
1882
  });
1856
- var BinaryOp$21 = $EXPECT($L75, fail, 'BinaryOp "||"');
1857
- var BinaryOp$22 = $EXPECT($L76, fail, 'BinaryOp "??"');
1858
- var BinaryOp$23 = $S($EXPECT($L77, fail, 'BinaryOp "instanceof"'), NonIdContinue);
1859
- var BinaryOp$24 = $S($EXPECT($L78, fail, 'BinaryOp "in"'), NonIdContinue);
1860
- var BinaryOp$25 = $EXPECT($L79, fail, 'BinaryOp "&"');
1861
- var BinaryOp$26 = $EXPECT($L80, fail, 'BinaryOp "^"');
1862
- var BinaryOp$27 = $EXPECT($L81, fail, 'BinaryOp "|"');
1883
+ var BinaryOp$21 = $EXPECT($L76, fail, 'BinaryOp "||"');
1884
+ var BinaryOp$22 = $EXPECT($L77, fail, 'BinaryOp "??"');
1885
+ var BinaryOp$23 = $S($EXPECT($L78, fail, 'BinaryOp "instanceof"'), NonIdContinue);
1886
+ var BinaryOp$24 = $S($EXPECT($L79, fail, 'BinaryOp "in"'), NonIdContinue);
1887
+ var BinaryOp$25 = $EXPECT($L80, fail, 'BinaryOp "&"');
1888
+ var BinaryOp$26 = $EXPECT($L81, fail, 'BinaryOp "^"');
1889
+ var BinaryOp$27 = $EXPECT($L82, fail, 'BinaryOp "|"');
1863
1890
  function BinaryOp(state) {
1864
1891
  if (state.tokenize) {
1865
1892
  return $TOKEN("BinaryOp", state, BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state));
@@ -1868,7 +1895,7 @@ var require_parser = __commonJS({
1868
1895
  }
1869
1896
  }
1870
1897
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
1871
- var UnaryOp$1 = $S($C($EXPECT($L82, fail, 'UnaryOp "delete"'), $EXPECT($L83, fail, 'UnaryOp "void"'), $EXPECT($L84, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
1898
+ var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
1872
1899
  function UnaryOp(state) {
1873
1900
  if (state.tokenize) {
1874
1901
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -1902,7 +1929,7 @@ var require_parser = __commonJS({
1902
1929
  return StatementListItem$0(state);
1903
1930
  }
1904
1931
  }
1905
- var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L85, fail, 'PostfixConditional "if"'), $EXPECT($L86, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
1932
+ var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L86, fail, 'PostfixConditional "if"'), $EXPECT($L87, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
1906
1933
  var ws = $1;
1907
1934
  var cond = $2;
1908
1935
  var exp = $4;
@@ -1935,7 +1962,7 @@ var require_parser = __commonJS({
1935
1962
  return Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
1936
1963
  }
1937
1964
  }
1938
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
1965
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
1939
1966
  function EmptyStatement(state) {
1940
1967
  if (state.verbose)
1941
1968
  console.log("ENTER:", "EmptyStatement");
@@ -1955,8 +1982,8 @@ var require_parser = __commonJS({
1955
1982
  return BlockStatement$0(state);
1956
1983
  }
1957
1984
  }
1958
- var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L88, fail, 'IfStatement "else"'), Block)));
1959
- var IfStatement$1 = $TS($S($EXPECT($L86, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
1985
+ var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
1986
+ var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
1960
1987
  var condition = $2;
1961
1988
  var block = $3;
1962
1989
  return ["if", condition.map((c) => {
@@ -1986,7 +2013,7 @@ var require_parser = __commonJS({
1986
2013
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
1987
2014
  }
1988
2015
  }
1989
- var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2016
+ var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
1990
2017
  var b = $3;
1991
2018
  return ["while(true)", b];
1992
2019
  });
@@ -1999,7 +2026,7 @@ var require_parser = __commonJS({
1999
2026
  return LoopStatement$0(state);
2000
2027
  }
2001
2028
  }
2002
- var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
2029
+ var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2003
2030
  function DoWhileStatement(state) {
2004
2031
  if (state.verbose)
2005
2032
  console.log("ENTER:", "DoWhileStatement");
@@ -2009,7 +2036,7 @@ var require_parser = __commonJS({
2009
2036
  return DoWhileStatement$0(state);
2010
2037
  }
2011
2038
  }
2012
- var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), NonIdContinue, Condition, Block);
2039
+ var WhileStatement$0 = $S(WhileClause, Block);
2013
2040
  function WhileStatement(state) {
2014
2041
  if (state.verbose)
2015
2042
  console.log("ENTER:", "WhileStatement");
@@ -2019,7 +2046,26 @@ var require_parser = __commonJS({
2019
2046
  return WhileStatement$0(state);
2020
2047
  }
2021
2048
  }
2022
- var ForStatement$0 = $S($EXPECT($L92, fail, 'ForStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2049
+ var WhileClause$0 = $TS($S($C($EXPECT($L92, fail, 'WhileClause "while"'), $EXPECT($L93, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2050
+ var kind = $1;
2051
+ var cond = $3;
2052
+ if (kind === "until") {
2053
+ cond[1] = "(!(";
2054
+ cond[5] = "))";
2055
+ return ["while", cond];
2056
+ }
2057
+ return $0;
2058
+ });
2059
+ function WhileClause(state) {
2060
+ if (state.verbose)
2061
+ console.log("ENTER:", "WhileClause");
2062
+ if (state.tokenize) {
2063
+ return $TOKEN("WhileClause", state, WhileClause$0(state));
2064
+ } else {
2065
+ return WhileClause$0(state);
2066
+ }
2067
+ }
2068
+ var ForStatement$0 = $S($EXPECT($L94, fail, 'ForStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L88, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2023
2069
  function ForStatement(state) {
2024
2070
  if (state.verbose)
2025
2071
  console.log("ENTER:", "ForStatement");
@@ -2029,10 +2075,10 @@ var require_parser = __commonJS({
2029
2075
  return ForStatement$0(state);
2030
2076
  }
2031
2077
  }
2032
- var ForInOfStatement$0 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2033
- var ForInOfStatement$1 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2034
- var ForInOfStatement$2 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2035
- var ForInOfStatement$3 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2078
+ var ForInOfStatement$0 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2079
+ var ForInOfStatement$1 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2080
+ var ForInOfStatement$2 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L96, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2081
+ var ForInOfStatement$3 = $S($EXPECT($L94, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L96, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2036
2082
  function ForInOfStatement(state) {
2037
2083
  if (state.tokenize) {
2038
2084
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2040,7 +2086,7 @@ var require_parser = __commonJS({
2040
2086
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2041
2087
  }
2042
2088
  }
2043
- var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), NonIdContinue, __, ForBinding);
2089
+ var ForDeclaration$0 = $S($C($EXPECT($L98, fail, 'ForDeclaration "let"'), $EXPECT($L99, fail, 'ForDeclaration "const"')), NonIdContinue, __, ForBinding);
2044
2090
  function ForDeclaration(state) {
2045
2091
  if (state.verbose)
2046
2092
  console.log("ENTER:", "ForDeclaration");
@@ -2059,7 +2105,7 @@ var require_parser = __commonJS({
2059
2105
  return ForBinding$0(state) || ForBinding$1(state);
2060
2106
  }
2061
2107
  }
2062
- var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2108
+ var SwitchStatement$0 = $S($EXPECT($L100, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2063
2109
  function SwitchStatement(state) {
2064
2110
  if (state.verbose)
2065
2111
  console.log("ENTER:", "SwitchStatement");
@@ -2103,9 +2149,9 @@ var require_parser = __commonJS({
2103
2149
  return NestedCaseClause$0(state);
2104
2150
  }
2105
2151
  }
2106
- var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2152
+ var CaseClause$0 = $S($EXPECT($L101, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2107
2153
  var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2108
- var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2154
+ var CaseClause$2 = $S($EXPECT($L102, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2109
2155
  function CaseClause(state) {
2110
2156
  if (state.tokenize) {
2111
2157
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2113,7 +2159,7 @@ var require_parser = __commonJS({
2113
2159
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2114
2160
  }
2115
2161
  }
2116
- var When$0 = $T($S($EXPECT($L101, fail, 'When "when"'), NonIdContinue), function(value) {
2162
+ var When$0 = $T($S($EXPECT($L103, fail, 'When "when"'), NonIdContinue), function(value) {
2117
2163
  return "case";
2118
2164
  });
2119
2165
  function When(state) {
@@ -2126,7 +2172,7 @@ var require_parser = __commonJS({
2126
2172
  }
2127
2173
  }
2128
2174
  var ImpliedColon$0 = $S(__, $EXPECT($L12, fail, 'ImpliedColon ":"'));
2129
- var ImpliedColon$1 = $T($EXPECT($L30, fail, 'ImpliedColon ""'), function(value) {
2175
+ var ImpliedColon$1 = $T($EXPECT($L31, fail, 'ImpliedColon ""'), function(value) {
2130
2176
  return ":";
2131
2177
  });
2132
2178
  function ImpliedColon(state) {
@@ -2136,7 +2182,7 @@ var require_parser = __commonJS({
2136
2182
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2137
2183
  }
2138
2184
  }
2139
- var TryStatement$0 = $TS($S($EXPECT($L102, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2185
+ var TryStatement$0 = $TS($S($EXPECT($L104, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2140
2186
  var c = $3;
2141
2187
  var f = $4;
2142
2188
  if (!c && !f) {
@@ -2153,7 +2199,7 @@ var require_parser = __commonJS({
2153
2199
  return TryStatement$0(state);
2154
2200
  }
2155
2201
  }
2156
- var Catch$0 = $S(__, $EXPECT($L103, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2202
+ var Catch$0 = $S(__, $EXPECT($L105, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2157
2203
  function Catch(state) {
2158
2204
  if (state.verbose)
2159
2205
  console.log("ENTER:", "Catch");
@@ -2172,7 +2218,7 @@ var require_parser = __commonJS({
2172
2218
  return CatchBind$0(state) || CatchBind$1(state);
2173
2219
  }
2174
2220
  }
2175
- var Finally$0 = $S(__, $EXPECT($L104, fail, 'Finally "finally"'), BracedBlock);
2221
+ var Finally$0 = $S(__, $EXPECT($L106, fail, 'Finally "finally"'), BracedBlock);
2176
2222
  function Finally(state) {
2177
2223
  if (state.verbose)
2178
2224
  console.log("ENTER:", "Finally");
@@ -2210,20 +2256,39 @@ var require_parser = __commonJS({
2210
2256
  return ExpressionStatement$0(state);
2211
2257
  }
2212
2258
  }
2213
- var KeywordStatement$0 = $S($EXPECT($L105, fail, 'KeywordStatement "break"'), NonIdContinue);
2214
- var KeywordStatement$1 = $S($EXPECT($L106, fail, 'KeywordStatement "continue"'), NonIdContinue);
2215
- var KeywordStatement$2 = $S($EXPECT($L107, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2216
- var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), NonIdContinue, Expression);
2217
- var KeywordStatement$4 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), NonIdContinue);
2218
- var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2259
+ var KeywordStatement$0 = $S($EXPECT($L107, fail, 'KeywordStatement "break"'), NonIdContinue);
2260
+ var KeywordStatement$1 = $S($EXPECT($L108, fail, 'KeywordStatement "continue"'), NonIdContinue);
2261
+ var KeywordStatement$2 = $S($EXPECT($L109, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2262
+ var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
2263
+ var KeywordStatement$4 = $S($EXPECT($L110, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2219
2264
  function KeywordStatement(state) {
2220
2265
  if (state.tokenize) {
2221
- return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state));
2266
+ return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
2267
+ } else {
2268
+ return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state);
2269
+ }
2270
+ }
2271
+ var MaybeNestedExpression$0 = $S($N(EOS), $Q(TrailingComment), Expression);
2272
+ var MaybeNestedExpression$1 = $S($Y(EOS), SingleNestedExpression);
2273
+ var MaybeNestedExpression$2 = $S($Y(EOS), ObjectLiteral);
2274
+ function MaybeNestedExpression(state) {
2275
+ if (state.tokenize) {
2276
+ return $TOKEN("MaybeNestedExpression", state, MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state) || MaybeNestedExpression$2(state));
2277
+ } else {
2278
+ return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state) || MaybeNestedExpression$2(state);
2279
+ }
2280
+ }
2281
+ var Return$0 = $S($EXPECT($L111, fail, 'Return "return"'), NonIdContinue);
2282
+ function Return(state) {
2283
+ if (state.verbose)
2284
+ console.log("ENTER:", "Return");
2285
+ if (state.tokenize) {
2286
+ return $TOKEN("Return", state, Return$0(state));
2222
2287
  } else {
2223
- return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
2288
+ return Return$0(state);
2224
2289
  }
2225
2290
  }
2226
- var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2291
+ var ImportDeclaration$0 = $T($S($EXPECT($L112, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2227
2292
  return { "ts": true, "children": value };
2228
2293
  });
2229
2294
  var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), NonIdContinue, __, ImportClause, __, FromClause);
@@ -2265,7 +2330,7 @@ var require_parser = __commonJS({
2265
2330
  return NamedImports$0(state);
2266
2331
  }
2267
2332
  }
2268
- var FromClause$0 = $S($EXPECT($L111, fail, 'FromClause "from"'), NonIdContinue, __, ModuleSpecifier);
2333
+ var FromClause$0 = $S($EXPECT($L113, fail, 'FromClause "from"'), NonIdContinue, __, ModuleSpecifier);
2269
2334
  function FromClause(state) {
2270
2335
  if (state.verbose)
2271
2336
  console.log("ENTER:", "FromClause");
@@ -2313,7 +2378,7 @@ var require_parser = __commonJS({
2313
2378
  return ImportedBinding$0(state);
2314
2379
  }
2315
2380
  }
2316
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2381
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L102, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2317
2382
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2318
2383
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2319
2384
  function ExportDeclaration(state) {
@@ -2333,7 +2398,7 @@ var require_parser = __commonJS({
2333
2398
  return As$0(state);
2334
2399
  }
2335
2400
  }
2336
- var Export$0 = $S($EXPECT($L112, fail, 'Export "export"'), NonIdContinue);
2401
+ var Export$0 = $S($EXPECT($L114, fail, 'Export "export"'), NonIdContinue);
2337
2402
  function Export(state) {
2338
2403
  if (state.verbose)
2339
2404
  console.log("ENTER:", "Export");
@@ -2393,8 +2458,8 @@ var require_parser = __commonJS({
2393
2458
  return HoistableDeclaration$0(state);
2394
2459
  }
2395
2460
  }
2396
- var LexicalDeclaration$0 = $S($C($EXPECT($L96, fail, 'LexicalDeclaration "let"'), $EXPECT($L97, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2397
- var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L113, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
2461
+ var LexicalDeclaration$0 = $S($C($EXPECT($L98, fail, 'LexicalDeclaration "let"'), $EXPECT($L99, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
2462
+ var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L115, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
2398
2463
  var bind = value[0];
2399
2464
  var suffix = value[1];
2400
2465
  var ws = value[2];
@@ -2417,7 +2482,7 @@ var require_parser = __commonJS({
2417
2482
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2418
2483
  }
2419
2484
  }
2420
- var Initializer$0 = $S(__, $EXPECT($L55, fail, 'Initializer "="'), AssignmentExpression);
2485
+ var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
2421
2486
  function Initializer(state) {
2422
2487
  if (state.verbose)
2423
2488
  console.log("ENTER:", "Initializer");
@@ -2427,7 +2492,7 @@ var require_parser = __commonJS({
2427
2492
  return Initializer$0(state);
2428
2493
  }
2429
2494
  }
2430
- var VariableStatement$0 = $S($EXPECT($L93, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2495
+ var VariableStatement$0 = $S($EXPECT($L95, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2431
2496
  function VariableStatement(state) {
2432
2497
  if (state.verbose)
2433
2498
  console.log("ENTER:", "VariableStatement");
@@ -2518,11 +2583,11 @@ var require_parser = __commonJS({
2518
2583
  return HexLiteral$0(state);
2519
2584
  }
2520
2585
  }
2521
- var StringLiteral$0 = $T($S($EXPECT($L114, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L114, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function(value) {
2586
+ var StringLiteral$0 = $T($S($EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function(value) {
2522
2587
  return ["`", value[1], "`"];
2523
2588
  });
2524
- var StringLiteral$1 = $S($EXPECT($L115, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\""'));
2525
- var StringLiteral$2 = $S($EXPECT($L116, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "\\\\'"`));
2589
+ var StringLiteral$1 = $S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'));
2590
+ var StringLiteral$2 = $S($EXPECT($L118, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "\\\\'"`));
2526
2591
  function StringLiteral(state) {
2527
2592
  if (state.tokenize) {
2528
2593
  return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
@@ -2558,7 +2623,7 @@ var require_parser = __commonJS({
2558
2623
  return TripleDoubleStringCharacter$0(state);
2559
2624
  }
2560
2625
  }
2561
- var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R11, fail, "EscapeSequence /./")));
2626
+ var EscapeSequence$0 = $TEXT($S($EXPECT($L119, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R11, fail, "EscapeSequence /./")));
2562
2627
  function EscapeSequence(state) {
2563
2628
  if (state.verbose)
2564
2629
  console.log("ENTER:", "EscapeSequence");
@@ -2568,7 +2633,7 @@ var require_parser = __commonJS({
2568
2633
  return EscapeSequence$0(state);
2569
2634
  }
2570
2635
  }
2571
- var RegularExpressionLiteral$0 = $S($EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L57, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2636
+ var RegularExpressionLiteral$0 = $S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
2572
2637
  function RegularExpressionLiteral(state) {
2573
2638
  if (state.verbose)
2574
2639
  console.log("ENTER:", "RegularExpressionLiteral");
@@ -2607,7 +2672,7 @@ var require_parser = __commonJS({
2607
2672
  return RegularExpressionFlags$0(state);
2608
2673
  }
2609
2674
  }
2610
- var TemplateLiteral$0 = $S($EXPECT($L118, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L118, fail, 'TemplateLiteral "`"'));
2675
+ var TemplateLiteral$0 = $S($EXPECT($L120, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L120, fail, 'TemplateLiteral "`"'));
2611
2676
  function TemplateLiteral(state) {
2612
2677
  if (state.verbose)
2613
2678
  console.log("ENTER:", "TemplateLiteral");
@@ -2617,7 +2682,7 @@ var require_parser = __commonJS({
2617
2682
  return TemplateLiteral$0(state);
2618
2683
  }
2619
2684
  }
2620
- var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2685
+ var TemplateSubstitution$0 = $S($EXPECT($L121, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L16, fail, 'TemplateSubstitution "}"'));
2621
2686
  function TemplateSubstitution(state) {
2622
2687
  if (state.verbose)
2623
2688
  console.log("ENTER:", "TemplateSubstitution");
@@ -2674,7 +2739,7 @@ var require_parser = __commonJS({
2674
2739
  return MultiLineComment$0(state) || MultiLineComment$1(state);
2675
2740
  }
2676
2741
  }
2677
- var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R11, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
2742
+ var JSMultiLineComment$0 = $S($EXPECT($L122, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'JSMultiLineComment "*/"')), $EXPECT($R11, fail, "JSMultiLineComment /./")))), $EXPECT($L123, fail, 'JSMultiLineComment "*/"'));
2678
2743
  function JSMultiLineComment(state) {
2679
2744
  if (state.verbose)
2680
2745
  console.log("ENTER:", "JSMultiLineComment");
@@ -2698,7 +2763,7 @@ var require_parser = __commonJS({
2698
2763
  return CoffeeSingleLineComment$0(state);
2699
2764
  }
2700
2765
  }
2701
- var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R11, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), function(value) {
2766
+ var CoffeeMultiLineComment$0 = $T($S($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R11, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), function(value) {
2702
2767
  return ["/*", value[1], "*/"];
2703
2768
  });
2704
2769
  function CoffeeMultiLineComment(state) {
@@ -2710,7 +2775,7 @@ var require_parser = __commonJS({
2710
2775
  return CoffeeMultiLineComment$0(state);
2711
2776
  }
2712
2777
  }
2713
- var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($R19, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L121, fail, 'InlineComment "*/"'));
2778
+ var InlineComment$0 = $S($EXPECT($L122, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'InlineComment "*/"')), $EXPECT($R19, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L123, fail, 'InlineComment "*/"'));
2714
2779
  function InlineComment(state) {
2715
2780
  if (state.verbose)
2716
2781
  console.log("ENTER:", "InlineComment");
@@ -2760,7 +2825,7 @@ var require_parser = __commonJS({
2760
2825
  return __$0(state);
2761
2826
  }
2762
2827
  }
2763
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2828
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
2764
2829
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
2765
2830
  return [";", value];
2766
2831
  });
@@ -2795,7 +2860,7 @@ var require_parser = __commonJS({
2795
2860
  return JSXElement$0(state) || JSXElement$1(state);
2796
2861
  }
2797
2862
  }
2798
- var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
2863
+ var JSXSelfClosingElement$0 = $S($EXPECT($L14, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L125, fail, 'JSXSelfClosingElement "/>"'));
2799
2864
  function JSXSelfClosingElement(state) {
2800
2865
  if (state.verbose)
2801
2866
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -2805,7 +2870,7 @@ var require_parser = __commonJS({
2805
2870
  return JSXSelfClosingElement$0(state);
2806
2871
  }
2807
2872
  }
2808
- var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L66, fail, 'JSXOpeningElement ">"'));
2873
+ var JSXOpeningElement$0 = $S($EXPECT($L14, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
2809
2874
  function JSXOpeningElement(state) {
2810
2875
  if (state.verbose)
2811
2876
  console.log("ENTER:", "JSXOpeningElement");
@@ -2815,7 +2880,7 @@ var require_parser = __commonJS({
2815
2880
  return JSXOpeningElement$0(state);
2816
2881
  }
2817
2882
  }
2818
- var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L66, fail, 'JSXClosingElement ">"'));
2883
+ var JSXClosingElement$0 = $S($EXPECT($L126, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
2819
2884
  function JSXClosingElement(state) {
2820
2885
  if (state.verbose)
2821
2886
  console.log("ENTER:", "JSXClosingElement");
@@ -2825,7 +2890,7 @@ var require_parser = __commonJS({
2825
2890
  return JSXClosingElement$0(state);
2826
2891
  }
2827
2892
  }
2828
- var JSXFragment$0 = $S($EXPECT($L125, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L126, fail, 'JSXFragment "</>"'));
2893
+ var JSXFragment$0 = $S($EXPECT($L127, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L128, fail, 'JSXFragment "</>"'));
2829
2894
  function JSXFragment(state) {
2830
2895
  if (state.verbose)
2831
2896
  console.log("ENTER:", "JSXFragment");
@@ -2865,7 +2930,7 @@ var require_parser = __commonJS({
2865
2930
  return JSXAttributes$0(state);
2866
2931
  }
2867
2932
  }
2868
- var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L31, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
2933
+ var JSXAttribute$0 = $S($EXPECT($L11, fail, 'JSXAttribute "{"'), __, $EXPECT($L32, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L16, fail, 'JSXAttribute "}"'));
2869
2934
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
2870
2935
  function JSXAttribute(state) {
2871
2936
  if (state.tokenize) {
@@ -2884,7 +2949,7 @@ var require_parser = __commonJS({
2884
2949
  return JSXAttributeName$0(state);
2885
2950
  }
2886
2951
  }
2887
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L55, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2952
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
2888
2953
  function JSXAttributeInitializer(state) {
2889
2954
  if (state.verbose)
2890
2955
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -2937,7 +3002,7 @@ var require_parser = __commonJS({
2937
3002
  return JSXText$0(state);
2938
3003
  }
2939
3004
  }
2940
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L31, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3005
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L32, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
2941
3006
  function JSXChildExpression(state) {
2942
3007
  if (state.verbose)
2943
3008
  console.log("ENTER:", "JSXChildExpression");
@@ -2947,7 +3012,7 @@ var require_parser = __commonJS({
2947
3012
  return JSXChildExpression$0(state);
2948
3013
  }
2949
3014
  }
2950
- var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L55, fail, 'TypeDeclaration "="'), __, Type), function(value) {
3015
+ var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclaration "="'), __, Type), function(value) {
2951
3016
  return { "ts": true, "children": value };
2952
3017
  });
2953
3018
  var TypeDeclaration$1 = $T($S($EXPECT($R28, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
@@ -3005,7 +3070,7 @@ var require_parser = __commonJS({
3005
3070
  return InterfaceProperty$0(state);
3006
3071
  }
3007
3072
  }
3008
- var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
3073
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
3009
3074
  var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
3010
3075
  var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3011
3076
  return ";";
@@ -3020,7 +3085,7 @@ var require_parser = __commonJS({
3020
3085
  return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
3021
3086
  }
3022
3087
  }
3023
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L127, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L24, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L25, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3088
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R29, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L129, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L24, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L25, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3024
3089
  function TypeIndexSignature(state) {
3025
3090
  if (state.verbose)
3026
3091
  console.log("ENTER:", "TypeIndexSignature");
@@ -3031,7 +3096,7 @@ var require_parser = __commonJS({
3031
3096
  }
3032
3097
  }
3033
3098
  var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
3034
- var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L78, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3099
+ var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3035
3100
  function TypeIndex(state) {
3036
3101
  if (state.tokenize) {
3037
3102
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3051,7 +3116,7 @@ var require_parser = __commonJS({
3051
3116
  return TypeSuffix$0(state);
3052
3117
  }
3053
3118
  }
3054
- var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L128, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3119
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L12, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L130, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3055
3120
  return { "ts": true, "children": value };
3056
3121
  });
3057
3122
  function ReturnTypeSuffix(state) {
@@ -3063,7 +3128,7 @@ var require_parser = __commonJS({
3063
3128
  return ReturnTypeSuffix$0(state);
3064
3129
  }
3065
3130
  }
3066
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L69, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3131
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3067
3132
  function TypePredicate(state) {
3068
3133
  if (state.verbose)
3069
3134
  console.log("ENTER:", "TypePredicate");
@@ -3113,9 +3178,9 @@ var require_parser = __commonJS({
3113
3178
  return TypeUnarySuffix$0(state);
3114
3179
  }
3115
3180
  }
3116
- var TypeUnaryOp$0 = $EXPECT($L129, fail, 'TypeUnaryOp "keyof"');
3117
- var TypeUnaryOp$1 = $EXPECT($L84, fail, 'TypeUnaryOp "typeof"');
3118
- var TypeUnaryOp$2 = $EXPECT($L130, fail, 'TypeUnaryOp "infer"');
3181
+ var TypeUnaryOp$0 = $EXPECT($L131, fail, 'TypeUnaryOp "keyof"');
3182
+ var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
3183
+ var TypeUnaryOp$2 = $EXPECT($L132, fail, 'TypeUnaryOp "infer"');
3119
3184
  function TypeUnaryOp(state) {
3120
3185
  if (state.tokenize) {
3121
3186
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -3156,8 +3221,8 @@ var require_parser = __commonJS({
3156
3221
  }
3157
3222
  }
3158
3223
  var TypeLiteral$0 = Literal;
3159
- var TypeLiteral$1 = $EXPECT($L83, fail, 'TypeLiteral "void"');
3160
- var TypeLiteral$2 = $EXPECT($L131, fail, 'TypeLiteral "[]"');
3224
+ var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
3225
+ var TypeLiteral$2 = $EXPECT($L133, fail, 'TypeLiteral "[]"');
3161
3226
  function TypeLiteral(state) {
3162
3227
  if (state.tokenize) {
3163
3228
  return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -3165,8 +3230,8 @@ var require_parser = __commonJS({
3165
3230
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3166
3231
  }
3167
3232
  }
3168
- var TypeBinaryOp$0 = $EXPECT($L81, fail, 'TypeBinaryOp "|"');
3169
- var TypeBinaryOp$1 = $EXPECT($L79, fail, 'TypeBinaryOp "&"');
3233
+ var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
3234
+ var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
3170
3235
  function TypeBinaryOp(state) {
3171
3236
  if (state.tokenize) {
3172
3237
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3184,7 +3249,7 @@ var require_parser = __commonJS({
3184
3249
  return FunctionType$0(state);
3185
3250
  }
3186
3251
  }
3187
- var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L66, fail, 'TypeArguments ">"'));
3252
+ var TypeArguments$0 = $S(__, $EXPECT($L14, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
3188
3253
  function TypeArguments(state) {
3189
3254
  if (state.verbose)
3190
3255
  console.log("ENTER:", "TypeArguments");
@@ -3194,7 +3259,7 @@ var require_parser = __commonJS({
3194
3259
  return TypeArguments$0(state);
3195
3260
  }
3196
3261
  }
3197
- var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L66, fail, 'TypeParameters ">"'));
3262
+ var TypeParameters$0 = $S(__, $EXPECT($L14, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"'));
3198
3263
  function TypeParameters(state) {
3199
3264
  if (state.verbose)
3200
3265
  console.log("ENTER:", "TypeParameters");
@@ -3225,8 +3290,8 @@ var require_parser = __commonJS({
3225
3290
  }
3226
3291
  }
3227
3292
  var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3228
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L66, fail, 'TypeParameterDelimiter ">"')));
3229
- var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L66, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3293
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
3294
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3230
3295
  return ",";
3231
3296
  });
3232
3297
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3291,7 +3356,7 @@ var require_parser = __commonJS({
3291
3356
  return EOF$0(state);
3292
3357
  }
3293
3358
  }
3294
- var InsertOpenParen$0 = $T($EXPECT($L30, fail, 'InsertOpenParen ""'), function(value) {
3359
+ var InsertOpenParen$0 = $T($EXPECT($L31, fail, 'InsertOpenParen ""'), function(value) {
3295
3360
  return "(";
3296
3361
  });
3297
3362
  function InsertOpenParen(state) {
@@ -3303,7 +3368,7 @@ var require_parser = __commonJS({
3303
3368
  return InsertOpenParen$0(state);
3304
3369
  }
3305
3370
  }
3306
- var InsertCloseParen$0 = $T($EXPECT($L30, fail, 'InsertCloseParen ""'), function(value) {
3371
+ var InsertCloseParen$0 = $T($EXPECT($L31, fail, 'InsertCloseParen ""'), function(value) {
3307
3372
  return ")";
3308
3373
  });
3309
3374
  function InsertCloseParen(state) {
@@ -3315,7 +3380,7 @@ var require_parser = __commonJS({
3315
3380
  return InsertCloseParen$0(state);
3316
3381
  }
3317
3382
  }
3318
- var InsertOpenBrace$0 = $T($EXPECT($L30, fail, 'InsertOpenBrace ""'), function(value) {
3383
+ var InsertOpenBrace$0 = $T($EXPECT($L31, fail, 'InsertOpenBrace ""'), function(value) {
3319
3384
  return " {";
3320
3385
  });
3321
3386
  function InsertOpenBrace(state) {
@@ -3327,7 +3392,7 @@ var require_parser = __commonJS({
3327
3392
  return InsertOpenBrace$0(state);
3328
3393
  }
3329
3394
  }
3330
- var InsertCloseBrace$0 = $T($EXPECT($L30, fail, 'InsertCloseBrace ""'), function(value) {
3395
+ var InsertCloseBrace$0 = $T($EXPECT($L31, fail, 'InsertCloseBrace ""'), function(value) {
3331
3396
  return "}";
3332
3397
  });
3333
3398
  function InsertCloseBrace(state) {
@@ -3339,7 +3404,7 @@ var require_parser = __commonJS({
3339
3404
  return InsertCloseBrace$0(state);
3340
3405
  }
3341
3406
  }
3342
- var InsertNewline$0 = $TV($EXPECT($L30, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3407
+ var InsertNewline$0 = $TV($EXPECT($L31, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3343
3408
  return "\n";
3344
3409
  });
3345
3410
  function InsertNewline(state) {
@@ -3351,7 +3416,7 @@ var require_parser = __commonJS({
3351
3416
  return InsertNewline$0(state);
3352
3417
  }
3353
3418
  }
3354
- var InsertIndent$0 = $TV($EXPECT($L30, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3419
+ var InsertIndent$0 = $TV($EXPECT($L31, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3355
3420
  return "".padStart(global.currentIndent * 2);
3356
3421
  });
3357
3422
  function InsertIndent(state) {
@@ -3363,7 +3428,7 @@ var require_parser = __commonJS({
3363
3428
  return InsertIndent$0(state);
3364
3429
  }
3365
3430
  }
3366
- var InsertSpace$0 = $T($EXPECT($L30, fail, 'InsertSpace ""'), function(value) {
3431
+ var InsertSpace$0 = $T($EXPECT($L31, fail, 'InsertSpace ""'), function(value) {
3367
3432
  return " ";
3368
3433
  });
3369
3434
  function InsertSpace(state) {
@@ -3375,7 +3440,7 @@ var require_parser = __commonJS({
3375
3440
  return InsertSpace$0(state);
3376
3441
  }
3377
3442
  }
3378
- var InsertDot$0 = $T($EXPECT($L30, fail, 'InsertDot ""'), function(value) {
3443
+ var InsertDot$0 = $T($EXPECT($L31, fail, 'InsertDot ""'), function(value) {
3379
3444
  return ".";
3380
3445
  });
3381
3446
  function InsertDot(state) {
@@ -3387,7 +3452,7 @@ var require_parser = __commonJS({
3387
3452
  return InsertDot$0(state);
3388
3453
  }
3389
3454
  }
3390
- var InsertBreak$0 = $T($EXPECT($L30, fail, 'InsertBreak ""'), function(value) {
3455
+ var InsertBreak$0 = $T($EXPECT($L31, fail, 'InsertBreak ""'), function(value) {
3391
3456
  return "break;";
3392
3457
  });
3393
3458
  function InsertBreak(state) {
@@ -3399,7 +3464,7 @@ var require_parser = __commonJS({
3399
3464
  return InsertBreak$0(state);
3400
3465
  }
3401
3466
  }
3402
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L30, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3467
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L31, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3403
3468
  var directives = $2;
3404
3469
  global.currentIndent = 0;
3405
3470
  global.indentLevels = [0];
@@ -3419,7 +3484,7 @@ var require_parser = __commonJS({
3419
3484
  return Init$0(state);
3420
3485
  }
3421
3486
  }
3422
- var Indent$0 = $TV($Q($C($EXPECT($L132, fail, 'Indent " "'), $EXPECT($L133, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3487
+ var Indent$0 = $TV($Q($C($EXPECT($L134, fail, 'Indent " "'), $EXPECT($L135, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3423
3488
  return $1.length;
3424
3489
  });
3425
3490
  function Indent(state) {
@@ -3431,7 +3496,7 @@ var require_parser = __commonJS({
3431
3496
  return Indent$0(state);
3432
3497
  }
3433
3498
  }
3434
- var PushIndent$0 = $TV($EXPECT($L30, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3499
+ var PushIndent$0 = $TV($EXPECT($L31, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3435
3500
  global.currentIndent++;
3436
3501
  if (global.verbose) {
3437
3502
  console.log("pushing indent", global.currentIndent);
@@ -3448,7 +3513,7 @@ var require_parser = __commonJS({
3448
3513
  return PushIndent$0(state);
3449
3514
  }
3450
3515
  }
3451
- var PopIndent$0 = $TV($EXPECT($L30, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3516
+ var PopIndent$0 = $TV($EXPECT($L31, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3452
3517
  if (global.verbose) {
3453
3518
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3454
3519
  }
@@ -3537,7 +3602,9 @@ gen = require_generate();
3537
3602
  module.exports = {
3538
3603
  parse,
3539
3604
  compile: function(src, options) {
3540
- return gen(parse(src), options);
3605
+ return gen(parse(src, {
3606
+ filename: options != null ? options.filename : void 0
3607
+ }), options);
3541
3608
  },
3542
3609
  generate: gen
3543
3610
  };