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