@danielx/civet 0.3.7 → 0.3.9

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 (7) hide show
  1. package/README.md +2 -1
  2. package/dist/browser.js +293 -280
  3. package/dist/browser.js.map +2 -2
  4. package/dist/civet +6 -6
  5. package/dist/cli.js.map +3 -3
  6. package/dist/main.js +293 -280
  7. package/package.json +1 -1
package/dist/browser.js CHANGED
@@ -446,6 +446,7 @@ var Civet = (() => {
446
446
  CallExpression,
447
447
  CallExpressionRest,
448
448
  OptionalShorthand,
449
+ NonNullAssertion,
449
450
  SpacedApplication,
450
451
  ApplicationStart,
451
452
  AdditionalReservedWords,
@@ -708,119 +709,120 @@ var Civet = (() => {
708
709
  var $L23 = $L("super");
709
710
  var $L24 = $L("import");
710
711
  var $L25 = $L(".");
711
- var $L26 = $L("[");
712
- var $L27 = $L("]");
713
- var $L28 = $L("::");
714
- var $L29 = $L("super[");
715
- var $L30 = $L("new.target");
716
- var $L31 = $L("import.meta");
717
- var $L32 = $L("");
718
- var $L33 = $L("...");
719
- var $L34 = $L("function");
720
- var $L35 = $L("->");
721
- var $L36 = $L("null");
722
- var $L37 = $L("true");
723
- var $L38 = $L("false");
724
- var $L39 = $L("get");
725
- var $L40 = $L("set");
726
- var $L41 = $L("**=");
727
- var $L42 = $L("*=");
728
- var $L43 = $L("/=");
729
- var $L44 = $L("%=");
730
- var $L45 = $L("+=");
731
- var $L46 = $L("-=");
732
- var $L47 = $L("<<=");
733
- var $L48 = $L(">>>=");
734
- var $L49 = $L(">>=");
735
- var $L50 = $L("&&=");
736
- var $L51 = $L("&=");
737
- var $L52 = $L("^=");
738
- var $L53 = $L("||=");
739
- var $L54 = $L("|=");
740
- var $L55 = $L("??=");
741
- var $L56 = $L("=");
742
- var $L57 = $L("**");
743
- var $L58 = $L("/");
744
- var $L59 = $L("%");
745
- var $L60 = $L("+");
746
- var $L61 = $L("-");
747
- var $L62 = $L("<=");
748
- var $L63 = $L(">=");
749
- var $L64 = $L("<<");
750
- var $L65 = $L(">>>");
751
- var $L66 = $L(">>");
752
- var $L67 = $L(">");
753
- var $L68 = $L("!==");
754
- var $L69 = $L("!=");
755
- var $L70 = $L("is");
756
- var $L71 = $L("===");
757
- var $L72 = $L("==");
758
- var $L73 = $L("and");
759
- var $L74 = $L("&&");
760
- var $L75 = $L("or");
761
- var $L76 = $L("||");
762
- var $L77 = $L("??");
763
- var $L78 = $L("instanceof");
764
- var $L79 = $L("in");
765
- var $L80 = $L("&");
766
- var $L81 = $L("^");
767
- var $L82 = $L("|");
768
- var $L83 = $L("delete");
769
- var $L84 = $L("void");
770
- var $L85 = $L("typeof");
771
- var $L86 = $L("if");
772
- var $L87 = $L("unless");
773
- var $L88 = $L(";");
774
- var $L89 = $L("else");
775
- var $L90 = $L("loop");
776
- var $L91 = $L("do");
777
- var $L92 = $L("while");
778
- var $L93 = $L("until");
779
- var $L94 = $L("var");
780
- var $L95 = $L("of");
781
- var $L96 = $L("for");
782
- var $L97 = $L("let");
783
- var $L98 = $L("const");
784
- var $L99 = $L("switch");
785
- var $L100 = $L("case");
786
- var $L101 = $L("default");
787
- var $L102 = $L("when");
788
- var $L103 = $L("try");
789
- var $L104 = $L("catch");
790
- var $L105 = $L("finally");
791
- var $L106 = $L("break");
792
- var $L107 = $L("continue");
793
- var $L108 = $L("debugger");
794
- var $L109 = $L("throw");
795
- var $L110 = $L("return");
796
- var $L111 = $L("import type");
797
- var $L112 = $L("from");
798
- var $L113 = $L("export");
799
- var $L114 = $L(":=");
800
- var $L115 = $L('"""');
801
- var $L116 = $L("'''");
802
- var $L117 = $L('"');
803
- var $L118 = $L("'");
804
- var $L119 = $L("`");
805
- var $L120 = $L("${");
806
- var $L121 = $L("/*");
807
- var $L122 = $L("*/");
808
- var $L123 = $L("###");
809
- var $L124 = $L("/>");
810
- var $L125 = $L("</");
811
- var $L126 = $L("<>");
812
- var $L127 = $L("</>");
813
- var $L128 = $L("declare");
814
- var $L129 = $L("type");
815
- var $L130 = $L("interface");
816
- var $L131 = $L("namespace");
817
- var $L132 = $L("readonly");
818
- var $L133 = $L("asserts");
819
- var $L134 = $L("keyof");
820
- var $L135 = $L("infer");
821
- var $L136 = $L("[]");
822
- var $L137 = $L(" ");
823
- var $L138 = $L(" ");
712
+ var $L26 = $L("!");
713
+ var $L27 = $L("[");
714
+ var $L28 = $L("]");
715
+ var $L29 = $L("::");
716
+ var $L30 = $L("super[");
717
+ var $L31 = $L("new.target");
718
+ var $L32 = $L("import.meta");
719
+ var $L33 = $L("");
720
+ var $L34 = $L("...");
721
+ var $L35 = $L("function");
722
+ var $L36 = $L("->");
723
+ var $L37 = $L("null");
724
+ var $L38 = $L("true");
725
+ var $L39 = $L("false");
726
+ var $L40 = $L("get");
727
+ var $L41 = $L("set");
728
+ var $L42 = $L("**=");
729
+ var $L43 = $L("*=");
730
+ var $L44 = $L("/=");
731
+ var $L45 = $L("%=");
732
+ var $L46 = $L("+=");
733
+ var $L47 = $L("-=");
734
+ var $L48 = $L("<<=");
735
+ var $L49 = $L(">>>=");
736
+ var $L50 = $L(">>=");
737
+ var $L51 = $L("&&=");
738
+ var $L52 = $L("&=");
739
+ var $L53 = $L("^=");
740
+ var $L54 = $L("||=");
741
+ var $L55 = $L("|=");
742
+ var $L56 = $L("??=");
743
+ var $L57 = $L("=");
744
+ var $L58 = $L("**");
745
+ var $L59 = $L("/");
746
+ var $L60 = $L("%");
747
+ var $L61 = $L("+");
748
+ var $L62 = $L("-");
749
+ var $L63 = $L("<=");
750
+ var $L64 = $L(">=");
751
+ var $L65 = $L("<<");
752
+ var $L66 = $L(">>>");
753
+ var $L67 = $L(">>");
754
+ var $L68 = $L(">");
755
+ var $L69 = $L("!==");
756
+ var $L70 = $L("!=");
757
+ var $L71 = $L("is");
758
+ var $L72 = $L("===");
759
+ var $L73 = $L("==");
760
+ var $L74 = $L("and");
761
+ var $L75 = $L("&&");
762
+ var $L76 = $L("or");
763
+ var $L77 = $L("||");
764
+ var $L78 = $L("??");
765
+ var $L79 = $L("instanceof");
766
+ var $L80 = $L("in");
767
+ var $L81 = $L("&");
768
+ var $L82 = $L("^");
769
+ var $L83 = $L("|");
770
+ var $L84 = $L("delete");
771
+ var $L85 = $L("void");
772
+ var $L86 = $L("typeof");
773
+ var $L87 = $L("if");
774
+ var $L88 = $L("unless");
775
+ var $L89 = $L(";");
776
+ var $L90 = $L("else");
777
+ var $L91 = $L("loop");
778
+ var $L92 = $L("do");
779
+ var $L93 = $L("while");
780
+ var $L94 = $L("until");
781
+ var $L95 = $L("var");
782
+ var $L96 = $L("of");
783
+ var $L97 = $L("for");
784
+ var $L98 = $L("let");
785
+ var $L99 = $L("const");
786
+ var $L100 = $L("switch");
787
+ var $L101 = $L("case");
788
+ var $L102 = $L("default");
789
+ var $L103 = $L("when");
790
+ var $L104 = $L("try");
791
+ var $L105 = $L("catch");
792
+ var $L106 = $L("finally");
793
+ var $L107 = $L("break");
794
+ var $L108 = $L("continue");
795
+ var $L109 = $L("debugger");
796
+ var $L110 = $L("throw");
797
+ var $L111 = $L("return");
798
+ var $L112 = $L("import type");
799
+ var $L113 = $L("from");
800
+ var $L114 = $L("export");
801
+ var $L115 = $L(":=");
802
+ var $L116 = $L('"""');
803
+ var $L117 = $L("'''");
804
+ var $L118 = $L('"');
805
+ var $L119 = $L("'");
806
+ var $L120 = $L("`");
807
+ var $L121 = $L("${");
808
+ var $L122 = $L("/*");
809
+ var $L123 = $L("*/");
810
+ var $L124 = $L("###");
811
+ var $L125 = $L("/>");
812
+ var $L126 = $L("</");
813
+ var $L127 = $L("<>");
814
+ var $L128 = $L("</>");
815
+ var $L129 = $L("declare");
816
+ var $L130 = $L("type");
817
+ var $L131 = $L("interface");
818
+ var $L132 = $L("namespace");
819
+ var $L133 = $L("readonly");
820
+ var $L134 = $L("asserts");
821
+ var $L135 = $L("keyof");
822
+ var $L136 = $L("infer");
823
+ var $L137 = $L("[]");
824
+ var $L138 = $L(" ");
825
+ var $L139 = $L(" ");
824
826
  var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
825
827
  var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
826
828
  var $R2 = $R(new RegExp("[!~+-]", "suy"));
@@ -1313,7 +1315,7 @@ var Civet = (() => {
1313
1315
  return CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
1314
1316
  }
1315
1317
  }
1316
- var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
1318
+ var CallExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), Arguments);
1317
1319
  var CallExpressionRest$1 = MemberExpressionRest;
1318
1320
  var CallExpressionRest$2 = SpacedApplication;
1319
1321
  var CallExpressionRest$3 = TemplateLiteral;
@@ -1334,6 +1336,18 @@ var Civet = (() => {
1334
1336
  return OptionalShorthand$0(state);
1335
1337
  }
1336
1338
  }
1339
+ var NonNullAssertion$0 = $T($EXPECT($L26, fail, 'NonNullAssertion "!"'), function(value) {
1340
+ return { "ts": true, "children": value };
1341
+ });
1342
+ function NonNullAssertion(state) {
1343
+ if (state.verbose)
1344
+ console.log("ENTER:", "NonNullAssertion");
1345
+ if (state.tokenize) {
1346
+ return $TOKEN("NonNullAssertion", state, NonNullAssertion$0(state));
1347
+ } else {
1348
+ return NonNullAssertion$0(state);
1349
+ }
1350
+ }
1337
1351
  var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
1338
1352
  function SpacedApplication(state) {
1339
1353
  if (state.verbose)
@@ -1378,22 +1392,23 @@ var Civet = (() => {
1378
1392
  return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
1379
1393
  }
1380
1394
  }
1381
- var MemberExpressionRest$0 = $S($E(OptionalShorthand), $EXPECT($L26, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L27, fail, 'MemberExpressionRest "]"'));
1395
+ var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), $EXPECT($L27, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L28, fail, 'MemberExpressionRest "]"'));
1382
1396
  var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
1383
- var MemberExpressionRest$2 = $TS($S($EXPECT($L28, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1397
+ var MemberExpressionRest$2 = $TS($S($EXPECT($L29, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
1384
1398
  var id = $2;
1385
1399
  if (id)
1386
1400
  return [".prototype.", id];
1387
1401
  return ".prototype";
1388
1402
  });
1403
+ var MemberExpressionRest$3 = NonNullAssertion;
1389
1404
  function MemberExpressionRest(state) {
1390
1405
  if (state.tokenize) {
1391
- return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state));
1406
+ return $TOKEN("MemberExpressionRest", state, MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state));
1392
1407
  } else {
1393
- return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state);
1408
+ return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
1394
1409
  }
1395
1410
  }
1396
- var PropertyAccess$0 = $S($E($EXPECT($L3, fail, 'PropertyAccess "?"')), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1411
+ var PropertyAccess$0 = $S($E($C($EXPECT($L3, fail, 'PropertyAccess "?"'), NonNullAssertion)), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
1397
1412
  function PropertyAccess(state) {
1398
1413
  if (state.verbose)
1399
1414
  console.log("ENTER:", "PropertyAccess");
@@ -1403,7 +1418,7 @@ var Civet = (() => {
1403
1418
  return PropertyAccess$0(state);
1404
1419
  }
1405
1420
  }
1406
- var SuperProperty$0 = $S($EXPECT($L29, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L27, fail, 'SuperProperty "]"'));
1421
+ var SuperProperty$0 = $S($EXPECT($L30, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L28, fail, 'SuperProperty "]"'));
1407
1422
  function SuperProperty(state) {
1408
1423
  if (state.verbose)
1409
1424
  console.log("ENTER:", "SuperProperty");
@@ -1413,8 +1428,8 @@ var Civet = (() => {
1413
1428
  return SuperProperty$0(state);
1414
1429
  }
1415
1430
  }
1416
- var MetaProperty$0 = $EXPECT($L30, fail, 'MetaProperty "new.target"');
1417
- var MetaProperty$1 = $EXPECT($L31, fail, 'MetaProperty "import.meta"');
1431
+ var MetaProperty$0 = $EXPECT($L31, fail, 'MetaProperty "new.target"');
1432
+ var MetaProperty$1 = $EXPECT($L32, fail, 'MetaProperty "import.meta"');
1418
1433
  function MetaProperty(state) {
1419
1434
  if (state.tokenize) {
1420
1435
  return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1423,7 +1438,7 @@ var Civet = (() => {
1423
1438
  }
1424
1439
  }
1425
1440
  var Parameters$0 = $S($E(TypeParameters), $EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
1426
- var Parameters$1 = $T($EXPECT($L32, fail, 'Parameters ""'), function(value) {
1441
+ var Parameters$1 = $T($EXPECT($L33, fail, 'Parameters ""'), function(value) {
1427
1442
  return "()";
1428
1443
  });
1429
1444
  function Parameters(state) {
@@ -1487,7 +1502,7 @@ var Civet = (() => {
1487
1502
  return ObjectBindingPattern$0(state);
1488
1503
  }
1489
1504
  }
1490
- var ArrayBindingPattern$0 = $S($EXPECT($L26, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L27, fail, 'ArrayBindingPattern "]"'));
1505
+ var ArrayBindingPattern$0 = $S($EXPECT($L27, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L28, fail, 'ArrayBindingPattern "]"'));
1491
1506
  function ArrayBindingPattern(state) {
1492
1507
  if (state.verbose)
1493
1508
  console.log("ENTER:", "ArrayBindingPattern");
@@ -1506,7 +1521,7 @@ var Civet = (() => {
1506
1521
  return BindingProperty$0(state) || BindingProperty$1(state);
1507
1522
  }
1508
1523
  }
1509
- var BindingRestProperty$0 = $S($EXPECT($L33, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1524
+ var BindingRestProperty$0 = $S($EXPECT($L34, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
1510
1525
  function BindingRestProperty(state) {
1511
1526
  if (state.verbose)
1512
1527
  console.log("ENTER:", "BindingRestProperty");
@@ -1526,7 +1541,7 @@ var Civet = (() => {
1526
1541
  return BindingElement$0(state);
1527
1542
  }
1528
1543
  }
1529
- var BindingRestElement$0 = $S($EXPECT($L33, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1544
+ var BindingRestElement$0 = $S($EXPECT($L34, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
1530
1545
  function BindingRestElement(state) {
1531
1546
  if (state.verbose)
1532
1547
  console.log("ENTER:", "BindingRestElement");
@@ -1547,7 +1562,7 @@ var Civet = (() => {
1547
1562
  }
1548
1563
  }
1549
1564
  var FunctionExpression$0 = ThinArrowFunction;
1550
- var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L34, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1565
+ var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L35, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
1551
1566
  function FunctionExpression(state) {
1552
1567
  if (state.tokenize) {
1553
1568
  return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1576,7 +1591,7 @@ var Civet = (() => {
1576
1591
  return ThinArrowFunction$0(state);
1577
1592
  }
1578
1593
  }
1579
- var Arrow$0 = $TV($EXPECT($L35, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1594
+ var Arrow$0 = $TV($EXPECT($L36, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
1580
1595
  return { $loc, token: $1 };
1581
1596
  });
1582
1597
  function Arrow(state) {
@@ -1669,7 +1684,7 @@ var Civet = (() => {
1669
1684
  return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
1670
1685
  }
1671
1686
  }
1672
- var NullLiteral$0 = $TV($EXPECT($L36, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1687
+ var NullLiteral$0 = $TV($EXPECT($L37, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
1673
1688
  return { $loc, token: $1 };
1674
1689
  });
1675
1690
  function NullLiteral(state) {
@@ -1681,7 +1696,7 @@ var Civet = (() => {
1681
1696
  return NullLiteral$0(state);
1682
1697
  }
1683
1698
  }
1684
- var BooleanLiteral$0 = $TV($C($EXPECT($L37, fail, 'BooleanLiteral "true"'), $EXPECT($L38, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1699
+ var BooleanLiteral$0 = $TV($C($EXPECT($L38, fail, 'BooleanLiteral "true"'), $EXPECT($L39, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
1685
1700
  return { $loc, token: $1 };
1686
1701
  });
1687
1702
  function BooleanLiteral(state) {
@@ -1738,8 +1753,8 @@ var Civet = (() => {
1738
1753
  return IdentifierReference$0(state);
1739
1754
  }
1740
1755
  }
1741
- var ArrayLiteral$0 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1742
- var ArrayLiteral$1 = $S($EXPECT($L26, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L27, fail, 'ArrayLiteral "]"'));
1756
+ var ArrayLiteral$0 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
1757
+ var ArrayLiteral$1 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
1743
1758
  function ArrayLiteral(state) {
1744
1759
  if (state.tokenize) {
1745
1760
  return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1773,8 +1788,8 @@ var Civet = (() => {
1773
1788
  }
1774
1789
  }
1775
1790
  var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
1776
- var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L27, fail, 'ArrayElementDelimiter "]"')));
1777
- var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L27, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1791
+ var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L28, fail, 'ArrayElementDelimiter "]"')));
1792
+ var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L28, fail, 'ArrayElementDelimiter "]"'))), function(value) {
1778
1793
  return ",";
1779
1794
  });
1780
1795
  var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
@@ -1807,7 +1822,7 @@ var Civet = (() => {
1807
1822
  return InlineElementList$0(state);
1808
1823
  }
1809
1824
  }
1810
- var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L33, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1825
+ var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L34, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
1811
1826
  function ArrayElementExpression(state) {
1812
1827
  if (state.verbose)
1813
1828
  console.log("ENTER:", "ArrayElementExpression");
@@ -1890,7 +1905,7 @@ var Civet = (() => {
1890
1905
  }
1891
1906
  var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L14, fail, 'PropertyDefinition ":"'), AssignmentExpression);
1892
1907
  var PropertyDefinition$1 = MethodDefinition;
1893
- var PropertyDefinition$2 = $S($EXPECT($L33, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1908
+ var PropertyDefinition$2 = $S($EXPECT($L34, fail, 'PropertyDefinition "..."'), AssignmentExpression);
1894
1909
  var PropertyDefinition$3 = IdentifierReference;
1895
1910
  function PropertyDefinition(state) {
1896
1911
  if (state.tokenize) {
@@ -1902,7 +1917,7 @@ var Civet = (() => {
1902
1917
  var PropertyName$0 = NumericLiteral;
1903
1918
  var PropertyName$1 = StringLiteral;
1904
1919
  var PropertyName$2 = IdentifierName;
1905
- var PropertyName$3 = $S($EXPECT($L26, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L27, fail, 'PropertyName "]"'));
1920
+ var PropertyName$3 = $S($EXPECT($L27, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L28, fail, 'PropertyName "]"'));
1906
1921
  function PropertyName(state) {
1907
1922
  if (state.tokenize) {
1908
1923
  return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1910,8 +1925,8 @@ var Civet = (() => {
1910
1925
  return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
1911
1926
  }
1912
1927
  }
1913
- var MethodDefinition$0 = $S($EXPECT($L39, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1914
- var MethodDefinition$1 = $S($EXPECT($L40, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1928
+ var MethodDefinition$0 = $S($EXPECT($L40, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1929
+ var MethodDefinition$1 = $S($EXPECT($L41, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
1915
1930
  var MethodDefinition$2 = AsyncGeneratorMethod;
1916
1931
  var MethodDefinition$3 = AsyncMethod;
1917
1932
  var MethodDefinition$4 = GeneratorMethod;
@@ -1923,7 +1938,7 @@ var Civet = (() => {
1923
1938
  return MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state);
1924
1939
  }
1925
1940
  }
1926
- var MethodModifier$0 = $S($C($EXPECT($L39, fail, 'MethodModifier "get"'), $EXPECT($L40, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
1941
+ var MethodModifier$0 = $S($C($EXPECT($L40, fail, 'MethodModifier "get"'), $EXPECT($L41, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
1927
1942
  function MethodModifier(state) {
1928
1943
  if (state.verbose)
1929
1944
  console.log("ENTER:", "MethodModifier");
@@ -2034,22 +2049,22 @@ var Civet = (() => {
2034
2049
  return AssignmentOp$0(state);
2035
2050
  }
2036
2051
  }
2037
- var AssignmentOpSymbol$0 = $EXPECT($L41, fail, 'AssignmentOpSymbol "**="');
2038
- var AssignmentOpSymbol$1 = $EXPECT($L42, fail, 'AssignmentOpSymbol "*="');
2039
- var AssignmentOpSymbol$2 = $EXPECT($L43, fail, 'AssignmentOpSymbol "/="');
2040
- var AssignmentOpSymbol$3 = $EXPECT($L44, fail, 'AssignmentOpSymbol "%="');
2041
- var AssignmentOpSymbol$4 = $EXPECT($L45, fail, 'AssignmentOpSymbol "+="');
2042
- var AssignmentOpSymbol$5 = $EXPECT($L46, fail, 'AssignmentOpSymbol "-="');
2043
- var AssignmentOpSymbol$6 = $EXPECT($L47, fail, 'AssignmentOpSymbol "<<="');
2044
- var AssignmentOpSymbol$7 = $EXPECT($L48, fail, 'AssignmentOpSymbol ">>>="');
2045
- var AssignmentOpSymbol$8 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>="');
2046
- var AssignmentOpSymbol$9 = $EXPECT($L50, fail, 'AssignmentOpSymbol "&&="');
2047
- var AssignmentOpSymbol$10 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&="');
2048
- var AssignmentOpSymbol$11 = $EXPECT($L52, fail, 'AssignmentOpSymbol "^="');
2049
- var AssignmentOpSymbol$12 = $EXPECT($L53, fail, 'AssignmentOpSymbol "||="');
2050
- var AssignmentOpSymbol$13 = $EXPECT($L54, fail, 'AssignmentOpSymbol "|="');
2051
- var AssignmentOpSymbol$14 = $EXPECT($L55, fail, 'AssignmentOpSymbol "??="');
2052
- var AssignmentOpSymbol$15 = $EXPECT($L56, fail, 'AssignmentOpSymbol "="');
2052
+ var AssignmentOpSymbol$0 = $EXPECT($L42, fail, 'AssignmentOpSymbol "**="');
2053
+ var AssignmentOpSymbol$1 = $EXPECT($L43, fail, 'AssignmentOpSymbol "*="');
2054
+ var AssignmentOpSymbol$2 = $EXPECT($L44, fail, 'AssignmentOpSymbol "/="');
2055
+ var AssignmentOpSymbol$3 = $EXPECT($L45, fail, 'AssignmentOpSymbol "%="');
2056
+ var AssignmentOpSymbol$4 = $EXPECT($L46, fail, 'AssignmentOpSymbol "+="');
2057
+ var AssignmentOpSymbol$5 = $EXPECT($L47, fail, 'AssignmentOpSymbol "-="');
2058
+ var AssignmentOpSymbol$6 = $EXPECT($L48, fail, 'AssignmentOpSymbol "<<="');
2059
+ var AssignmentOpSymbol$7 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>>="');
2060
+ var AssignmentOpSymbol$8 = $EXPECT($L50, fail, 'AssignmentOpSymbol ">>="');
2061
+ var AssignmentOpSymbol$9 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&&="');
2062
+ var AssignmentOpSymbol$10 = $EXPECT($L52, fail, 'AssignmentOpSymbol "&="');
2063
+ var AssignmentOpSymbol$11 = $EXPECT($L53, fail, 'AssignmentOpSymbol "^="');
2064
+ var AssignmentOpSymbol$12 = $EXPECT($L54, fail, 'AssignmentOpSymbol "||="');
2065
+ var AssignmentOpSymbol$13 = $EXPECT($L55, fail, 'AssignmentOpSymbol "|="');
2066
+ var AssignmentOpSymbol$14 = $EXPECT($L56, fail, 'AssignmentOpSymbol "??="');
2067
+ var AssignmentOpSymbol$15 = $EXPECT($L57, fail, 'AssignmentOpSymbol "="');
2053
2068
  function AssignmentOpSymbol(state) {
2054
2069
  if (state.tokenize) {
2055
2070
  return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state));
@@ -2069,48 +2084,48 @@ var Civet = (() => {
2069
2084
  return BinaryOp$0(state);
2070
2085
  }
2071
2086
  }
2072
- var BinaryOpSymbol$0 = $EXPECT($L57, fail, 'BinaryOpSymbol "**"');
2087
+ var BinaryOpSymbol$0 = $EXPECT($L58, fail, 'BinaryOpSymbol "**"');
2073
2088
  var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
2074
- var BinaryOpSymbol$2 = $EXPECT($L58, fail, 'BinaryOpSymbol "/"');
2075
- var BinaryOpSymbol$3 = $EXPECT($L59, fail, 'BinaryOpSymbol "%"');
2076
- var BinaryOpSymbol$4 = $EXPECT($L60, fail, 'BinaryOpSymbol "+"');
2077
- var BinaryOpSymbol$5 = $EXPECT($L61, fail, 'BinaryOpSymbol "-"');
2078
- var BinaryOpSymbol$6 = $EXPECT($L62, fail, 'BinaryOpSymbol "<="');
2079
- var BinaryOpSymbol$7 = $EXPECT($L63, fail, 'BinaryOpSymbol ">="');
2080
- var BinaryOpSymbol$8 = $EXPECT($L64, fail, 'BinaryOpSymbol "<<"');
2089
+ var BinaryOpSymbol$2 = $EXPECT($L59, fail, 'BinaryOpSymbol "/"');
2090
+ var BinaryOpSymbol$3 = $EXPECT($L60, fail, 'BinaryOpSymbol "%"');
2091
+ var BinaryOpSymbol$4 = $EXPECT($L61, fail, 'BinaryOpSymbol "+"');
2092
+ var BinaryOpSymbol$5 = $EXPECT($L62, fail, 'BinaryOpSymbol "-"');
2093
+ var BinaryOpSymbol$6 = $EXPECT($L63, fail, 'BinaryOpSymbol "<="');
2094
+ var BinaryOpSymbol$7 = $EXPECT($L64, fail, 'BinaryOpSymbol ">="');
2095
+ var BinaryOpSymbol$8 = $EXPECT($L65, fail, 'BinaryOpSymbol "<<"');
2081
2096
  var BinaryOpSymbol$9 = $EXPECT($L16, fail, 'BinaryOpSymbol "<"');
2082
- var BinaryOpSymbol$10 = $EXPECT($L65, fail, 'BinaryOpSymbol ">>>"');
2083
- var BinaryOpSymbol$11 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>"');
2084
- var BinaryOpSymbol$12 = $EXPECT($L67, fail, 'BinaryOpSymbol ">"');
2085
- var BinaryOpSymbol$13 = $EXPECT($L68, fail, 'BinaryOpSymbol "!=="');
2086
- var BinaryOpSymbol$14 = $TV($EXPECT($L69, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2087
- if (global.coffeeCompat)
2097
+ var BinaryOpSymbol$10 = $EXPECT($L66, fail, 'BinaryOpSymbol ">>>"');
2098
+ var BinaryOpSymbol$11 = $EXPECT($L67, fail, 'BinaryOpSymbol ">>"');
2099
+ var BinaryOpSymbol$12 = $EXPECT($L68, fail, 'BinaryOpSymbol ">"');
2100
+ var BinaryOpSymbol$13 = $EXPECT($L69, fail, 'BinaryOpSymbol "!=="');
2101
+ var BinaryOpSymbol$14 = $TV($EXPECT($L70, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
2102
+ if (module.coffeeCompat)
2088
2103
  return "!==";
2089
2104
  return $1;
2090
2105
  });
2091
- var BinaryOpSymbol$15 = $T($S($EXPECT($L70, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2106
+ var BinaryOpSymbol$15 = $T($S($EXPECT($L71, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
2092
2107
  return "===";
2093
2108
  });
2094
- var BinaryOpSymbol$16 = $EXPECT($L71, fail, 'BinaryOpSymbol "==="');
2095
- var BinaryOpSymbol$17 = $TV($EXPECT($L72, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2096
- if (global.coffeeCompat)
2109
+ var BinaryOpSymbol$16 = $EXPECT($L72, fail, 'BinaryOpSymbol "==="');
2110
+ var BinaryOpSymbol$17 = $TV($EXPECT($L73, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
2111
+ if (module.coffeeCompat)
2097
2112
  return "===";
2098
2113
  return $1;
2099
2114
  });
2100
- var BinaryOpSymbol$18 = $T($S($EXPECT($L73, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2115
+ var BinaryOpSymbol$18 = $T($S($EXPECT($L74, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
2101
2116
  return "&&";
2102
2117
  });
2103
- var BinaryOpSymbol$19 = $EXPECT($L74, fail, 'BinaryOpSymbol "&&"');
2104
- var BinaryOpSymbol$20 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2118
+ var BinaryOpSymbol$19 = $EXPECT($L75, fail, 'BinaryOpSymbol "&&"');
2119
+ var BinaryOpSymbol$20 = $T($S($EXPECT($L76, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
2105
2120
  return "||";
2106
2121
  });
2107
- var BinaryOpSymbol$21 = $EXPECT($L76, fail, 'BinaryOpSymbol "||"');
2108
- var BinaryOpSymbol$22 = $EXPECT($L77, fail, 'BinaryOpSymbol "??"');
2109
- var BinaryOpSymbol$23 = $S($EXPECT($L78, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
2110
- var BinaryOpSymbol$24 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
2111
- var BinaryOpSymbol$25 = $EXPECT($L80, fail, 'BinaryOpSymbol "&"');
2112
- var BinaryOpSymbol$26 = $EXPECT($L81, fail, 'BinaryOpSymbol "^"');
2113
- var BinaryOpSymbol$27 = $EXPECT($L82, fail, 'BinaryOpSymbol "|"');
2122
+ var BinaryOpSymbol$21 = $EXPECT($L77, fail, 'BinaryOpSymbol "||"');
2123
+ var BinaryOpSymbol$22 = $EXPECT($L78, fail, 'BinaryOpSymbol "??"');
2124
+ var BinaryOpSymbol$23 = $S($EXPECT($L79, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue);
2125
+ var BinaryOpSymbol$24 = $S($EXPECT($L80, fail, 'BinaryOpSymbol "in"'), NonIdContinue);
2126
+ var BinaryOpSymbol$25 = $EXPECT($L81, fail, 'BinaryOpSymbol "&"');
2127
+ var BinaryOpSymbol$26 = $EXPECT($L82, fail, 'BinaryOpSymbol "^"');
2128
+ var BinaryOpSymbol$27 = $EXPECT($L83, fail, 'BinaryOpSymbol "|"');
2114
2129
  function BinaryOpSymbol(state) {
2115
2130
  if (state.tokenize) {
2116
2131
  return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state));
@@ -2119,7 +2134,7 @@ var Civet = (() => {
2119
2134
  }
2120
2135
  }
2121
2136
  var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
2122
- var UnaryOp$1 = $S($C($EXPECT($L83, fail, 'UnaryOp "delete"'), $EXPECT($L84, fail, 'UnaryOp "void"'), $EXPECT($L85, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2137
+ var UnaryOp$1 = $S($C($EXPECT($L84, fail, 'UnaryOp "delete"'), $EXPECT($L85, fail, 'UnaryOp "void"'), $EXPECT($L86, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
2123
2138
  function UnaryOp(state) {
2124
2139
  if (state.tokenize) {
2125
2140
  return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2153,7 +2168,7 @@ var Civet = (() => {
2153
2168
  return StatementListItem$0(state);
2154
2169
  }
2155
2170
  }
2156
- 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) {
2171
+ var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L87, fail, 'PostfixConditional "if"'), $EXPECT($L88, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
2157
2172
  var ws = $1;
2158
2173
  var cond = $2;
2159
2174
  var exp = $4;
@@ -2186,7 +2201,7 @@ var Civet = (() => {
2186
2201
  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);
2187
2202
  }
2188
2203
  }
2189
- var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L88, fail, 'EmptyStatement ";"')));
2204
+ var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L89, fail, 'EmptyStatement ";"')));
2190
2205
  function EmptyStatement(state) {
2191
2206
  if (state.verbose)
2192
2207
  console.log("ENTER:", "EmptyStatement");
@@ -2206,8 +2221,8 @@ var Civet = (() => {
2206
2221
  return BlockStatement$0(state);
2207
2222
  }
2208
2223
  }
2209
- var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L89, fail, 'IfStatement "else"'), Block)));
2210
- var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2224
+ var IfStatement$0 = $S($EXPECT($L87, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L90, fail, 'IfStatement "else"'), Block)));
2225
+ var IfStatement$1 = $TS($S($EXPECT($L88, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
2211
2226
  var condition = $2;
2212
2227
  var block = $3;
2213
2228
  return ["if", condition.map((c) => {
@@ -2237,7 +2252,7 @@ var Civet = (() => {
2237
2252
  return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
2238
2253
  }
2239
2254
  }
2240
- var LoopStatement$0 = $TS($S($EXPECT($L90, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2255
+ var LoopStatement$0 = $TS($S($EXPECT($L91, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
2241
2256
  var b = $3;
2242
2257
  return ["while(true)", b];
2243
2258
  });
@@ -2250,7 +2265,7 @@ var Civet = (() => {
2250
2265
  return LoopStatement$0(state);
2251
2266
  }
2252
2267
  }
2253
- var DoWhileStatement$0 = $S($EXPECT($L91, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2268
+ var DoWhileStatement$0 = $S($EXPECT($L92, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
2254
2269
  function DoWhileStatement(state) {
2255
2270
  if (state.verbose)
2256
2271
  console.log("ENTER:", "DoWhileStatement");
@@ -2270,7 +2285,7 @@ var Civet = (() => {
2270
2285
  return WhileStatement$0(state);
2271
2286
  }
2272
2287
  }
2273
- 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) {
2288
+ var WhileClause$0 = $TS($S($C($EXPECT($L93, fail, 'WhileClause "while"'), $EXPECT($L94, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
2274
2289
  var kind = $1;
2275
2290
  var cond = $3;
2276
2291
  if (kind === "until") {
@@ -2289,7 +2304,7 @@ var Civet = (() => {
2289
2304
  return WhileClause$0(state);
2290
2305
  }
2291
2306
  }
2292
- var ForStatement$0 = $S(For, __, $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);
2307
+ var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L89, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L89, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
2293
2308
  function ForStatement(state) {
2294
2309
  if (state.verbose)
2295
2310
  console.log("ENTER:", "ForStatement");
@@ -2299,10 +2314,10 @@ var Civet = (() => {
2299
2314
  return ForStatement$0(state);
2300
2315
  }
2301
2316
  }
2302
- var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2303
- var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L79, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2304
- var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2305
- var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L94, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2317
+ var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L80, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2318
+ var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L80, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
2319
+ var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L96, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
2320
+ var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L95, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L96, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
2306
2321
  function ForInOfStatement(state) {
2307
2322
  if (state.tokenize) {
2308
2323
  return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2310,7 +2325,7 @@ var Civet = (() => {
2310
2325
  return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
2311
2326
  }
2312
2327
  }
2313
- var For$0 = $TS($S($EXPECT($L96, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2328
+ var For$0 = $TS($S($EXPECT($L97, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2314
2329
  return { $loc, token: $1 };
2315
2330
  });
2316
2331
  function For(state) {
@@ -2332,7 +2347,7 @@ var Civet = (() => {
2332
2347
  return ForDeclaration$0(state);
2333
2348
  }
2334
2349
  }
2335
- var LetOrConst$0 = $TV($C($EXPECT($L97, fail, 'LetOrConst "let"'), $EXPECT($L98, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
2350
+ var LetOrConst$0 = $TV($C($EXPECT($L98, fail, 'LetOrConst "let"'), $EXPECT($L99, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
2336
2351
  return { $loc, token: $1 };
2337
2352
  });
2338
2353
  function LetOrConst(state) {
@@ -2353,7 +2368,7 @@ var Civet = (() => {
2353
2368
  return ForBinding$0(state) || ForBinding$1(state);
2354
2369
  }
2355
2370
  }
2356
- var SwitchStatement$0 = $S($EXPECT($L99, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2371
+ var SwitchStatement$0 = $S($EXPECT($L100, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
2357
2372
  function SwitchStatement(state) {
2358
2373
  if (state.verbose)
2359
2374
  console.log("ENTER:", "SwitchStatement");
@@ -2397,9 +2412,9 @@ var Civet = (() => {
2397
2412
  return NestedCaseClause$0(state);
2398
2413
  }
2399
2414
  }
2400
- var CaseClause$0 = $S($EXPECT($L100, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2415
+ var CaseClause$0 = $S($EXPECT($L101, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
2401
2416
  var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
2402
- var CaseClause$2 = $S($EXPECT($L101, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2417
+ var CaseClause$2 = $S($EXPECT($L102, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
2403
2418
  function CaseClause(state) {
2404
2419
  if (state.tokenize) {
2405
2420
  return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2407,7 +2422,7 @@ var Civet = (() => {
2407
2422
  return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
2408
2423
  }
2409
2424
  }
2410
- var When$0 = $T($S($EXPECT($L102, fail, 'When "when"'), NonIdContinue), function(value) {
2425
+ var When$0 = $T($S($EXPECT($L103, fail, 'When "when"'), NonIdContinue), function(value) {
2411
2426
  return "case";
2412
2427
  });
2413
2428
  function When(state) {
@@ -2420,7 +2435,7 @@ var Civet = (() => {
2420
2435
  }
2421
2436
  }
2422
2437
  var ImpliedColon$0 = $S(__, $EXPECT($L14, fail, 'ImpliedColon ":"'));
2423
- var ImpliedColon$1 = $T($EXPECT($L32, fail, 'ImpliedColon ""'), function(value) {
2438
+ var ImpliedColon$1 = $T($EXPECT($L33, fail, 'ImpliedColon ""'), function(value) {
2424
2439
  return ":";
2425
2440
  });
2426
2441
  function ImpliedColon(state) {
@@ -2430,7 +2445,7 @@ var Civet = (() => {
2430
2445
  return ImpliedColon$0(state) || ImpliedColon$1(state);
2431
2446
  }
2432
2447
  }
2433
- var TryStatement$0 = $TS($S($EXPECT($L103, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2448
+ var TryStatement$0 = $TS($S($EXPECT($L104, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
2434
2449
  var c = $3;
2435
2450
  var f = $4;
2436
2451
  if (!c && !f) {
@@ -2447,7 +2462,7 @@ var Civet = (() => {
2447
2462
  return TryStatement$0(state);
2448
2463
  }
2449
2464
  }
2450
- var Catch$0 = $S(__, $EXPECT($L104, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2465
+ var Catch$0 = $S(__, $EXPECT($L105, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
2451
2466
  function Catch(state) {
2452
2467
  if (state.verbose)
2453
2468
  console.log("ENTER:", "Catch");
@@ -2466,7 +2481,7 @@ var Civet = (() => {
2466
2481
  return CatchBind$0(state) || CatchBind$1(state);
2467
2482
  }
2468
2483
  }
2469
- var Finally$0 = $S(__, $EXPECT($L105, fail, 'Finally "finally"'), BracedBlock);
2484
+ var Finally$0 = $S(__, $EXPECT($L106, fail, 'Finally "finally"'), BracedBlock);
2470
2485
  function Finally(state) {
2471
2486
  if (state.verbose)
2472
2487
  console.log("ENTER:", "Finally");
@@ -2504,11 +2519,11 @@ var Civet = (() => {
2504
2519
  return ExpressionStatement$0(state);
2505
2520
  }
2506
2521
  }
2507
- var KeywordStatement$0 = $S($EXPECT($L106, fail, 'KeywordStatement "break"'), NonIdContinue);
2508
- var KeywordStatement$1 = $S($EXPECT($L107, fail, 'KeywordStatement "continue"'), NonIdContinue);
2509
- var KeywordStatement$2 = $S($EXPECT($L108, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2522
+ var KeywordStatement$0 = $S($EXPECT($L107, fail, 'KeywordStatement "break"'), NonIdContinue);
2523
+ var KeywordStatement$1 = $S($EXPECT($L108, fail, 'KeywordStatement "continue"'), NonIdContinue);
2524
+ var KeywordStatement$2 = $S($EXPECT($L109, fail, 'KeywordStatement "debugger"'), NonIdContinue);
2510
2525
  var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
2511
- var KeywordStatement$4 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2526
+ var KeywordStatement$4 = $S($EXPECT($L110, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
2512
2527
  function KeywordStatement(state) {
2513
2528
  if (state.tokenize) {
2514
2529
  return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
@@ -2525,7 +2540,7 @@ var Civet = (() => {
2525
2540
  return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
2526
2541
  }
2527
2542
  }
2528
- var Return$0 = $TS($S($EXPECT($L110, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2543
+ var Return$0 = $TS($S($EXPECT($L111, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2529
2544
  return { $loc, token: $1 };
2530
2545
  });
2531
2546
  function Return(state) {
@@ -2537,7 +2552,7 @@ var Civet = (() => {
2537
2552
  return Return$0(state);
2538
2553
  }
2539
2554
  }
2540
- var ImportDeclaration$0 = $T($S($EXPECT($L111, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2555
+ var ImportDeclaration$0 = $T($S($EXPECT($L112, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
2541
2556
  return { "ts": true, "children": value };
2542
2557
  });
2543
2558
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -2550,7 +2565,7 @@ var Civet = (() => {
2550
2565
  return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
2551
2566
  }
2552
2567
  }
2553
- var ImpliedImport$0 = $T($EXPECT($L32, fail, 'ImpliedImport ""'), function(value) {
2568
+ var ImpliedImport$0 = $T($EXPECT($L33, fail, 'ImpliedImport ""'), function(value) {
2554
2569
  return "import ";
2555
2570
  });
2556
2571
  function ImpliedImport(state) {
@@ -2614,7 +2629,7 @@ var Civet = (() => {
2614
2629
  return FromClause$0(state);
2615
2630
  }
2616
2631
  }
2617
- var From$0 = $TS($S($EXPECT($L112, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2632
+ var From$0 = $TS($S($EXPECT($L113, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
2618
2633
  return { $loc, token: $1 };
2619
2634
  });
2620
2635
  function From(state) {
@@ -2676,7 +2691,7 @@ var Civet = (() => {
2676
2691
  return ImportedBinding$0(state);
2677
2692
  }
2678
2693
  }
2679
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L101, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2694
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L102, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
2680
2695
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
2681
2696
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
2682
2697
  function ExportDeclaration(state) {
@@ -2696,7 +2711,7 @@ var Civet = (() => {
2696
2711
  return As$0(state);
2697
2712
  }
2698
2713
  }
2699
- var Export$0 = $S($EXPECT($L113, fail, 'Export "export"'), NonIdContinue);
2714
+ var Export$0 = $S($EXPECT($L114, fail, 'Export "export"'), NonIdContinue);
2700
2715
  function Export(state) {
2701
2716
  if (state.verbose)
2702
2717
  console.log("ENTER:", "Export");
@@ -2780,7 +2795,7 @@ var Civet = (() => {
2780
2795
  return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
2781
2796
  }
2782
2797
  }
2783
- var ConstAssignment$0 = $TV($EXPECT($L114, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2798
+ var ConstAssignment$0 = $TV($EXPECT($L115, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
2784
2799
  return { $loc, token: $0 };
2785
2800
  });
2786
2801
  function ConstAssignment(state) {
@@ -2801,7 +2816,7 @@ var Civet = (() => {
2801
2816
  return LexicalBinding$0(state) || LexicalBinding$1(state);
2802
2817
  }
2803
2818
  }
2804
- var Initializer$0 = $S(__, $EXPECT($L56, fail, 'Initializer "="'), AssignmentExpression);
2819
+ var Initializer$0 = $S(__, $EXPECT($L57, fail, 'Initializer "="'), AssignmentExpression);
2805
2820
  function Initializer(state) {
2806
2821
  if (state.verbose)
2807
2822
  console.log("ENTER:", "Initializer");
@@ -2811,7 +2826,7 @@ var Civet = (() => {
2811
2826
  return Initializer$0(state);
2812
2827
  }
2813
2828
  }
2814
- var VariableStatement$0 = $S($EXPECT($L94, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2829
+ var VariableStatement$0 = $S($EXPECT($L95, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
2815
2830
  function VariableStatement(state) {
2816
2831
  if (state.verbose)
2817
2832
  console.log("ENTER:", "VariableStatement");
@@ -2914,18 +2929,18 @@ var Civet = (() => {
2914
2929
  return HexLiteral$0(state);
2915
2930
  }
2916
2931
  }
2917
- var StringLiteral$0 = $TS($S($EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
2932
+ var StringLiteral$0 = $TS($S($EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L116, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
2918
2933
  var str = $2;
2919
2934
  return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
2920
2935
  });
2921
- var StringLiteral$1 = $TS($S($EXPECT($L116, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
2936
+ var StringLiteral$1 = $TS($S($EXPECT($L117, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L117, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
2922
2937
  var str = $2;
2923
2938
  return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
2924
2939
  });
2925
- var StringLiteral$2 = $TV($TEXT($S($EXPECT($L117, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L117, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2940
+ var StringLiteral$2 = $TV($TEXT($S($EXPECT($L118, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L118, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
2926
2941
  return { $loc, token: $1 };
2927
2942
  });
2928
- var StringLiteral$3 = $TV($TEXT($S($EXPECT($L118, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L118, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2943
+ var StringLiteral$3 = $TV($TEXT($S($EXPECT($L119, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L119, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
2929
2944
  return { $loc, token: $1 };
2930
2945
  });
2931
2946
  function StringLiteral(state) {
@@ -2975,7 +2990,7 @@ var Civet = (() => {
2975
2990
  return TripleSingleStringCharacter$0(state);
2976
2991
  }
2977
2992
  }
2978
- var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L58, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2993
+ var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L59, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L59, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
2979
2994
  return { $loc, token: $1 };
2980
2995
  });
2981
2996
  function RegularExpressionLiteral(state) {
@@ -3017,7 +3032,7 @@ var Civet = (() => {
3017
3032
  return RegularExpressionFlags$0(state);
3018
3033
  }
3019
3034
  }
3020
- var TemplateLiteral$0 = $S($EXPECT($L119, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L119, fail, 'TemplateLiteral "`"'));
3035
+ var TemplateLiteral$0 = $S($EXPECT($L120, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L120, fail, 'TemplateLiteral "`"'));
3021
3036
  function TemplateLiteral(state) {
3022
3037
  if (state.verbose)
3023
3038
  console.log("ENTER:", "TemplateLiteral");
@@ -3027,7 +3042,7 @@ var Civet = (() => {
3027
3042
  return TemplateLiteral$0(state);
3028
3043
  }
3029
3044
  }
3030
- var TemplateSubstitution$0 = $S($EXPECT($L120, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L13, fail, 'TemplateSubstitution "}"'));
3045
+ var TemplateSubstitution$0 = $S($EXPECT($L121, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L13, fail, 'TemplateSubstitution "}"'));
3031
3046
  function TemplateSubstitution(state) {
3032
3047
  if (state.verbose)
3033
3048
  console.log("ENTER:", "TemplateSubstitution");
@@ -3084,7 +3099,7 @@ var Civet = (() => {
3084
3099
  return MultiLineComment$0(state) || MultiLineComment$1(state);
3085
3100
  }
3086
3101
  }
3087
- var JSMultiLineComment$0 = $S($EXPECT($L121, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./")))), $EXPECT($L122, fail, 'JSMultiLineComment "*/"'));
3102
+ var JSMultiLineComment$0 = $S($EXPECT($L122, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./")))), $EXPECT($L123, fail, 'JSMultiLineComment "*/"'));
3088
3103
  function JSMultiLineComment(state) {
3089
3104
  if (state.verbose)
3090
3105
  console.log("ENTER:", "JSMultiLineComment");
@@ -3095,7 +3110,7 @@ var Civet = (() => {
3095
3110
  }
3096
3111
  }
3097
3112
  var CoffeeSingleLineComment$0 = $TR($EXPECT($R21, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
3098
- if (!global.coffeeCompat)
3113
+ if (!module.coffeeCompat)
3099
3114
  return $skip;
3100
3115
  return ["//", $1];
3101
3116
  });
@@ -3108,7 +3123,7 @@ var Civet = (() => {
3108
3123
  return CoffeeSingleLineComment$0(state);
3109
3124
  }
3110
3125
  }
3111
- var CoffeeMultiLineComment$0 = $T($S($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L123, fail, 'CoffeeMultiLineComment "###"')), function(value) {
3126
+ var CoffeeMultiLineComment$0 = $T($S($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L124, fail, 'CoffeeMultiLineComment "###"')), function(value) {
3112
3127
  return ["/*", value[1], "*/"];
3113
3128
  });
3114
3129
  function CoffeeMultiLineComment(state) {
@@ -3120,7 +3135,7 @@ var Civet = (() => {
3120
3135
  return CoffeeMultiLineComment$0(state);
3121
3136
  }
3122
3137
  }
3123
- var InlineComment$0 = $S($EXPECT($L121, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L122, fail, 'InlineComment "*/"'));
3138
+ var InlineComment$0 = $S($EXPECT($L122, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L123, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L123, fail, 'InlineComment "*/"'));
3124
3139
  function InlineComment(state) {
3125
3140
  if (state.verbose)
3126
3141
  console.log("ENTER:", "InlineComment");
@@ -3170,7 +3185,7 @@ var Civet = (() => {
3170
3185
  return __$0(state);
3171
3186
  }
3172
3187
  }
3173
- var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L88, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3188
+ var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L89, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
3174
3189
  var StatementDelimiter$1 = $T($Y(EOS), function(value) {
3175
3190
  return [";", value];
3176
3191
  });
@@ -3205,7 +3220,7 @@ var Civet = (() => {
3205
3220
  return JSXElement$0(state) || JSXElement$1(state);
3206
3221
  }
3207
3222
  }
3208
- var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L124, fail, 'JSXSelfClosingElement "/>"'));
3223
+ var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L125, fail, 'JSXSelfClosingElement "/>"'));
3209
3224
  function JSXSelfClosingElement(state) {
3210
3225
  if (state.verbose)
3211
3226
  console.log("ENTER:", "JSXSelfClosingElement");
@@ -3215,7 +3230,7 @@ var Civet = (() => {
3215
3230
  return JSXSelfClosingElement$0(state);
3216
3231
  }
3217
3232
  }
3218
- var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L67, fail, 'JSXOpeningElement ">"'));
3233
+ var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L68, fail, 'JSXOpeningElement ">"'));
3219
3234
  function JSXOpeningElement(state) {
3220
3235
  if (state.verbose)
3221
3236
  console.log("ENTER:", "JSXOpeningElement");
@@ -3225,7 +3240,7 @@ var Civet = (() => {
3225
3240
  return JSXOpeningElement$0(state);
3226
3241
  }
3227
3242
  }
3228
- var JSXClosingElement$0 = $S($EXPECT($L125, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L67, fail, 'JSXClosingElement ">"'));
3243
+ var JSXClosingElement$0 = $S($EXPECT($L126, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L68, fail, 'JSXClosingElement ">"'));
3229
3244
  function JSXClosingElement(state) {
3230
3245
  if (state.verbose)
3231
3246
  console.log("ENTER:", "JSXClosingElement");
@@ -3235,7 +3250,7 @@ var Civet = (() => {
3235
3250
  return JSXClosingElement$0(state);
3236
3251
  }
3237
3252
  }
3238
- var JSXFragment$0 = $S($EXPECT($L126, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L127, fail, 'JSXFragment "</>"'));
3253
+ var JSXFragment$0 = $S($EXPECT($L127, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L128, fail, 'JSXFragment "</>"'));
3239
3254
  function JSXFragment(state) {
3240
3255
  if (state.verbose)
3241
3256
  console.log("ENTER:", "JSXFragment");
@@ -3275,7 +3290,7 @@ var Civet = (() => {
3275
3290
  return JSXAttributes$0(state);
3276
3291
  }
3277
3292
  }
3278
- var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L33, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
3293
+ var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L34, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
3279
3294
  var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
3280
3295
  function JSXAttribute(state) {
3281
3296
  if (state.tokenize) {
@@ -3294,7 +3309,7 @@ var Civet = (() => {
3294
3309
  return JSXAttributeName$0(state);
3295
3310
  }
3296
3311
  }
3297
- var JSXAttributeInitializer$0 = $S(__, $EXPECT($L56, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3312
+ var JSXAttributeInitializer$0 = $S(__, $EXPECT($L57, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
3298
3313
  function JSXAttributeInitializer(state) {
3299
3314
  if (state.verbose)
3300
3315
  console.log("ENTER:", "JSXAttributeInitializer");
@@ -3347,7 +3362,7 @@ var Civet = (() => {
3347
3362
  return JSXText$0(state);
3348
3363
  }
3349
3364
  }
3350
- var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L33, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3365
+ var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L34, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
3351
3366
  function JSXChildExpression(state) {
3352
3367
  if (state.verbose)
3353
3368
  console.log("ENTER:", "JSXChildExpression");
@@ -3369,8 +3384,8 @@ var Civet = (() => {
3369
3384
  return TypeDeclaration$0(state);
3370
3385
  }
3371
3386
  }
3372
- var TypeDeclarationModifier$0 = $S($EXPECT($L128, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
3373
- var TypeDeclarationModifier$1 = $S($EXPECT($L113, fail, 'TypeDeclarationModifier "export"'), NonIdContinue);
3387
+ var TypeDeclarationModifier$0 = $S($EXPECT($L129, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
3388
+ var TypeDeclarationModifier$1 = $S($EXPECT($L114, fail, 'TypeDeclarationModifier "export"'), NonIdContinue);
3374
3389
  function TypeDeclarationModifier(state) {
3375
3390
  if (state.tokenize) {
3376
3391
  return $TOKEN("TypeDeclarationModifier", state, TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state));
@@ -3378,7 +3393,7 @@ var Civet = (() => {
3378
3393
  return TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state);
3379
3394
  }
3380
3395
  }
3381
- var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclarationRest "="'), __, Type);
3396
+ var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L57, fail, 'TypeDeclarationRest "="'), __, Type);
3382
3397
  var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
3383
3398
  var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
3384
3399
  function TypeDeclarationRest(state) {
@@ -3388,7 +3403,7 @@ var Civet = (() => {
3388
3403
  return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
3389
3404
  }
3390
3405
  }
3391
- var TypeKeyword$0 = $S($EXPECT($L129, fail, 'TypeKeyword "type"'), NonIdContinue);
3406
+ var TypeKeyword$0 = $S($EXPECT($L130, fail, 'TypeKeyword "type"'), NonIdContinue);
3392
3407
  function TypeKeyword(state) {
3393
3408
  if (state.verbose)
3394
3409
  console.log("ENTER:", "TypeKeyword");
@@ -3398,7 +3413,7 @@ var Civet = (() => {
3398
3413
  return TypeKeyword$0(state);
3399
3414
  }
3400
3415
  }
3401
- var Interface$0 = $S($EXPECT($L130, fail, 'Interface "interface"'), NonIdContinue);
3416
+ var Interface$0 = $S($EXPECT($L131, fail, 'Interface "interface"'), NonIdContinue);
3402
3417
  function Interface(state) {
3403
3418
  if (state.verbose)
3404
3419
  console.log("ENTER:", "Interface");
@@ -3408,7 +3423,7 @@ var Civet = (() => {
3408
3423
  return Interface$0(state);
3409
3424
  }
3410
3425
  }
3411
- var Namespace$0 = $S($EXPECT($L131, fail, 'Namespace "namespace"'), NonIdContinue);
3426
+ var Namespace$0 = $S($EXPECT($L132, fail, 'Namespace "namespace"'), NonIdContinue);
3412
3427
  function Namespace(state) {
3413
3428
  if (state.verbose)
3414
3429
  console.log("ENTER:", "Namespace");
@@ -3462,7 +3477,7 @@ var Civet = (() => {
3462
3477
  return InterfaceProperty$0(state) || InterfaceProperty$1(state);
3463
3478
  }
3464
3479
  }
3465
- var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
3480
+ var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L89, fail, 'InterfacePropertyDelimiter ";"'));
3466
3481
  var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"')));
3467
3482
  var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
3468
3483
  return ";";
@@ -3512,7 +3527,7 @@ var Civet = (() => {
3512
3527
  return NestedTypeDeclaration$0(state);
3513
3528
  }
3514
3529
  }
3515
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L132, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L26, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L27, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3530
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L133, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L27, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L28, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
3516
3531
  function TypeIndexSignature(state) {
3517
3532
  if (state.verbose)
3518
3533
  console.log("ENTER:", "TypeIndexSignature");
@@ -3523,7 +3538,7 @@ var Civet = (() => {
3523
3538
  }
3524
3539
  }
3525
3540
  var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
3526
- var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L79, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3541
+ var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L80, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
3527
3542
  function TypeIndex(state) {
3528
3543
  if (state.tokenize) {
3529
3544
  return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3543,7 +3558,7 @@ var Civet = (() => {
3543
3558
  return TypeSuffix$0(state);
3544
3559
  }
3545
3560
  }
3546
- var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L133, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3561
+ var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L134, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
3547
3562
  return { "ts": true, "children": value };
3548
3563
  });
3549
3564
  function ReturnTypeSuffix(state) {
@@ -3555,7 +3570,7 @@ var Civet = (() => {
3555
3570
  return ReturnTypeSuffix$0(state);
3556
3571
  }
3557
3572
  }
3558
- var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L70, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3573
+ var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L71, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
3559
3574
  function TypePredicate(state) {
3560
3575
  if (state.verbose)
3561
3576
  console.log("ENTER:", "TypePredicate");
@@ -3605,9 +3620,9 @@ var Civet = (() => {
3605
3620
  return TypeUnarySuffix$0(state);
3606
3621
  }
3607
3622
  }
3608
- var TypeUnaryOp$0 = $EXPECT($L134, fail, 'TypeUnaryOp "keyof"');
3609
- var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
3610
- var TypeUnaryOp$2 = $EXPECT($L135, fail, 'TypeUnaryOp "infer"');
3623
+ var TypeUnaryOp$0 = $EXPECT($L135, fail, 'TypeUnaryOp "keyof"');
3624
+ var TypeUnaryOp$1 = $EXPECT($L86, fail, 'TypeUnaryOp "typeof"');
3625
+ var TypeUnaryOp$2 = $EXPECT($L136, fail, 'TypeUnaryOp "infer"');
3611
3626
  function TypeUnaryOp(state) {
3612
3627
  if (state.tokenize) {
3613
3628
  return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -3615,7 +3630,7 @@ var Civet = (() => {
3615
3630
  return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
3616
3631
  }
3617
3632
  }
3618
- var TypeIndexedAccess$0 = $S(__, $EXPECT($L26, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L27, fail, 'TypeIndexedAccess "]"'));
3633
+ var TypeIndexedAccess$0 = $S(__, $EXPECT($L27, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L28, fail, 'TypeIndexedAccess "]"'));
3619
3634
  function TypeIndexedAccess(state) {
3620
3635
  if (state.verbose)
3621
3636
  console.log("ENTER:", "TypeIndexedAccess");
@@ -3648,8 +3663,8 @@ var Civet = (() => {
3648
3663
  }
3649
3664
  }
3650
3665
  var TypeLiteral$0 = Literal;
3651
- var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
3652
- var TypeLiteral$2 = $EXPECT($L136, fail, 'TypeLiteral "[]"');
3666
+ var TypeLiteral$1 = $EXPECT($L85, fail, 'TypeLiteral "void"');
3667
+ var TypeLiteral$2 = $EXPECT($L137, fail, 'TypeLiteral "[]"');
3653
3668
  function TypeLiteral(state) {
3654
3669
  if (state.tokenize) {
3655
3670
  return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -3657,8 +3672,8 @@ var Civet = (() => {
3657
3672
  return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
3658
3673
  }
3659
3674
  }
3660
- var TypeBinaryOp$0 = $EXPECT($L82, fail, 'TypeBinaryOp "|"');
3661
- var TypeBinaryOp$1 = $EXPECT($L80, fail, 'TypeBinaryOp "&"');
3675
+ var TypeBinaryOp$0 = $EXPECT($L83, fail, 'TypeBinaryOp "|"');
3676
+ var TypeBinaryOp$1 = $EXPECT($L81, fail, 'TypeBinaryOp "&"');
3662
3677
  function TypeBinaryOp(state) {
3663
3678
  if (state.tokenize) {
3664
3679
  return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3676,7 +3691,7 @@ var Civet = (() => {
3676
3691
  return FunctionType$0(state);
3677
3692
  }
3678
3693
  }
3679
- var TypeArguments$0 = $S(__, $EXPECT($L16, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L67, fail, 'TypeArguments ">"'));
3694
+ var TypeArguments$0 = $S(__, $EXPECT($L16, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L68, fail, 'TypeArguments ">"'));
3680
3695
  function TypeArguments(state) {
3681
3696
  if (state.verbose)
3682
3697
  console.log("ENTER:", "TypeArguments");
@@ -3686,7 +3701,7 @@ var Civet = (() => {
3686
3701
  return TypeArguments$0(state);
3687
3702
  }
3688
3703
  }
3689
- var TypeParameters$0 = $TS($S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
3704
+ var TypeParameters$0 = $TS($S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L68, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
3690
3705
  return { ts: true, children: $0 };
3691
3706
  });
3692
3707
  function TypeParameters(state) {
@@ -3719,8 +3734,8 @@ var Civet = (() => {
3719
3734
  }
3720
3735
  }
3721
3736
  var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
3722
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L67, fail, 'TypeParameterDelimiter ">"')));
3723
- var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L67, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3737
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L68, fail, 'TypeParameterDelimiter ">"')));
3738
+ var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L68, fail, 'TypeParameterDelimiter ">"'))), function(value) {
3724
3739
  return ",";
3725
3740
  });
3726
3741
  var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
@@ -3743,9 +3758,7 @@ var Civet = (() => {
3743
3758
  return Shebang$0(state);
3744
3759
  }
3745
3760
  }
3746
- var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R33, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
3747
- return $0.map((p) => p.join(""));
3748
- });
3761
+ var DirectivePrologue$0 = $Q($S($R$0($EXPECT($R33, fail, "DirectivePrologue /[\\t ]*/")), StringLiteral, $TEXT(StatementDelimiter), EOS));
3749
3762
  function DirectivePrologue(state) {
3750
3763
  if (state.verbose)
3751
3764
  console.log("ENTER:", "DirectivePrologue");
@@ -3785,7 +3798,7 @@ var Civet = (() => {
3785
3798
  return EOF$0(state);
3786
3799
  }
3787
3800
  }
3788
- var Debugger$0 = $TV($EXPECT($L32, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3801
+ var Debugger$0 = $TV($EXPECT($L33, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
3789
3802
  debugger;
3790
3803
  });
3791
3804
  function Debugger(state) {
@@ -3797,7 +3810,7 @@ var Civet = (() => {
3797
3810
  return Debugger$0(state);
3798
3811
  }
3799
3812
  }
3800
- var InsertOpenParen$0 = $T($EXPECT($L32, fail, 'InsertOpenParen ""'), function(value) {
3813
+ var InsertOpenParen$0 = $T($EXPECT($L33, fail, 'InsertOpenParen ""'), function(value) {
3801
3814
  return "(";
3802
3815
  });
3803
3816
  function InsertOpenParen(state) {
@@ -3809,7 +3822,7 @@ var Civet = (() => {
3809
3822
  return InsertOpenParen$0(state);
3810
3823
  }
3811
3824
  }
3812
- var InsertCloseParen$0 = $T($EXPECT($L32, fail, 'InsertCloseParen ""'), function(value) {
3825
+ var InsertCloseParen$0 = $T($EXPECT($L33, fail, 'InsertCloseParen ""'), function(value) {
3813
3826
  return ")";
3814
3827
  });
3815
3828
  function InsertCloseParen(state) {
@@ -3821,7 +3834,7 @@ var Civet = (() => {
3821
3834
  return InsertCloseParen$0(state);
3822
3835
  }
3823
3836
  }
3824
- var InsertOpenBrace$0 = $T($EXPECT($L32, fail, 'InsertOpenBrace ""'), function(value) {
3837
+ var InsertOpenBrace$0 = $T($EXPECT($L33, fail, 'InsertOpenBrace ""'), function(value) {
3825
3838
  return " {";
3826
3839
  });
3827
3840
  function InsertOpenBrace(state) {
@@ -3833,7 +3846,7 @@ var Civet = (() => {
3833
3846
  return InsertOpenBrace$0(state);
3834
3847
  }
3835
3848
  }
3836
- var InsertCloseBrace$0 = $T($EXPECT($L32, fail, 'InsertCloseBrace ""'), function(value) {
3849
+ var InsertCloseBrace$0 = $T($EXPECT($L33, fail, 'InsertCloseBrace ""'), function(value) {
3837
3850
  return "}";
3838
3851
  });
3839
3852
  function InsertCloseBrace(state) {
@@ -3845,7 +3858,7 @@ var Civet = (() => {
3845
3858
  return InsertCloseBrace$0(state);
3846
3859
  }
3847
3860
  }
3848
- var InsertNewline$0 = $TV($EXPECT($L32, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3861
+ var InsertNewline$0 = $TV($EXPECT($L33, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
3849
3862
  return "\n";
3850
3863
  });
3851
3864
  function InsertNewline(state) {
@@ -3857,7 +3870,7 @@ var Civet = (() => {
3857
3870
  return InsertNewline$0(state);
3858
3871
  }
3859
3872
  }
3860
- var InsertIndent$0 = $TV($EXPECT($L32, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3873
+ var InsertIndent$0 = $TV($EXPECT($L33, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
3861
3874
  return "".padStart(global.currentIndent * 2);
3862
3875
  });
3863
3876
  function InsertIndent(state) {
@@ -3869,7 +3882,7 @@ var Civet = (() => {
3869
3882
  return InsertIndent$0(state);
3870
3883
  }
3871
3884
  }
3872
- var InsertSpace$0 = $T($EXPECT($L32, fail, 'InsertSpace ""'), function(value) {
3885
+ var InsertSpace$0 = $T($EXPECT($L33, fail, 'InsertSpace ""'), function(value) {
3873
3886
  return " ";
3874
3887
  });
3875
3888
  function InsertSpace(state) {
@@ -3881,7 +3894,7 @@ var Civet = (() => {
3881
3894
  return InsertSpace$0(state);
3882
3895
  }
3883
3896
  }
3884
- var InsertDot$0 = $T($EXPECT($L32, fail, 'InsertDot ""'), function(value) {
3897
+ var InsertDot$0 = $T($EXPECT($L33, fail, 'InsertDot ""'), function(value) {
3885
3898
  return ".";
3886
3899
  });
3887
3900
  function InsertDot(state) {
@@ -3893,7 +3906,7 @@ var Civet = (() => {
3893
3906
  return InsertDot$0(state);
3894
3907
  }
3895
3908
  }
3896
- var InsertBreak$0 = $T($EXPECT($L32, fail, 'InsertBreak ""'), function(value) {
3909
+ var InsertBreak$0 = $T($EXPECT($L33, fail, 'InsertBreak ""'), function(value) {
3897
3910
  return "break;";
3898
3911
  });
3899
3912
  function InsertBreak(state) {
@@ -3905,14 +3918,14 @@ var Civet = (() => {
3905
3918
  return InsertBreak$0(state);
3906
3919
  }
3907
3920
  }
3908
- var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L32, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3921
+ var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L33, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
3909
3922
  var directives = $2;
3910
3923
  global.currentIndent = 0;
3911
3924
  global.indentLevels = [0];
3912
3925
  global.verbose = false;
3913
3926
  if (directives) {
3914
3927
  const compatRe = /use coffee-compat/;
3915
- global.coffeeCompat = directives.some((d) => d.match(compatRe));
3928
+ module.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
3916
3929
  }
3917
3930
  module.dedentBlockString = function(str) {
3918
3931
  const spacing = str.match(/^(\r?\n|\n)\s+/);
@@ -3933,7 +3946,7 @@ var Civet = (() => {
3933
3946
  return Init$0(state);
3934
3947
  }
3935
3948
  }
3936
- var Indent$0 = $TV($Q($C($EXPECT($L137, fail, 'Indent " "'), $EXPECT($L138, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3949
+ var Indent$0 = $TV($Q($C($EXPECT($L138, fail, 'Indent " "'), $EXPECT($L139, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
3937
3950
  return $1.length;
3938
3951
  });
3939
3952
  function Indent(state) {
@@ -3945,7 +3958,7 @@ var Civet = (() => {
3945
3958
  return Indent$0(state);
3946
3959
  }
3947
3960
  }
3948
- var PushIndent$0 = $TV($EXPECT($L32, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3961
+ var PushIndent$0 = $TV($EXPECT($L33, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
3949
3962
  global.currentIndent++;
3950
3963
  if (global.verbose) {
3951
3964
  console.log("pushing indent", global.currentIndent);
@@ -3962,7 +3975,7 @@ var Civet = (() => {
3962
3975
  return PushIndent$0(state);
3963
3976
  }
3964
3977
  }
3965
- var PopIndent$0 = $TV($EXPECT($L32, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3978
+ var PopIndent$0 = $TV($EXPECT($L33, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
3966
3979
  if (global.verbose) {
3967
3980
  console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
3968
3981
  }