@danielx/civet 0.4.20 → 0.4.21

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 (4) hide show
  1. package/README.md +16 -13
  2. package/dist/browser.js +600 -505
  3. package/dist/main.js +600 -505
  4. package/package.json +1 -1
package/dist/browser.js CHANGED
@@ -439,7 +439,7 @@ ${input.slice(result.pos)}
439
439
  NestedClassElement,
440
440
  ClassElement,
441
441
  FieldDefinition,
442
- This,
442
+ ThisLiteral,
443
443
  LeftHandSideExpression,
444
444
  CallExpression,
445
445
  CallExpressionRest,
@@ -500,6 +500,7 @@ ${input.slice(result.pos)}
500
500
  Identifier,
501
501
  IdentifierName,
502
502
  IdentifierReference,
503
+ UpcomingAssignment,
503
504
  ArrayLiteral,
504
505
  RangeExpression,
505
506
  ArrayLiteralContent,
@@ -656,6 +657,7 @@ ${input.slice(result.pos)}
656
657
  JSMultiLineComment,
657
658
  CoffeeSingleLineComment,
658
659
  CoffeeMultiLineComment,
660
+ CoffeeHereCommentStart,
659
661
  InlineComment,
660
662
  RestOfLine,
661
663
  TrailingComment,
@@ -719,6 +721,7 @@ ${input.slice(result.pos)}
719
721
  Switch,
720
722
  Target,
721
723
  Then,
724
+ This,
722
725
  Throw,
723
726
  TripleDoubleQuote,
724
727
  TripleSingleQuote,
@@ -835,45 +838,45 @@ ${input.slice(result.pos)}
835
838
  var $L3 = $L(" ");
836
839
  var $L4 = $L("<");
837
840
  var $L5 = $L("extends");
838
- var $L6 = $L("this");
839
- var $L7 = $L("#");
840
- var $L8 = $L(".");
841
- var $L9 = $L("super");
842
- var $L10 = $L("import");
843
- var $L11 = $L("!");
844
- var $L12 = $L("super[");
845
- var $L13 = $L("import.meta");
846
- var $L14 = $L("");
847
- var $L15 = $L(")");
848
- var $L16 = $L("->");
849
- var $L17 = $L("null");
850
- var $L18 = $L("true");
851
- var $L19 = $L("false");
852
- var $L20 = $L("yes");
853
- var $L21 = $L("on");
854
- var $L22 = $L("no");
855
- var $L23 = $L("off");
856
- var $L24 = $L(",");
857
- var $L25 = $L("]");
858
- var $L26 = $L(":");
859
- var $L27 = $L("}");
860
- var $L28 = $L("**=");
861
- var $L29 = $L("*=");
862
- var $L30 = $L("/=");
863
- var $L31 = $L("%=");
864
- var $L32 = $L("+=");
865
- var $L33 = $L("-=");
866
- var $L34 = $L("<<=");
867
- var $L35 = $L(">>>=");
868
- var $L36 = $L(">>=");
869
- var $L37 = $L("&&=");
870
- var $L38 = $L("&=");
871
- var $L39 = $L("^=");
872
- var $L40 = $L("||=");
873
- var $L41 = $L("|=");
874
- var $L42 = $L("??=");
875
- var $L43 = $L("?=");
876
- var $L44 = $L("=");
841
+ var $L6 = $L("#");
842
+ var $L7 = $L(".");
843
+ var $L8 = $L("super");
844
+ var $L9 = $L("import");
845
+ var $L10 = $L("!");
846
+ var $L11 = $L("super[");
847
+ var $L12 = $L("import.meta");
848
+ var $L13 = $L("");
849
+ var $L14 = $L(")");
850
+ var $L15 = $L("->");
851
+ var $L16 = $L("null");
852
+ var $L17 = $L("true");
853
+ var $L18 = $L("false");
854
+ var $L19 = $L("yes");
855
+ var $L20 = $L("on");
856
+ var $L21 = $L("no");
857
+ var $L22 = $L("off");
858
+ var $L23 = $L(",");
859
+ var $L24 = $L("=");
860
+ var $L25 = $L(">");
861
+ var $L26 = $L("]");
862
+ var $L27 = $L(":");
863
+ var $L28 = $L("}");
864
+ var $L29 = $L("**=");
865
+ var $L30 = $L("*=");
866
+ var $L31 = $L("/=");
867
+ var $L32 = $L("%=");
868
+ var $L33 = $L("+=");
869
+ var $L34 = $L("-=");
870
+ var $L35 = $L("<<=");
871
+ var $L36 = $L(">>>=");
872
+ var $L37 = $L(">>=");
873
+ var $L38 = $L("&&=");
874
+ var $L39 = $L("&=");
875
+ var $L40 = $L("^=");
876
+ var $L41 = $L("||=");
877
+ var $L42 = $L("|=");
878
+ var $L43 = $L("??=");
879
+ var $L44 = $L("?=");
877
880
  var $L45 = $L("and=");
878
881
  var $L46 = $L("or=");
879
882
  var $L47 = $L("**");
@@ -887,107 +890,106 @@ ${input.slice(result.pos)}
887
890
  var $L55 = $L("<<");
888
891
  var $L56 = $L(">>>");
889
892
  var $L57 = $L(">>");
890
- var $L58 = $L(">");
891
- var $L59 = $L("!==");
892
- var $L60 = $L("!=");
893
- var $L61 = $L("isnt");
894
- var $L62 = $L("is");
895
- var $L63 = $L("===");
896
- var $L64 = $L("==");
897
- var $L65 = $L("and");
898
- var $L66 = $L("&&");
899
- var $L67 = $L("of");
900
- var $L68 = $L("or");
901
- var $L69 = $L("||");
902
- var $L70 = $L("??");
903
- var $L71 = $L("?");
904
- var $L72 = $L("instanceof");
893
+ var $L58 = $L("!==");
894
+ var $L59 = $L("!=");
895
+ var $L60 = $L("isnt");
896
+ var $L61 = $L("is");
897
+ var $L62 = $L("===");
898
+ var $L63 = $L("==");
899
+ var $L64 = $L("and");
900
+ var $L65 = $L("&&");
901
+ var $L66 = $L("of");
902
+ var $L67 = $L("or");
903
+ var $L68 = $L("||");
904
+ var $L69 = $L("??");
905
+ var $L70 = $L("?");
906
+ var $L71 = $L("instanceof");
907
+ var $L72 = $L("not");
905
908
  var $L73 = $L("in");
906
- var $L74 = $L("not");
907
- var $L75 = $L("&");
908
- var $L76 = $L("^");
909
- var $L77 = $L("|");
910
- var $L78 = $L(";");
911
- var $L79 = $L("own");
912
- var $L80 = $L("finally");
913
- var $L81 = $L("break");
914
- var $L82 = $L("continue");
915
- var $L83 = $L("debugger");
916
- var $L84 = $L("import type");
917
- var $L85 = $L("default");
918
- var $L86 = $L(":=");
919
- var $L87 = $L("/*");
920
- var $L88 = $L("*/");
921
- var $L89 = $L("###");
922
- var $L90 = $L("\\");
923
- var $L91 = $L("as");
924
- var $L92 = $L("@");
925
- var $L93 = $L("async");
926
- var $L94 = $L("await");
927
- var $L95 = $L("`");
928
- var $L96 = $L("by");
929
- var $L97 = $L("case");
930
- var $L98 = $L("catch");
931
- var $L99 = $L("class");
932
- var $L100 = $L("#{");
933
- var $L101 = $L("delete");
934
- var $L102 = $L("do");
935
- var $L103 = $L("..");
936
- var $L104 = $L("...");
937
- var $L105 = $L("::");
938
- var $L106 = $L('"');
939
- var $L107 = $L("else");
940
- var $L108 = $L("export");
941
- var $L109 = $L("for");
942
- var $L110 = $L("from");
943
- var $L111 = $L("function");
944
- var $L112 = $L("get");
945
- var $L113 = $L("set");
946
- var $L114 = $L("if");
947
- var $L115 = $L("let");
948
- var $L116 = $L("const");
949
- var $L117 = $L("loop");
950
- var $L118 = $L("new");
951
- var $L119 = $L("{");
952
- var $L120 = $L("[");
953
- var $L121 = $L("(");
954
- var $L122 = $L("return");
955
- var $L123 = $L("'");
956
- var $L124 = $L("static");
957
- var $L125 = $L("${");
958
- var $L126 = $L("switch");
959
- var $L127 = $L("target");
960
- var $L128 = $L("then");
961
- var $L129 = $L("throw");
962
- var $L130 = $L('"""');
963
- var $L131 = $L("'''");
964
- var $L132 = $L("///");
965
- var $L133 = $L("```");
966
- var $L134 = $L("try");
967
- var $L135 = $L("typeof");
968
- var $L136 = $L("unless");
969
- var $L137 = $L("until");
970
- var $L138 = $L("var");
971
- var $L139 = $L("void");
972
- var $L140 = $L("when");
973
- var $L141 = $L("while");
974
- var $L142 = $L("yield");
975
- var $L143 = $L("/>");
976
- var $L144 = $L("</");
977
- var $L145 = $L("<>");
978
- var $L146 = $L("</>");
979
- var $L147 = $L("declare");
980
- var $L148 = $L("type");
981
- var $L149 = $L("interface");
982
- var $L150 = $L("namespace");
983
- var $L151 = $L("readonly");
984
- var $L152 = $L("asserts");
985
- var $L153 = $L("keyof");
986
- var $L154 = $L("infer");
987
- var $L155 = $L("[]");
988
- var $L156 = $L("civet");
989
- var $L157 = $L(" ");
990
- var $L158 = $L(" ");
909
+ var $L74 = $L("&");
910
+ var $L75 = $L("^");
911
+ var $L76 = $L("|");
912
+ var $L77 = $L(";");
913
+ var $L78 = $L("own");
914
+ var $L79 = $L("finally");
915
+ var $L80 = $L("break");
916
+ var $L81 = $L("continue");
917
+ var $L82 = $L("debugger");
918
+ var $L83 = $L("import type");
919
+ var $L84 = $L("default");
920
+ var $L85 = $L(":=");
921
+ var $L86 = $L("/*");
922
+ var $L87 = $L("*/");
923
+ var $L88 = $L("\\");
924
+ var $L89 = $L("as");
925
+ var $L90 = $L("@");
926
+ var $L91 = $L("async");
927
+ var $L92 = $L("await");
928
+ var $L93 = $L("`");
929
+ var $L94 = $L("by");
930
+ var $L95 = $L("case");
931
+ var $L96 = $L("catch");
932
+ var $L97 = $L("class");
933
+ var $L98 = $L("#{");
934
+ var $L99 = $L("delete");
935
+ var $L100 = $L("do");
936
+ var $L101 = $L("..");
937
+ var $L102 = $L("...");
938
+ var $L103 = $L("::");
939
+ var $L104 = $L('"');
940
+ var $L105 = $L("else");
941
+ var $L106 = $L("export");
942
+ var $L107 = $L("for");
943
+ var $L108 = $L("from");
944
+ var $L109 = $L("function");
945
+ var $L110 = $L("get");
946
+ var $L111 = $L("set");
947
+ var $L112 = $L("if");
948
+ var $L113 = $L("let");
949
+ var $L114 = $L("const");
950
+ var $L115 = $L("loop");
951
+ var $L116 = $L("new");
952
+ var $L117 = $L("{");
953
+ var $L118 = $L("[");
954
+ var $L119 = $L("(");
955
+ var $L120 = $L("return");
956
+ var $L121 = $L("'");
957
+ var $L122 = $L("static");
958
+ var $L123 = $L("${");
959
+ var $L124 = $L("switch");
960
+ var $L125 = $L("target");
961
+ var $L126 = $L("then");
962
+ var $L127 = $L("this");
963
+ var $L128 = $L("throw");
964
+ var $L129 = $L('"""');
965
+ var $L130 = $L("'''");
966
+ var $L131 = $L("///");
967
+ var $L132 = $L("```");
968
+ var $L133 = $L("try");
969
+ var $L134 = $L("typeof");
970
+ var $L135 = $L("unless");
971
+ var $L136 = $L("until");
972
+ var $L137 = $L("var");
973
+ var $L138 = $L("void");
974
+ var $L139 = $L("when");
975
+ var $L140 = $L("while");
976
+ var $L141 = $L("yield");
977
+ var $L142 = $L("/>");
978
+ var $L143 = $L("</");
979
+ var $L144 = $L("<>");
980
+ var $L145 = $L("</>");
981
+ var $L146 = $L("declare");
982
+ var $L147 = $L("type");
983
+ var $L148 = $L("interface");
984
+ var $L149 = $L("namespace");
985
+ var $L150 = $L("readonly");
986
+ var $L151 = $L("asserts");
987
+ var $L152 = $L("keyof");
988
+ var $L153 = $L("infer");
989
+ var $L154 = $L("[]");
990
+ var $L155 = $L("civet");
991
+ var $L156 = $L(" ");
992
+ var $L157 = $L(" ");
991
993
  var $R0 = $R(new RegExp("(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
992
994
  var $R1 = $R(new RegExp("[&]", "suy"));
993
995
  var $R2 = $R(new RegExp("[!~+-]+", "suy"));
@@ -1024,22 +1026,23 @@ ${input.slice(result.pos)}
1024
1026
  var $R33 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|let|loop|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|until|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
1025
1027
  var $R34 = $R(new RegExp("\\/\\/(?!\\/)[^\\r\\n]*", "suy"));
1026
1028
  var $R35 = $R(new RegExp(".", "suy"));
1027
- var $R36 = $R(new RegExp("#(?!##)([^\\r\\n]*)", "suy"));
1028
- var $R37 = $R(new RegExp("[^\\r\\n]", "suy"));
1029
- var $R38 = $R(new RegExp("[ \\t]+", "suy"));
1030
- var $R39 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
1031
- var $R40 = $R(new RegExp("\\s", "suy"));
1032
- var $R41 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
1033
- var $R42 = $R(new RegExp('"[^"]*"', "suy"));
1034
- var $R43 = $R(new RegExp("'[^']*'", "suy"));
1035
- var $R44 = $R(new RegExp("[^{}<>]+", "suy"));
1036
- var $R45 = $R(new RegExp("[+-]?", "suy"));
1037
- var $R46 = $R(new RegExp("[+-]", "suy"));
1038
- var $R47 = $R(new RegExp("#![^\\r\\n]*", "suy"));
1039
- var $R48 = $R(new RegExp("[\\t ]*", "suy"));
1040
- var $R49 = $R(new RegExp("[\\s]*", "suy"));
1041
- var $R50 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
1042
- var $R51 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
1029
+ var $R36 = $R(new RegExp("#(?!##(?!#))([^\\r\\n]*)", "suy"));
1030
+ var $R37 = $R(new RegExp("###(?!#)", "suy"));
1031
+ var $R38 = $R(new RegExp("[^\\r\\n]", "suy"));
1032
+ var $R39 = $R(new RegExp("[ \\t]+", "suy"));
1033
+ var $R40 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
1034
+ var $R41 = $R(new RegExp("\\s", "suy"));
1035
+ var $R42 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
1036
+ var $R43 = $R(new RegExp('"[^"]*"', "suy"));
1037
+ var $R44 = $R(new RegExp("'[^']*'", "suy"));
1038
+ var $R45 = $R(new RegExp("[^{}<>]+", "suy"));
1039
+ var $R46 = $R(new RegExp("[+-]?", "suy"));
1040
+ var $R47 = $R(new RegExp("[+-]", "suy"));
1041
+ var $R48 = $R(new RegExp("#![^\\r\\n]*", "suy"));
1042
+ var $R49 = $R(new RegExp("[\\t ]*", "suy"));
1043
+ var $R50 = $R(new RegExp("[\\s]*", "suy"));
1044
+ var $R51 = $R(new RegExp("\\s+([+-]?)([a-zA-Z0-9-]+)", "suy"));
1045
+ var $R52 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
1043
1046
  var Program$0 = $TS($S(Reset, Init, __, $Q(TopLevelStatement), __), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
1044
1047
  var statements = $4;
1045
1048
  module.processProgram(statements);
@@ -1089,9 +1092,10 @@ ${input.slice(result.pos)}
1089
1092
  return $skip;
1090
1093
  });
1091
1094
  var ExtendedExpression$1 = $TS($S(__, ExpressionizedStatement), function($skip, $loc, $0, $1, $2) {
1092
- return Object.assign({}, $2, {
1095
+ return {
1096
+ ...$2,
1093
1097
  children: [...$1, ...$2.children]
1094
- });
1098
+ };
1095
1099
  });
1096
1100
  var ExtendedExpression$2 = AssignmentExpression;
1097
1101
  function ExtendedExpression(state) {
@@ -1427,9 +1431,10 @@ ${input.slice(result.pos)}
1427
1431
  switch (exp.type) {
1428
1432
  case "Identifier":
1429
1433
  case "Literal":
1430
- return Object.assign({}, exp, {
1434
+ return {
1435
+ ...exp,
1431
1436
  children: [...pre, ...exp.children, post]
1432
- });
1437
+ };
1433
1438
  default:
1434
1439
  return {
1435
1440
  type: "ParenthesizedExpression",
@@ -1616,7 +1621,9 @@ ${input.slice(result.pos)}
1616
1621
  return {
1617
1622
  type: "AssignmentExpression",
1618
1623
  children: $0,
1619
- names: null
1624
+ names: null,
1625
+ lhs: $1,
1626
+ exp: $2
1620
1627
  };
1621
1628
  });
1622
1629
  function ActualAssignment(state) {
@@ -1678,9 +1685,10 @@ ${input.slice(result.pos)}
1678
1685
  }
1679
1686
  var ArrowFunction$0 = $TS($S($E($S(Async, __)), ArrowFunctionTail), function($skip, $loc, $0, $1, $2) {
1680
1687
  var tail = $2;
1681
- return Object.assign({}, tail, {
1688
+ return {
1689
+ ...tail,
1682
1690
  children: [...$1 || [], ...tail.children]
1683
- });
1691
+ };
1684
1692
  });
1685
1693
  function ArrowFunction(state) {
1686
1694
  if (state.events) {
@@ -1866,7 +1874,7 @@ ${input.slice(result.pos)}
1866
1874
  return result;
1867
1875
  }
1868
1876
  }
1869
- var PrimaryExpression$0 = This;
1877
+ var PrimaryExpression$0 = ThisLiteral;
1870
1878
  var PrimaryExpression$1 = Literal;
1871
1879
  var PrimaryExpression$2 = ArrayLiteral;
1872
1880
  var PrimaryExpression$3 = ObjectLiteral;
@@ -1900,20 +1908,7 @@ ${input.slice(result.pos)}
1900
1908
  var exp = $2;
1901
1909
  var post = $3;
1902
1910
  if (post) {
1903
- let clause;
1904
- switch (post[1].type) {
1905
- case "IterationStatement":
1906
- case "ForStatement":
1907
- clause = module.addPostfixStatement(exp, ...post);
1908
- return {
1909
- type: "IterationExpression",
1910
- children: [clause],
1911
- block: clause.block
1912
- };
1913
- case "IfStatement":
1914
- clause = module.expressionizeIfClause(post[1], exp);
1915
- return clause;
1916
- }
1911
+ return module.attachPostfixStatementAsExpression(exp, post);
1917
1912
  }
1918
1913
  return {
1919
1914
  type: "ParenthesizedExpression",
@@ -2144,37 +2139,35 @@ ${input.slice(result.pos)}
2144
2139
  return result;
2145
2140
  }
2146
2141
  }
2147
- var This$0 = $TV($EXPECT($L6, fail, 'This "this"'), function($skip, $loc, $0, $1) {
2148
- return { $loc, token: $1 };
2149
- });
2150
- var This$1 = $TS($S(At, $TEXT($S($E($EXPECT($L7, fail, 'This "#"')), IdentifierName))), function($skip, $loc, $0, $1, $2) {
2142
+ var ThisLiteral$0 = This;
2143
+ var ThisLiteral$1 = $TS($S(At, $TEXT($S($E($EXPECT($L6, fail, 'ThisLiteral "#"')), IdentifierName))), function($skip, $loc, $0, $1, $2) {
2151
2144
  var t = $1;
2152
2145
  var id = $2;
2153
2146
  return [{ ...t, token: "this." }, id];
2154
2147
  });
2155
- var This$2 = $TS($S(At), function($skip, $loc, $0, $1) {
2148
+ var ThisLiteral$2 = $TS($S(At), function($skip, $loc, $0, $1) {
2156
2149
  $1.token = "this";
2157
2150
  return $1;
2158
2151
  });
2159
- function This(state) {
2152
+ function ThisLiteral(state) {
2160
2153
  if (state.events) {
2161
- const result = state.events.enter?.("This", state);
2154
+ const result = state.events.enter?.("ThisLiteral", state);
2162
2155
  if (result)
2163
2156
  return result.cache;
2164
2157
  }
2165
2158
  if (state.tokenize) {
2166
- const result = $TOKEN("This", state, This$0(state) || This$1(state) || This$2(state));
2159
+ const result = $TOKEN("ThisLiteral", state, ThisLiteral$0(state) || ThisLiteral$1(state) || ThisLiteral$2(state));
2167
2160
  if (state.events)
2168
- state.events.exit?.("This", state, result);
2161
+ state.events.exit?.("ThisLiteral", state, result);
2169
2162
  return result;
2170
2163
  } else {
2171
- const result = This$0(state) || This$1(state) || This$2(state);
2164
+ const result = ThisLiteral$0(state) || ThisLiteral$1(state) || ThisLiteral$2(state);
2172
2165
  if (state.events)
2173
- state.events.exit?.("This", state, result);
2166
+ state.events.exit?.("ThisLiteral", state, result);
2174
2167
  return result;
2175
2168
  }
2176
2169
  }
2177
- var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L8, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
2170
+ var LeftHandSideExpression$0 = $TS($S($Q($S(New, $N($EXPECT($L7, fail, 'LeftHandSideExpression "."')), __)), CallExpression), function($skip, $loc, $0, $1, $2) {
2178
2171
  if ($1.length)
2179
2172
  return $0;
2180
2173
  return $2;
@@ -2197,8 +2190,8 @@ ${input.slice(result.pos)}
2197
2190
  return result;
2198
2191
  }
2199
2192
  }
2200
- var CallExpression$0 = $S($EXPECT($L9, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
2201
- var CallExpression$1 = $S($EXPECT($L10, fail, 'CallExpression "import"'), __, OpenParen, ExtendedExpression, __, CloseParen);
2193
+ var CallExpression$0 = $S($EXPECT($L8, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
2194
+ var CallExpression$1 = $S($EXPECT($L9, fail, 'CallExpression "import"'), __, OpenParen, ExtendedExpression, __, CloseParen);
2202
2195
  var CallExpression$2 = $TS($S(MemberExpression, $Q(CallExpressionRest)), function($skip, $loc, $0, $1, $2) {
2203
2196
  if ($2.length)
2204
2197
  return $0;
@@ -2262,7 +2255,7 @@ ${input.slice(result.pos)}
2262
2255
  return result;
2263
2256
  }
2264
2257
  }
2265
- var NonNullAssertion$0 = $T($EXPECT($L11, fail, 'NonNullAssertion "!"'), function(value) {
2258
+ var NonNullAssertion$0 = $T($EXPECT($L10, fail, 'NonNullAssertion "!"'), function(value) {
2266
2259
  return { "ts": true, "children": value };
2267
2260
  });
2268
2261
  function NonNullAssertion(state) {
@@ -2502,7 +2495,7 @@ ${input.slice(result.pos)}
2502
2495
  return result;
2503
2496
  }
2504
2497
  }
2505
- var SuperProperty$0 = $S($EXPECT($L12, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
2498
+ var SuperProperty$0 = $S($EXPECT($L11, fail, 'SuperProperty "super["'), ExtendedExpression, __, CloseBracket);
2506
2499
  function SuperProperty(state) {
2507
2500
  if (state.events) {
2508
2501
  const result = state.events.enter?.("SuperProperty", state);
@@ -2522,7 +2515,7 @@ ${input.slice(result.pos)}
2522
2515
  }
2523
2516
  }
2524
2517
  var MetaProperty$0 = $S(New, Dot, Target);
2525
- var MetaProperty$1 = $TV($EXPECT($L13, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
2518
+ var MetaProperty$1 = $TV($EXPECT($L12, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
2526
2519
  return { $loc, token: $1 };
2527
2520
  });
2528
2521
  function MetaProperty(state) {
@@ -2544,7 +2537,7 @@ ${input.slice(result.pos)}
2544
2537
  }
2545
2538
  }
2546
2539
  var Parameters$0 = NonEmptyParameters;
2547
- var Parameters$1 = $TV($EXPECT($L14, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
2540
+ var Parameters$1 = $TV($EXPECT($L13, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
2548
2541
  return {
2549
2542
  type: "Parameters",
2550
2543
  children: [{ $loc, token: "()" }],
@@ -2589,8 +2582,7 @@ ${input.slice(result.pos)}
2589
2582
  if (after.length) {
2590
2583
  const spliceRef = module.getSpliceRef();
2591
2584
  blockPrefix = {
2592
- type: "AssignmentExpression",
2593
- children: ["let [", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
2585
+ children: ["[", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
2594
2586
  names: after.flatMap((p) => p.names)
2595
2587
  };
2596
2588
  }
@@ -2684,7 +2676,7 @@ ${input.slice(result.pos)}
2684
2676
  }
2685
2677
  }
2686
2678
  var ParameterElementDelimiter$0 = $S($Q(_), Comma);
2687
- var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L15, fail, 'ParameterElementDelimiter ")"')));
2679
+ var ParameterElementDelimiter$1 = $Y($S(__, $EXPECT($L14, fail, 'ParameterElementDelimiter ")"')));
2688
2680
  var ParameterElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
2689
2681
  return { $loc, token: "," };
2690
2682
  });
@@ -2754,7 +2746,7 @@ ${input.slice(result.pos)}
2754
2746
  var BindingPattern$1 = $TS($S(__, ArrayBindingPattern), function($skip, $loc, $0, $1, $2) {
2755
2747
  var p = $2;
2756
2748
  return {
2757
- children: [...$1, p],
2749
+ children: [...$1, p.children],
2758
2750
  names: p.names
2759
2751
  };
2760
2752
  });
@@ -2779,6 +2771,7 @@ ${input.slice(result.pos)}
2779
2771
  var ObjectBindingPattern$0 = $TS($S(OpenBrace, ObjectBindingPatternContent, __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4) {
2780
2772
  var c = $2;
2781
2773
  return {
2774
+ type: "ObjectBindingPattern",
2782
2775
  children: [$1, ...c.children, ...$3, $4],
2783
2776
  names: c.names
2784
2777
  };
@@ -2839,6 +2832,7 @@ ${input.slice(result.pos)}
2839
2832
  var ArrayBindingPattern$0 = $TS($S(OpenBracket, ArrayBindingPatternContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
2840
2833
  var c = $2;
2841
2834
  return {
2835
+ type: "ArrayBindingPattern",
2842
2836
  names: c.names,
2843
2837
  children: $0
2844
2838
  };
@@ -2882,8 +2876,7 @@ ${input.slice(result.pos)}
2882
2876
  if (after.length) {
2883
2877
  const spliceRef = module.getSpliceRef();
2884
2878
  blockPrefix = {
2885
- type: "AssignmentExpression",
2886
- children: ["let [", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
2879
+ children: ["[", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
2887
2880
  names: after.flatMap((p) => p.names)
2888
2881
  };
2889
2882
  }
@@ -3116,8 +3109,7 @@ ${input.slice(result.pos)}
3116
3109
  if (after.length) {
3117
3110
  const spliceRef = module.getSpliceRef();
3118
3111
  blockPrefix = {
3119
- type: "AssignmentExpression",
3120
- children: ["let [", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
3112
+ children: ["[", module.insertTrimmingSpace(after, ""), "] = ", spliceRef, ".call(", restIdentifier, ", -", after.length.toString(), ")"],
3121
3113
  names: after.flatMap((p) => p.names)
3122
3114
  };
3123
3115
  }
@@ -3235,7 +3227,7 @@ ${input.slice(result.pos)}
3235
3227
  return result;
3236
3228
  }
3237
3229
  }
3238
- var EmptyBindingPattern$0 = $TV($EXPECT($L14, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
3230
+ var EmptyBindingPattern$0 = $TV($EXPECT($L13, fail, 'EmptyBindingPattern ""'), function($skip, $loc, $0, $1) {
3239
3231
  const ref = { type: "Ref", base: "ref" };
3240
3232
  return {
3241
3233
  type: "EmptyBinding",
@@ -3404,7 +3396,7 @@ ${input.slice(result.pos)}
3404
3396
  return result;
3405
3397
  }
3406
3398
  }
3407
- var Arrow$0 = $TV($EXPECT($L16, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
3399
+ var Arrow$0 = $TV($EXPECT($L15, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
3408
3400
  return { $loc, token: $1 };
3409
3401
  });
3410
3402
  function Arrow(state) {
@@ -3784,7 +3776,7 @@ ${input.slice(result.pos)}
3784
3776
  return result;
3785
3777
  }
3786
3778
  }
3787
- var NullLiteral$0 = $TV($EXPECT($L17, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
3779
+ var NullLiteral$0 = $TV($EXPECT($L16, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
3788
3780
  return { $loc, token: $1 };
3789
3781
  });
3790
3782
  function NullLiteral(state) {
@@ -3808,7 +3800,7 @@ ${input.slice(result.pos)}
3808
3800
  var BooleanLiteral$0 = $T($S(CoffeeBooleansEnabled, CoffeeScriptBooleanLiteral), function(value) {
3809
3801
  return value[1];
3810
3802
  });
3811
- var BooleanLiteral$1 = $TS($S($C($EXPECT($L18, fail, 'BooleanLiteral "true"'), $EXPECT($L19, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3803
+ var BooleanLiteral$1 = $TS($S($C($EXPECT($L17, fail, 'BooleanLiteral "true"'), $EXPECT($L18, fail, 'BooleanLiteral "false"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3812
3804
  return { $loc, token: $1 };
3813
3805
  });
3814
3806
  function BooleanLiteral(state) {
@@ -3829,10 +3821,10 @@ ${input.slice(result.pos)}
3829
3821
  return result;
3830
3822
  }
3831
3823
  }
3832
- var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3824
+ var CoffeeScriptBooleanLiteral$0 = $TS($S($C($EXPECT($L19, fail, 'CoffeeScriptBooleanLiteral "yes"'), $EXPECT($L20, fail, 'CoffeeScriptBooleanLiteral "on"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3833
3825
  return { $loc, token: "true" };
3834
3826
  });
3835
- var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L23, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3827
+ var CoffeeScriptBooleanLiteral$1 = $TS($S($C($EXPECT($L21, fail, 'CoffeeScriptBooleanLiteral "no"'), $EXPECT($L22, fail, 'CoffeeScriptBooleanLiteral "off"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
3836
3828
  return { $loc, token: "false" };
3837
3829
  });
3838
3830
  function CoffeeScriptBooleanLiteral(state) {
@@ -3853,7 +3845,7 @@ ${input.slice(result.pos)}
3853
3845
  return result;
3854
3846
  }
3855
3847
  }
3856
- var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
3848
+ var Comma$0 = $TV($EXPECT($L23, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
3857
3849
  return { $loc, token: $1 };
3858
3850
  });
3859
3851
  function Comma(state) {
@@ -3943,7 +3935,29 @@ ${input.slice(result.pos)}
3943
3935
  return result;
3944
3936
  }
3945
3937
  }
3946
- var ArrayLiteral$0 = $TS($S(OpenBracket, ArrayLiteralContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
3938
+ var UpcomingAssignment$0 = $Y($S(__, $EXPECT($L24, fail, 'UpcomingAssignment "="'), $N($C($EXPECT($L24, fail, 'UpcomingAssignment "="'), $EXPECT($L25, fail, 'UpcomingAssignment ">"')))));
3939
+ function UpcomingAssignment(state) {
3940
+ if (state.events) {
3941
+ const result = state.events.enter?.("UpcomingAssignment", state);
3942
+ if (result)
3943
+ return result.cache;
3944
+ }
3945
+ if (state.tokenize) {
3946
+ const result = $TOKEN("UpcomingAssignment", state, UpcomingAssignment$0(state));
3947
+ if (state.events)
3948
+ state.events.exit?.("UpcomingAssignment", state, result);
3949
+ return result;
3950
+ } else {
3951
+ const result = UpcomingAssignment$0(state);
3952
+ if (state.events)
3953
+ state.events.exit?.("UpcomingAssignment", state, result);
3954
+ return result;
3955
+ }
3956
+ }
3957
+ var ArrayLiteral$0 = $T($S(ArrayBindingPattern, UpcomingAssignment), function(value) {
3958
+ return value[0];
3959
+ });
3960
+ var ArrayLiteral$1 = $TS($S(OpenBracket, ArrayLiteralContent, __, CloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
3947
3961
  var content = $2;
3948
3962
  var ws = $3;
3949
3963
  if (content.type === "RangeExpression") {
@@ -3974,12 +3988,12 @@ ${input.slice(result.pos)}
3974
3988
  return result.cache;
3975
3989
  }
3976
3990
  if (state.tokenize) {
3977
- const result = $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state));
3991
+ const result = $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
3978
3992
  if (state.events)
3979
3993
  state.events.exit?.("ArrayLiteral", state, result);
3980
3994
  return result;
3981
3995
  } else {
3982
- const result = ArrayLiteral$0(state);
3996
+ const result = ArrayLiteral$0(state) || ArrayLiteral$1(state);
3983
3997
  if (state.events)
3984
3998
  state.events.exit?.("ArrayLiteral", state, result);
3985
3999
  return result;
@@ -4160,7 +4174,7 @@ ${input.slice(result.pos)}
4160
4174
  }
4161
4175
  }
4162
4176
  var ArrayElementDelimiter$0 = $S($Q(_), Comma);
4163
- var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
4177
+ var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ArrayElementDelimiter "]"')));
4164
4178
  var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
4165
4179
  return { $loc, token: "," };
4166
4180
  });
@@ -4236,10 +4250,17 @@ ${input.slice(result.pos)}
4236
4250
  return result;
4237
4251
  }
4238
4252
  }
4239
- var ArrayElementExpression$0 = $TS($S(ExtendedExpression, __, DotDotDot), function($skip, $loc, $0, $1, $2, $3) {
4253
+ var ArrayElementExpression$0 = $TS($S($E(ExtendedExpression), __, DotDotDot, $Y(ArrayElementDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
4240
4254
  var exp = $1;
4241
4255
  var ws = $2;
4242
4256
  var dots = $3;
4257
+ if (!exp) {
4258
+ exp = {
4259
+ type: "Ref",
4260
+ base: "ref",
4261
+ names: []
4262
+ };
4263
+ }
4243
4264
  return {
4244
4265
  type: "SpreadElement",
4245
4266
  children: [...ws, dots, exp],
@@ -4287,9 +4308,12 @@ ${input.slice(result.pos)}
4287
4308
  return result;
4288
4309
  }
4289
4310
  }
4290
- var ObjectLiteral$0 = BracedObjectLiteral;
4291
- var ObjectLiteral$1 = NestedImplicitObjectLiteral;
4292
- var ObjectLiteral$2 = InlineObjectLiteral;
4311
+ var ObjectLiteral$0 = $T($S(ObjectBindingPattern, UpcomingAssignment), function(value) {
4312
+ return value[0];
4313
+ });
4314
+ var ObjectLiteral$1 = BracedObjectLiteral;
4315
+ var ObjectLiteral$2 = NestedImplicitObjectLiteral;
4316
+ var ObjectLiteral$3 = InlineObjectLiteral;
4293
4317
  function ObjectLiteral(state) {
4294
4318
  if (state.events) {
4295
4319
  const result = state.events.enter?.("ObjectLiteral", state);
@@ -4297,12 +4321,12 @@ ${input.slice(result.pos)}
4297
4321
  return result.cache;
4298
4322
  }
4299
4323
  if (state.tokenize) {
4300
- const result = $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state));
4324
+ const result = $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state) || ObjectLiteral$3(state));
4301
4325
  if (state.events)
4302
4326
  state.events.exit?.("ObjectLiteral", state, result);
4303
4327
  return result;
4304
4328
  } else {
4305
- const result = ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state);
4329
+ const result = ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state) || ObjectLiteral$3(state);
4306
4330
  if (state.events)
4307
4331
  state.events.exit?.("ObjectLiteral", state, result);
4308
4332
  return result;
@@ -4465,14 +4489,13 @@ ${input.slice(result.pos)}
4465
4489
  return result;
4466
4490
  }
4467
4491
  }
4468
- var NestedPropertyDefinition$0 = $TS($S(Nested, PropertyDefinition, ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3) {
4492
+ var NestedPropertyDefinition$0 = $TS($S(Nested, $P($S(PropertyDefinition, ObjectPropertyDelimiter))), function($skip, $loc, $0, $1, $2) {
4469
4493
  var ws = $1;
4470
- var prop = $2;
4471
- var delimiter = $3;
4472
- return {
4494
+ var inlineProps = $2;
4495
+ return inlineProps.map(([prop, delimiter], i) => ({
4473
4496
  ...prop,
4474
- children: [...ws, ...prop.children, delimiter]
4475
- };
4497
+ children: [...i === 0 ? ws : [], ...prop.children, delimiter]
4498
+ }));
4476
4499
  });
4477
4500
  function NestedPropertyDefinition(state) {
4478
4501
  if (state.events) {
@@ -4515,13 +4538,14 @@ ${input.slice(result.pos)}
4515
4538
  return result;
4516
4539
  }
4517
4540
  }
4518
- var ImplicitInlineObjectPropertyDelimiter$0 = $T($Y($S(EOS, NamedProperty)), function(value) {
4541
+ var ImplicitInlineObjectPropertyDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L23, fail, 'ImplicitInlineObjectPropertyDelimiter ","'));
4542
+ var ImplicitInlineObjectPropertyDelimiter$1 = $T($Y($S(EOS, NamedProperty)), function(value) {
4519
4543
  return ",";
4520
4544
  });
4521
- var ImplicitInlineObjectPropertyDelimiter$1 = $T($Y($S(__, $EXPECT($L26, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'))), function(value) {
4545
+ var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y($S(__, $C($EXPECT($L27, fail, 'ImplicitInlineObjectPropertyDelimiter ":"'), $EXPECT($L14, fail, 'ImplicitInlineObjectPropertyDelimiter ")"'), $EXPECT($L26, fail, 'ImplicitInlineObjectPropertyDelimiter "]"'), $EXPECT($L28, fail, 'ImplicitInlineObjectPropertyDelimiter "}"'), ReservedWord))), function(value) {
4522
4546
  return "";
4523
4547
  });
4524
- var ImplicitInlineObjectPropertyDelimiter$2 = $T($Y(EOS), function(value) {
4548
+ var ImplicitInlineObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
4525
4549
  return "";
4526
4550
  });
4527
4551
  function ImplicitInlineObjectPropertyDelimiter(state) {
@@ -4531,19 +4555,19 @@ ${input.slice(result.pos)}
4531
4555
  return result.cache;
4532
4556
  }
4533
4557
  if (state.tokenize) {
4534
- const result = $TOKEN("ImplicitInlineObjectPropertyDelimiter", state, ImplicitInlineObjectPropertyDelimiter$0(state) || ImplicitInlineObjectPropertyDelimiter$1(state) || ImplicitInlineObjectPropertyDelimiter$2(state));
4558
+ const result = $TOKEN("ImplicitInlineObjectPropertyDelimiter", state, ImplicitInlineObjectPropertyDelimiter$0(state) || ImplicitInlineObjectPropertyDelimiter$1(state) || ImplicitInlineObjectPropertyDelimiter$2(state) || ImplicitInlineObjectPropertyDelimiter$3(state));
4535
4559
  if (state.events)
4536
4560
  state.events.exit?.("ImplicitInlineObjectPropertyDelimiter", state, result);
4537
4561
  return result;
4538
4562
  } else {
4539
- const result = ImplicitInlineObjectPropertyDelimiter$0(state) || ImplicitInlineObjectPropertyDelimiter$1(state) || ImplicitInlineObjectPropertyDelimiter$2(state);
4563
+ const result = ImplicitInlineObjectPropertyDelimiter$0(state) || ImplicitInlineObjectPropertyDelimiter$1(state) || ImplicitInlineObjectPropertyDelimiter$2(state) || ImplicitInlineObjectPropertyDelimiter$3(state);
4540
4564
  if (state.events)
4541
4565
  state.events.exit?.("ImplicitInlineObjectPropertyDelimiter", state, result);
4542
4566
  return result;
4543
4567
  }
4544
4568
  }
4545
4569
  var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
4546
- var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L27, fail, 'ObjectPropertyDelimiter "}"')));
4570
+ var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L28, fail, 'ObjectPropertyDelimiter "}"')));
4547
4571
  var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
4548
4572
  return { $loc, token: "," };
4549
4573
  });
@@ -4820,7 +4844,7 @@ ${input.slice(result.pos)}
4820
4844
  return result;
4821
4845
  }
4822
4846
  }
4823
- var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L7, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
4847
+ var PrivateIdentifier$0 = $TV($TEXT($S($EXPECT($L6, fail, 'PrivateIdentifier "#"'), IdentifierName)), function($skip, $loc, $0, $1) {
4824
4848
  return {
4825
4849
  type: "Identifier",
4826
4850
  name: $0,
@@ -4876,25 +4900,25 @@ ${input.slice(result.pos)}
4876
4900
  return result;
4877
4901
  }
4878
4902
  }
4879
- var AssignmentOpSymbol$0 = $EXPECT($L28, fail, 'AssignmentOpSymbol "**="');
4880
- var AssignmentOpSymbol$1 = $EXPECT($L29, fail, 'AssignmentOpSymbol "*="');
4881
- var AssignmentOpSymbol$2 = $EXPECT($L30, fail, 'AssignmentOpSymbol "/="');
4882
- var AssignmentOpSymbol$3 = $EXPECT($L31, fail, 'AssignmentOpSymbol "%="');
4883
- var AssignmentOpSymbol$4 = $EXPECT($L32, fail, 'AssignmentOpSymbol "+="');
4884
- var AssignmentOpSymbol$5 = $EXPECT($L33, fail, 'AssignmentOpSymbol "-="');
4885
- var AssignmentOpSymbol$6 = $EXPECT($L34, fail, 'AssignmentOpSymbol "<<="');
4886
- var AssignmentOpSymbol$7 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>>="');
4887
- var AssignmentOpSymbol$8 = $EXPECT($L36, fail, 'AssignmentOpSymbol ">>="');
4888
- var AssignmentOpSymbol$9 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&&="');
4889
- var AssignmentOpSymbol$10 = $EXPECT($L38, fail, 'AssignmentOpSymbol "&="');
4890
- var AssignmentOpSymbol$11 = $EXPECT($L39, fail, 'AssignmentOpSymbol "^="');
4891
- var AssignmentOpSymbol$12 = $EXPECT($L40, fail, 'AssignmentOpSymbol "||="');
4892
- var AssignmentOpSymbol$13 = $EXPECT($L41, fail, 'AssignmentOpSymbol "|="');
4893
- var AssignmentOpSymbol$14 = $EXPECT($L42, fail, 'AssignmentOpSymbol "??="');
4894
- var AssignmentOpSymbol$15 = $T($EXPECT($L43, fail, 'AssignmentOpSymbol "?="'), function(value) {
4903
+ var AssignmentOpSymbol$0 = $EXPECT($L29, fail, 'AssignmentOpSymbol "**="');
4904
+ var AssignmentOpSymbol$1 = $EXPECT($L30, fail, 'AssignmentOpSymbol "*="');
4905
+ var AssignmentOpSymbol$2 = $EXPECT($L31, fail, 'AssignmentOpSymbol "/="');
4906
+ var AssignmentOpSymbol$3 = $EXPECT($L32, fail, 'AssignmentOpSymbol "%="');
4907
+ var AssignmentOpSymbol$4 = $EXPECT($L33, fail, 'AssignmentOpSymbol "+="');
4908
+ var AssignmentOpSymbol$5 = $EXPECT($L34, fail, 'AssignmentOpSymbol "-="');
4909
+ var AssignmentOpSymbol$6 = $EXPECT($L35, fail, 'AssignmentOpSymbol "<<="');
4910
+ var AssignmentOpSymbol$7 = $EXPECT($L36, fail, 'AssignmentOpSymbol ">>>="');
4911
+ var AssignmentOpSymbol$8 = $EXPECT($L37, fail, 'AssignmentOpSymbol ">>="');
4912
+ var AssignmentOpSymbol$9 = $EXPECT($L38, fail, 'AssignmentOpSymbol "&&="');
4913
+ var AssignmentOpSymbol$10 = $EXPECT($L39, fail, 'AssignmentOpSymbol "&="');
4914
+ var AssignmentOpSymbol$11 = $EXPECT($L40, fail, 'AssignmentOpSymbol "^="');
4915
+ var AssignmentOpSymbol$12 = $EXPECT($L41, fail, 'AssignmentOpSymbol "||="');
4916
+ var AssignmentOpSymbol$13 = $EXPECT($L42, fail, 'AssignmentOpSymbol "|="');
4917
+ var AssignmentOpSymbol$14 = $EXPECT($L43, fail, 'AssignmentOpSymbol "??="');
4918
+ var AssignmentOpSymbol$15 = $T($EXPECT($L44, fail, 'AssignmentOpSymbol "?="'), function(value) {
4895
4919
  return "??=";
4896
4920
  });
4897
- var AssignmentOpSymbol$16 = $EXPECT($L44, fail, 'AssignmentOpSymbol "="');
4921
+ var AssignmentOpSymbol$16 = $EXPECT($L24, fail, 'AssignmentOpSymbol "="');
4898
4922
  var AssignmentOpSymbol$17 = $T($S(CoffeeWordAssignmentOp), function(value) {
4899
4923
  return value[0];
4900
4924
  });
@@ -4975,63 +4999,72 @@ ${input.slice(result.pos)}
4975
4999
  var BinaryOpSymbol$9 = $EXPECT($L4, fail, 'BinaryOpSymbol "<"');
4976
5000
  var BinaryOpSymbol$10 = $EXPECT($L56, fail, 'BinaryOpSymbol ">>>"');
4977
5001
  var BinaryOpSymbol$11 = $EXPECT($L57, fail, 'BinaryOpSymbol ">>"');
4978
- var BinaryOpSymbol$12 = $EXPECT($L58, fail, 'BinaryOpSymbol ">"');
4979
- var BinaryOpSymbol$13 = $EXPECT($L59, fail, 'BinaryOpSymbol "!=="');
4980
- var BinaryOpSymbol$14 = $TV($EXPECT($L60, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
5002
+ var BinaryOpSymbol$12 = $EXPECT($L25, fail, 'BinaryOpSymbol ">"');
5003
+ var BinaryOpSymbol$13 = $EXPECT($L58, fail, 'BinaryOpSymbol "!=="');
5004
+ var BinaryOpSymbol$14 = $TV($EXPECT($L59, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
4981
5005
  if (module.config.coffeeEq)
4982
5006
  return "!==";
4983
5007
  return $1;
4984
5008
  });
4985
- var BinaryOpSymbol$15 = $TS($S($EXPECT($L61, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5009
+ var BinaryOpSymbol$15 = $TS($S($EXPECT($L60, fail, 'BinaryOpSymbol "isnt"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
4986
5010
  if (module.config.coffeeIsnt)
4987
5011
  return "!==";
4988
5012
  return $skip;
4989
5013
  });
4990
- var BinaryOpSymbol$16 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
5014
+ var BinaryOpSymbol$16 = $T($S($EXPECT($L61, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
4991
5015
  return "===";
4992
5016
  });
4993
- var BinaryOpSymbol$17 = $EXPECT($L63, fail, 'BinaryOpSymbol "==="');
4994
- var BinaryOpSymbol$18 = $TV($EXPECT($L64, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
5017
+ var BinaryOpSymbol$17 = $EXPECT($L62, fail, 'BinaryOpSymbol "==="');
5018
+ var BinaryOpSymbol$18 = $TV($EXPECT($L63, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
4995
5019
  if (module.config.coffeeEq)
4996
5020
  return "===";
4997
5021
  return $1;
4998
5022
  });
4999
- var BinaryOpSymbol$19 = $T($S($EXPECT($L65, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
5023
+ var BinaryOpSymbol$19 = $T($S($EXPECT($L64, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
5000
5024
  return "&&";
5001
5025
  });
5002
- var BinaryOpSymbol$20 = $EXPECT($L66, fail, 'BinaryOpSymbol "&&"');
5003
- var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($L67, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
5026
+ var BinaryOpSymbol$20 = $EXPECT($L65, fail, 'BinaryOpSymbol "&&"');
5027
+ var BinaryOpSymbol$21 = $T($S(CoffeeOfEnabled, $EXPECT($L66, fail, 'BinaryOpSymbol "of"'), NonIdContinue), function(value) {
5004
5028
  return "in";
5005
5029
  });
5006
- var BinaryOpSymbol$22 = $T($S($EXPECT($L68, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
5030
+ var BinaryOpSymbol$22 = $T($S($EXPECT($L67, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
5007
5031
  return "||";
5008
5032
  });
5009
- var BinaryOpSymbol$23 = $EXPECT($L69, fail, 'BinaryOpSymbol "||"');
5010
- var BinaryOpSymbol$24 = $EXPECT($L70, fail, 'BinaryOpSymbol "??"');
5011
- var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L71, fail, 'BinaryOpSymbol "?"')), function(value) {
5033
+ var BinaryOpSymbol$23 = $EXPECT($L68, fail, 'BinaryOpSymbol "||"');
5034
+ var BinaryOpSymbol$24 = $EXPECT($L69, fail, 'BinaryOpSymbol "??"');
5035
+ var BinaryOpSymbol$25 = $T($S(CoffeeBinaryExistentialEnabled, $EXPECT($L70, fail, 'BinaryOpSymbol "?"')), function(value) {
5012
5036
  return "??";
5013
5037
  });
5014
- var BinaryOpSymbol$26 = $TS($S($EXPECT($L72, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5038
+ var BinaryOpSymbol$26 = $TS($S($EXPECT($L71, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5015
5039
  return $1;
5016
5040
  });
5017
- var BinaryOpSymbol$27 = $TS($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
5041
+ var BinaryOpSymbol$27 = $TS($S(CoffeeNotEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L71, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
5042
+ return {
5043
+ $loc,
5044
+ token: "instanceof",
5045
+ special: true
5046
+ };
5047
+ });
5048
+ var BinaryOpSymbol$28 = $TS($S(CoffeeOfEnabled, $EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
5018
5049
  return {
5019
5050
  ref: module.getIndexOfRef(),
5020
- suffix: " >= 0"
5051
+ suffix: " >= 0",
5052
+ special: true
5021
5053
  };
5022
5054
  });
5023
- var BinaryOpSymbol$28 = $TS($S(CoffeeOfEnabled, $EXPECT($L74, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
5055
+ var BinaryOpSymbol$29 = $TS($S(CoffeeOfEnabled, $EXPECT($L72, fail, 'BinaryOpSymbol "not"'), NonIdContinue, __, $EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
5024
5056
  return {
5025
5057
  ref: module.getIndexOfRef(),
5026
- suffix: " < 0"
5058
+ suffix: " < 0",
5059
+ special: true
5027
5060
  };
5028
5061
  });
5029
- var BinaryOpSymbol$29 = $TS($S($EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5062
+ var BinaryOpSymbol$30 = $TS($S($EXPECT($L73, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
5030
5063
  return $1;
5031
5064
  });
5032
- var BinaryOpSymbol$30 = $EXPECT($L75, fail, 'BinaryOpSymbol "&"');
5033
- var BinaryOpSymbol$31 = $EXPECT($L76, fail, 'BinaryOpSymbol "^"');
5034
- var BinaryOpSymbol$32 = $EXPECT($L77, fail, 'BinaryOpSymbol "|"');
5065
+ var BinaryOpSymbol$31 = $EXPECT($L74, fail, 'BinaryOpSymbol "&"');
5066
+ var BinaryOpSymbol$32 = $EXPECT($L75, fail, 'BinaryOpSymbol "^"');
5067
+ var BinaryOpSymbol$33 = $EXPECT($L76, fail, 'BinaryOpSymbol "|"');
5035
5068
  function BinaryOpSymbol(state) {
5036
5069
  if (state.events) {
5037
5070
  const result = state.events.enter?.("BinaryOpSymbol", state);
@@ -5039,12 +5072,12 @@ ${input.slice(result.pos)}
5039
5072
  return result.cache;
5040
5073
  }
5041
5074
  if (state.tokenize) {
5042
- const result = $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) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state));
5075
+ const result = $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) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state));
5043
5076
  if (state.events)
5044
5077
  state.events.exit?.("BinaryOpSymbol", state, result);
5045
5078
  return result;
5046
5079
  } else {
5047
- const result = 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) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state);
5080
+ const result = 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) || BinaryOpSymbol$28(state) || BinaryOpSymbol$29(state) || BinaryOpSymbol$30(state) || BinaryOpSymbol$31(state) || BinaryOpSymbol$32(state) || BinaryOpSymbol$33(state);
5048
5081
  if (state.events)
5049
5082
  state.events.exit?.("BinaryOpSymbol", state, result);
5050
5083
  return result;
@@ -5170,7 +5203,7 @@ ${input.slice(result.pos)}
5170
5203
  return result;
5171
5204
  }
5172
5205
  }
5173
- var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L78, fail, 'EmptyStatement ";"'))), function(value) {
5206
+ var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L77, fail, 'EmptyStatement ";"'))), function(value) {
5174
5207
  return { "type": "EmptyStatement", "children": value[0] };
5175
5208
  });
5176
5209
  function EmptyStatement(state) {
@@ -5191,7 +5224,7 @@ ${input.slice(result.pos)}
5191
5224
  return result;
5192
5225
  }
5193
5226
  }
5194
- var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($L44, fail, 'BlockStatement "="')))), function(value) {
5227
+ var BlockStatement$0 = $T($S(ExplicitBlock, $N($S(__, $EXPECT($L24, fail, 'BlockStatement "="')))), function(value) {
5195
5228
  return value[0];
5196
5229
  });
5197
5230
  function BlockStatement(state) {
@@ -5489,7 +5522,16 @@ ${input.slice(result.pos)}
5489
5522
  return result;
5490
5523
  }
5491
5524
  }
5492
- var NestedBlockExpression$0 = $S(Nested, ExtendedExpression, ExpressionDelimiter);
5525
+ var NestedBlockExpression$0 = $TS($S(Nested, ExtendedExpression, $E($S($Q(TrailingComment), PostfixStatement)), ExpressionDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
5526
+ var ws = $1;
5527
+ var exp = $2;
5528
+ var post = $3;
5529
+ var d = $4;
5530
+ if (post) {
5531
+ return [ws, module.attachPostfixStatementAsExpression(exp, post), d];
5532
+ }
5533
+ return [ws, exp, d];
5534
+ });
5493
5535
  function NestedBlockExpression(state) {
5494
5536
  if (state.events) {
5495
5537
  const result = state.events.enter?.("NestedBlockExpression", state);
@@ -5984,7 +6026,7 @@ ${input.slice(result.pos)}
5984
6026
  return result;
5985
6027
  }
5986
6028
  }
5987
- var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L79, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
6029
+ var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L78, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
5988
6030
  var own = $1;
5989
6031
  var binding = $2;
5990
6032
  if (own) {
@@ -6405,7 +6447,7 @@ ${input.slice(result.pos)}
6405
6447
  return result;
6406
6448
  }
6407
6449
  }
6408
- var NoExpressions$0 = $T($EXPECT($L14, fail, 'NoExpressions ""'), function(value) {
6450
+ var NoExpressions$0 = $T($EXPECT($L13, fail, 'NoExpressions ""'), function(value) {
6409
6451
  return [];
6410
6452
  });
6411
6453
  function NoExpressions(state) {
@@ -6427,7 +6469,7 @@ ${input.slice(result.pos)}
6427
6469
  }
6428
6470
  }
6429
6471
  var ImpliedColon$0 = $S(__, Colon);
6430
- var ImpliedColon$1 = $TV($EXPECT($L14, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
6472
+ var ImpliedColon$1 = $TV($EXPECT($L13, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
6431
6473
  return { $loc, token: ":" };
6432
6474
  });
6433
6475
  function ImpliedColon(state) {
@@ -6521,7 +6563,7 @@ ${input.slice(result.pos)}
6521
6563
  return result;
6522
6564
  }
6523
6565
  }
6524
- var Finally$0 = $S(__, $EXPECT($L80, fail, 'Finally "finally"'), BracedBlock);
6566
+ var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
6525
6567
  function Finally(state) {
6526
6568
  if (state.events) {
6527
6569
  const result = state.events.enter?.("Finally", state);
@@ -6560,7 +6602,7 @@ ${input.slice(result.pos)}
6560
6602
  return result;
6561
6603
  }
6562
6604
  }
6563
- var Condition$0 = $T($S(ParenthesizedExpression, $N($S($Q(TrailingComment), $C(BinaryOp, AssignmentOp)))), function(value) {
6605
+ var Condition$0 = $T($S(ParenthesizedExpression, $N($S($Q(TrailingComment), $C(BinaryOp, AssignmentOp, Dot, QuestionMark)))), function(value) {
6564
6606
  return value[0];
6565
6607
  });
6566
6608
  var Condition$1 = $TS($S(InsertOpenParen, ExtendedExpression, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
@@ -6611,13 +6653,13 @@ ${input.slice(result.pos)}
6611
6653
  return result;
6612
6654
  }
6613
6655
  }
6614
- var KeywordStatement$0 = $T($S($EXPECT($L81, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
6656
+ var KeywordStatement$0 = $T($S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue), function(value) {
6615
6657
  return { "type": "BreakStatement", "children": value };
6616
6658
  });
6617
- var KeywordStatement$1 = $T($S($EXPECT($L82, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
6659
+ var KeywordStatement$1 = $T($S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue), function(value) {
6618
6660
  return { "type": "ContinueStatement", "children": value };
6619
6661
  });
6620
- var KeywordStatement$2 = $T($S($EXPECT($L83, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
6662
+ var KeywordStatement$2 = $T($S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue), function(value) {
6621
6663
  return { "type": "DebuggerStatement", "children": value };
6622
6664
  });
6623
6665
  var KeywordStatement$3 = $T($S(Return, $E(MaybeNestedExpression)), function(value) {
@@ -6644,7 +6686,7 @@ ${input.slice(result.pos)}
6644
6686
  return result;
6645
6687
  }
6646
6688
  }
6647
- var DebuggerExpression$0 = $TS($S($EXPECT($L83, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
6689
+ var DebuggerExpression$0 = $TS($S($EXPECT($L82, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
6648
6690
  return {
6649
6691
  type: "DebuggerExpression",
6650
6692
  children: ["(()=>{", $1, "})()"]
@@ -6716,7 +6758,7 @@ ${input.slice(result.pos)}
6716
6758
  return result;
6717
6759
  }
6718
6760
  }
6719
- var ImportDeclaration$0 = $T($S($EXPECT($L84, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
6761
+ var ImportDeclaration$0 = $T($S($EXPECT($L83, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
6720
6762
  return { "ts": true, "children": value };
6721
6763
  });
6722
6764
  var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -6750,7 +6792,7 @@ ${input.slice(result.pos)}
6750
6792
  return result;
6751
6793
  }
6752
6794
  }
6753
- var ImpliedImport$0 = $TV($EXPECT($L14, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
6795
+ var ImpliedImport$0 = $TV($EXPECT($L13, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
6754
6796
  return { $loc, token: "import " };
6755
6797
  });
6756
6798
  function ImpliedImport(state) {
@@ -7016,7 +7058,7 @@ ${input.slice(result.pos)}
7016
7058
  return result;
7017
7059
  }
7018
7060
  }
7019
- var ExportDeclaration$0 = $S(Export, __, $EXPECT($L85, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
7061
+ var ExportDeclaration$0 = $S(Export, __, $EXPECT($L84, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression));
7020
7062
  var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
7021
7063
  var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
7022
7064
  function ExportDeclaration(state) {
@@ -7148,6 +7190,8 @@ ${input.slice(result.pos)}
7148
7190
  var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
7149
7191
  var c = $1;
7150
7192
  var id = $2;
7193
+ var suffix = $3;
7194
+ var ws = $4;
7151
7195
  var ca = $5;
7152
7196
  var e = $6;
7153
7197
  c = {
@@ -7177,10 +7221,14 @@ ${input.slice(result.pos)}
7177
7221
  names: id.names
7178
7222
  };
7179
7223
  }
7224
+ let [splices, thisAssignments] = module.gatherBindingCode(id);
7225
+ splices = splices.map((s) => [", ", s]);
7226
+ thisAssignments = thisAssignments.map((a) => [";", a]);
7227
+ const children = [c, id, suffix, ...ws, ca, e, ...splices, ...thisAssignments];
7180
7228
  return {
7181
7229
  type: "Declaration",
7182
7230
  names: id.names,
7183
- children: $0
7231
+ children
7184
7232
  };
7185
7233
  });
7186
7234
  function LexicalDeclaration(state) {
@@ -7201,7 +7249,7 @@ ${input.slice(result.pos)}
7201
7249
  return result;
7202
7250
  }
7203
7251
  }
7204
- var ConstAssignment$0 = $TV($EXPECT($L86, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
7252
+ var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
7205
7253
  return { $loc, token: "=" };
7206
7254
  });
7207
7255
  function ConstAssignment(state) {
@@ -8205,7 +8253,7 @@ ${input.slice(result.pos)}
8205
8253
  return result;
8206
8254
  }
8207
8255
  }
8208
- var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L87, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L88, fail, 'JSMultiLineComment "*/"')), $EXPECT($R35, fail, "JSMultiLineComment /./"))), $EXPECT($L88, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
8256
+ var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L87, fail, 'JSMultiLineComment "*/"')), $EXPECT($R35, fail, "JSMultiLineComment /./"))), $EXPECT($L87, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
8209
8257
  return { $loc, token: $1 };
8210
8258
  });
8211
8259
  function JSMultiLineComment(state) {
@@ -8226,7 +8274,7 @@ ${input.slice(result.pos)}
8226
8274
  return result;
8227
8275
  }
8228
8276
  }
8229
- var CoffeeSingleLineComment$0 = $TR($EXPECT($R36, fail, "CoffeeSingleLineComment /#(?!##)([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
8277
+ var CoffeeSingleLineComment$0 = $TR($EXPECT($R36, fail, "CoffeeSingleLineComment /#(?!##(?!#))([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
8230
8278
  return { $loc, token: `//${$1}` };
8231
8279
  });
8232
8280
  function CoffeeSingleLineComment(state) {
@@ -8247,7 +8295,7 @@ ${input.slice(result.pos)}
8247
8295
  return result;
8248
8296
  }
8249
8297
  }
8250
- var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L89, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L89, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L88, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R35, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L89, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
8298
+ var CoffeeMultiLineComment$0 = $TS($S(CoffeeHereCommentStart, $TEXT($Q($S($N($C(CoffeeHereCommentStart, $EXPECT($L87, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R35, fail, "CoffeeMultiLineComment /./")))), CoffeeHereCommentStart), function($skip, $loc, $0, $1, $2, $3) {
8251
8299
  return { $loc, token: `/*${$2}*/` };
8252
8300
  });
8253
8301
  function CoffeeMultiLineComment(state) {
@@ -8268,7 +8316,26 @@ ${input.slice(result.pos)}
8268
8316
  return result;
8269
8317
  }
8270
8318
  }
8271
- var InlineComment$0 = $TV($TEXT($S($EXPECT($L87, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L88, fail, 'InlineComment "*/"')), $EXPECT($R37, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L88, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
8319
+ var CoffeeHereCommentStart$0 = $R$0($EXPECT($R37, fail, "CoffeeHereCommentStart /###(?!#)/"));
8320
+ function CoffeeHereCommentStart(state) {
8321
+ if (state.events) {
8322
+ const result = state.events.enter?.("CoffeeHereCommentStart", state);
8323
+ if (result)
8324
+ return result.cache;
8325
+ }
8326
+ if (state.tokenize) {
8327
+ const result = $TOKEN("CoffeeHereCommentStart", state, CoffeeHereCommentStart$0(state));
8328
+ if (state.events)
8329
+ state.events.exit?.("CoffeeHereCommentStart", state, result);
8330
+ return result;
8331
+ } else {
8332
+ const result = CoffeeHereCommentStart$0(state);
8333
+ if (state.events)
8334
+ state.events.exit?.("CoffeeHereCommentStart", state, result);
8335
+ return result;
8336
+ }
8337
+ }
8338
+ var InlineComment$0 = $TV($TEXT($S($EXPECT($L86, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L87, fail, 'InlineComment "*/"')), $EXPECT($R38, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L87, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
8272
8339
  return { $loc, token: $1 };
8273
8340
  });
8274
8341
  function InlineComment(state) {
@@ -8348,10 +8415,10 @@ ${input.slice(result.pos)}
8348
8415
  return result;
8349
8416
  }
8350
8417
  }
8351
- var NonNewlineWhitespace$0 = $TR($EXPECT($R38, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
8418
+ var NonNewlineWhitespace$0 = $TR($EXPECT($R39, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
8352
8419
  return { $loc, token: $0 };
8353
8420
  });
8354
- var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L90, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
8421
+ var NonNewlineWhitespace$1 = $T($S(CoffeeLineContinuationEnabled, $EXPECT($L88, fail, 'NonNewlineWhitespace "\\\\\\\\"'), EOL), function(value) {
8355
8422
  return "";
8356
8423
  });
8357
8424
  function NonNewlineWhitespace(state) {
@@ -8457,7 +8524,7 @@ ${input.slice(result.pos)}
8457
8524
  return result;
8458
8525
  }
8459
8526
  }
8460
- var NonIdContinue$0 = $R$0($EXPECT($R39, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
8527
+ var NonIdContinue$0 = $R$0($EXPECT($R40, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
8461
8528
  function NonIdContinue(state) {
8462
8529
  if (state.events) {
8463
8530
  const result = state.events.enter?.("NonIdContinue", state);
@@ -8476,7 +8543,7 @@ ${input.slice(result.pos)}
8476
8543
  return result;
8477
8544
  }
8478
8545
  }
8479
- var Loc$0 = $TV($EXPECT($L14, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
8546
+ var Loc$0 = $TV($EXPECT($L13, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
8480
8547
  return { $loc, token: "" };
8481
8548
  });
8482
8549
  function Loc(state) {
@@ -8497,7 +8564,7 @@ ${input.slice(result.pos)}
8497
8564
  return result;
8498
8565
  }
8499
8566
  }
8500
- var Ampersand$0 = $TV($EXPECT($L75, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
8567
+ var Ampersand$0 = $TV($EXPECT($L74, fail, 'Ampersand "&"'), function($skip, $loc, $0, $1) {
8501
8568
  return { $loc, token: $1 };
8502
8569
  });
8503
8570
  function Ampersand(state) {
@@ -8518,7 +8585,7 @@ ${input.slice(result.pos)}
8518
8585
  return result;
8519
8586
  }
8520
8587
  }
8521
- var As$0 = $TS($S($EXPECT($L91, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8588
+ var As$0 = $TS($S($EXPECT($L89, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8522
8589
  return { $loc, token: $1 };
8523
8590
  });
8524
8591
  function As(state) {
@@ -8539,7 +8606,7 @@ ${input.slice(result.pos)}
8539
8606
  return result;
8540
8607
  }
8541
8608
  }
8542
- var At$0 = $TV($EXPECT($L92, fail, 'At "@"'), function($skip, $loc, $0, $1) {
8609
+ var At$0 = $TV($EXPECT($L90, fail, 'At "@"'), function($skip, $loc, $0, $1) {
8543
8610
  return { $loc, token: $1 };
8544
8611
  });
8545
8612
  function At(state) {
@@ -8560,7 +8627,7 @@ ${input.slice(result.pos)}
8560
8627
  return result;
8561
8628
  }
8562
8629
  }
8563
- var Async$0 = $TV($EXPECT($L93, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
8630
+ var Async$0 = $TV($EXPECT($L91, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
8564
8631
  return { $loc, token: $1 };
8565
8632
  });
8566
8633
  function Async(state) {
@@ -8581,7 +8648,7 @@ ${input.slice(result.pos)}
8581
8648
  return result;
8582
8649
  }
8583
8650
  }
8584
- var Await$0 = $TS($S($EXPECT($L94, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8651
+ var Await$0 = $TS($S($EXPECT($L92, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8585
8652
  return { $loc, token: $1 };
8586
8653
  });
8587
8654
  function Await(state) {
@@ -8602,7 +8669,7 @@ ${input.slice(result.pos)}
8602
8669
  return result;
8603
8670
  }
8604
8671
  }
8605
- var Backtick$0 = $TV($EXPECT($L95, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
8672
+ var Backtick$0 = $TV($EXPECT($L93, fail, 'Backtick "`"'), function($skip, $loc, $0, $1) {
8606
8673
  return { $loc, token: $1 };
8607
8674
  });
8608
8675
  function Backtick(state) {
@@ -8623,7 +8690,7 @@ ${input.slice(result.pos)}
8623
8690
  return result;
8624
8691
  }
8625
8692
  }
8626
- var By$0 = $TS($S($EXPECT($L96, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8693
+ var By$0 = $TS($S($EXPECT($L94, fail, 'By "by"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8627
8694
  return { $loc, token: $1 };
8628
8695
  });
8629
8696
  function By(state) {
@@ -8644,7 +8711,7 @@ ${input.slice(result.pos)}
8644
8711
  return result;
8645
8712
  }
8646
8713
  }
8647
- var Case$0 = $TS($S($EXPECT($L97, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8714
+ var Case$0 = $TS($S($EXPECT($L95, fail, 'Case "case"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8648
8715
  return { $loc, token: $1 };
8649
8716
  });
8650
8717
  function Case(state) {
@@ -8665,7 +8732,7 @@ ${input.slice(result.pos)}
8665
8732
  return result;
8666
8733
  }
8667
8734
  }
8668
- var Catch$0 = $TV($EXPECT($L98, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
8735
+ var Catch$0 = $TV($EXPECT($L96, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
8669
8736
  return { $loc, token: $1 };
8670
8737
  });
8671
8738
  function Catch(state) {
@@ -8686,7 +8753,7 @@ ${input.slice(result.pos)}
8686
8753
  return result;
8687
8754
  }
8688
8755
  }
8689
- var Class$0 = $TV($EXPECT($L99, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
8756
+ var Class$0 = $TV($EXPECT($L97, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
8690
8757
  return { $loc, token: $1 };
8691
8758
  });
8692
8759
  function Class(state) {
@@ -8707,7 +8774,7 @@ ${input.slice(result.pos)}
8707
8774
  return result;
8708
8775
  }
8709
8776
  }
8710
- var CloseBrace$0 = $TV($EXPECT($L27, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
8777
+ var CloseBrace$0 = $TV($EXPECT($L28, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
8711
8778
  return { $loc, token: $1 };
8712
8779
  });
8713
8780
  function CloseBrace(state) {
@@ -8728,7 +8795,7 @@ ${input.slice(result.pos)}
8728
8795
  return result;
8729
8796
  }
8730
8797
  }
8731
- var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
8798
+ var CloseBracket$0 = $TV($EXPECT($L26, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
8732
8799
  return { $loc, token: $1 };
8733
8800
  });
8734
8801
  function CloseBracket(state) {
@@ -8749,7 +8816,7 @@ ${input.slice(result.pos)}
8749
8816
  return result;
8750
8817
  }
8751
8818
  }
8752
- var CloseParen$0 = $TV($EXPECT($L15, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
8819
+ var CloseParen$0 = $TV($EXPECT($L14, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
8753
8820
  return { $loc, token: $1 };
8754
8821
  });
8755
8822
  function CloseParen(state) {
@@ -8770,7 +8837,7 @@ ${input.slice(result.pos)}
8770
8837
  return result;
8771
8838
  }
8772
8839
  }
8773
- var CoffeeSubstitutionStart$0 = $TV($EXPECT($L100, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
8840
+ var CoffeeSubstitutionStart$0 = $TV($EXPECT($L98, fail, 'CoffeeSubstitutionStart "#{"'), function($skip, $loc, $0, $1) {
8774
8841
  return { $loc, token: "${" };
8775
8842
  });
8776
8843
  function CoffeeSubstitutionStart(state) {
@@ -8791,7 +8858,7 @@ ${input.slice(result.pos)}
8791
8858
  return result;
8792
8859
  }
8793
8860
  }
8794
- var Colon$0 = $TV($EXPECT($L26, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
8861
+ var Colon$0 = $TV($EXPECT($L27, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
8795
8862
  return { $loc, token: $1 };
8796
8863
  });
8797
8864
  function Colon(state) {
@@ -8812,7 +8879,7 @@ ${input.slice(result.pos)}
8812
8879
  return result;
8813
8880
  }
8814
8881
  }
8815
- var ConstructorShorthand$0 = $TV($EXPECT($L92, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
8882
+ var ConstructorShorthand$0 = $TV($EXPECT($L90, fail, 'ConstructorShorthand "@"'), function($skip, $loc, $0, $1) {
8816
8883
  return { $loc, token: "constructor" };
8817
8884
  });
8818
8885
  function ConstructorShorthand(state) {
@@ -8833,7 +8900,7 @@ ${input.slice(result.pos)}
8833
8900
  return result;
8834
8901
  }
8835
8902
  }
8836
- var Default$0 = $TS($S($EXPECT($L85, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8903
+ var Default$0 = $TS($S($EXPECT($L84, fail, 'Default "default"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8837
8904
  return { $loc, token: $1 };
8838
8905
  });
8839
8906
  function Default(state) {
@@ -8854,7 +8921,7 @@ ${input.slice(result.pos)}
8854
8921
  return result;
8855
8922
  }
8856
8923
  }
8857
- var Delete$0 = $TS($S($EXPECT($L101, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8924
+ var Delete$0 = $TS($S($EXPECT($L99, fail, 'Delete "delete"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8858
8925
  return { $loc, token: $1 };
8859
8926
  });
8860
8927
  function Delete(state) {
@@ -8875,7 +8942,7 @@ ${input.slice(result.pos)}
8875
8942
  return result;
8876
8943
  }
8877
8944
  }
8878
- var Do$0 = $TS($S($EXPECT($L102, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8945
+ var Do$0 = $TS($S($EXPECT($L100, fail, 'Do "do"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
8879
8946
  return { $loc, token: $1 };
8880
8947
  });
8881
8948
  function Do(state) {
@@ -8896,7 +8963,7 @@ ${input.slice(result.pos)}
8896
8963
  return result;
8897
8964
  }
8898
8965
  }
8899
- var Dot$0 = $TV($EXPECT($L8, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
8966
+ var Dot$0 = $TV($EXPECT($L7, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
8900
8967
  return { $loc, token: $1 };
8901
8968
  });
8902
8969
  function Dot(state) {
@@ -8917,7 +8984,7 @@ ${input.slice(result.pos)}
8917
8984
  return result;
8918
8985
  }
8919
8986
  }
8920
- var DotDot$0 = $TV($EXPECT($L103, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
8987
+ var DotDot$0 = $TV($EXPECT($L101, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
8921
8988
  return { $loc, token: $1 };
8922
8989
  });
8923
8990
  function DotDot(state) {
@@ -8938,7 +9005,7 @@ ${input.slice(result.pos)}
8938
9005
  return result;
8939
9006
  }
8940
9007
  }
8941
- var DotDotDot$0 = $TV($EXPECT($L104, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
9008
+ var DotDotDot$0 = $TV($EXPECT($L102, fail, 'DotDotDot "..."'), function($skip, $loc, $0, $1) {
8942
9009
  return { $loc, token: $1 };
8943
9010
  });
8944
9011
  function DotDotDot(state) {
@@ -8959,7 +9026,7 @@ ${input.slice(result.pos)}
8959
9026
  return result;
8960
9027
  }
8961
9028
  }
8962
- var DoubleColon$0 = $TV($EXPECT($L105, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
9029
+ var DoubleColon$0 = $TV($EXPECT($L103, fail, 'DoubleColon "::"'), function($skip, $loc, $0, $1) {
8963
9030
  return { $loc, token: $1 };
8964
9031
  });
8965
9032
  function DoubleColon(state) {
@@ -8980,7 +9047,7 @@ ${input.slice(result.pos)}
8980
9047
  return result;
8981
9048
  }
8982
9049
  }
8983
- var DoubleQuote$0 = $TV($EXPECT($L106, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
9050
+ var DoubleQuote$0 = $TV($EXPECT($L104, fail, 'DoubleQuote "\\\\\\""'), function($skip, $loc, $0, $1) {
8984
9051
  return { $loc, token: $1 };
8985
9052
  });
8986
9053
  function DoubleQuote(state) {
@@ -9001,7 +9068,7 @@ ${input.slice(result.pos)}
9001
9068
  return result;
9002
9069
  }
9003
9070
  }
9004
- var Else$0 = $TV($EXPECT($L107, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
9071
+ var Else$0 = $TV($EXPECT($L105, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
9005
9072
  return { $loc, token: $1 };
9006
9073
  });
9007
9074
  function Else(state) {
@@ -9022,7 +9089,7 @@ ${input.slice(result.pos)}
9022
9089
  return result;
9023
9090
  }
9024
9091
  }
9025
- var Equals$0 = $TV($EXPECT($L44, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
9092
+ var Equals$0 = $TV($EXPECT($L24, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
9026
9093
  return { $loc, token: $1 };
9027
9094
  });
9028
9095
  function Equals(state) {
@@ -9043,7 +9110,7 @@ ${input.slice(result.pos)}
9043
9110
  return result;
9044
9111
  }
9045
9112
  }
9046
- var Export$0 = $TS($S($EXPECT($L108, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9113
+ var Export$0 = $TS($S($EXPECT($L106, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9047
9114
  return { $loc, token: $1 };
9048
9115
  });
9049
9116
  function Export(state) {
@@ -9064,7 +9131,7 @@ ${input.slice(result.pos)}
9064
9131
  return result;
9065
9132
  }
9066
9133
  }
9067
- var For$0 = $TS($S($EXPECT($L109, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9134
+ var For$0 = $TS($S($EXPECT($L107, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9068
9135
  return { $loc, token: $1 };
9069
9136
  });
9070
9137
  function For(state) {
@@ -9085,7 +9152,7 @@ ${input.slice(result.pos)}
9085
9152
  return result;
9086
9153
  }
9087
9154
  }
9088
- var From$0 = $TS($S($EXPECT($L110, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9155
+ var From$0 = $TS($S($EXPECT($L108, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9089
9156
  return { $loc, token: $1 };
9090
9157
  });
9091
9158
  function From(state) {
@@ -9106,7 +9173,7 @@ ${input.slice(result.pos)}
9106
9173
  return result;
9107
9174
  }
9108
9175
  }
9109
- var Function$0 = $TV($EXPECT($L111, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
9176
+ var Function$0 = $TV($EXPECT($L109, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
9110
9177
  return { $loc, token: $1 };
9111
9178
  });
9112
9179
  function Function(state) {
@@ -9127,7 +9194,7 @@ ${input.slice(result.pos)}
9127
9194
  return result;
9128
9195
  }
9129
9196
  }
9130
- var GetOrSet$0 = $TS($S($C($EXPECT($L112, fail, 'GetOrSet "get"'), $EXPECT($L113, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9197
+ var GetOrSet$0 = $TS($S($C($EXPECT($L110, fail, 'GetOrSet "get"'), $EXPECT($L111, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9131
9198
  return { $loc, token: $1 };
9132
9199
  });
9133
9200
  function GetOrSet(state) {
@@ -9148,7 +9215,7 @@ ${input.slice(result.pos)}
9148
9215
  return result;
9149
9216
  }
9150
9217
  }
9151
- var If$0 = $TV($TEXT($S($EXPECT($L114, fail, 'If "if"'), $E($EXPECT($L3, fail, 'If " "')))), function($skip, $loc, $0, $1) {
9218
+ var If$0 = $TV($TEXT($S($EXPECT($L112, fail, 'If "if"'), $E($EXPECT($L3, fail, 'If " "')))), function($skip, $loc, $0, $1) {
9152
9219
  return { $loc, token: $1 };
9153
9220
  });
9154
9221
  function If(state) {
@@ -9169,7 +9236,7 @@ ${input.slice(result.pos)}
9169
9236
  return result;
9170
9237
  }
9171
9238
  }
9172
- var Import$0 = $TS($S($EXPECT($L10, fail, 'Import "import"'), $Y($EXPECT($R40, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
9239
+ var Import$0 = $TS($S($EXPECT($L9, fail, 'Import "import"'), $Y($EXPECT($R41, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
9173
9240
  return { $loc, token: $1 };
9174
9241
  });
9175
9242
  function Import(state) {
@@ -9211,7 +9278,7 @@ ${input.slice(result.pos)}
9211
9278
  return result;
9212
9279
  }
9213
9280
  }
9214
- var LetOrConst$0 = $TV($C($EXPECT($L115, fail, 'LetOrConst "let"'), $EXPECT($L116, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
9281
+ var LetOrConst$0 = $TV($C($EXPECT($L113, fail, 'LetOrConst "let"'), $EXPECT($L114, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
9215
9282
  return { $loc, token: $1 };
9216
9283
  });
9217
9284
  function LetOrConst(state) {
@@ -9232,7 +9299,7 @@ ${input.slice(result.pos)}
9232
9299
  return result;
9233
9300
  }
9234
9301
  }
9235
- var Loop$0 = $TS($S($EXPECT($L117, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9302
+ var Loop$0 = $TS($S($EXPECT($L115, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9236
9303
  return { $loc, token: "while(true)" };
9237
9304
  });
9238
9305
  function Loop(state) {
@@ -9253,7 +9320,7 @@ ${input.slice(result.pos)}
9253
9320
  return result;
9254
9321
  }
9255
9322
  }
9256
- var New$0 = $TV($EXPECT($L118, fail, 'New "new"'), function($skip, $loc, $0, $1) {
9323
+ var New$0 = $TV($EXPECT($L116, fail, 'New "new"'), function($skip, $loc, $0, $1) {
9257
9324
  return { $loc, token: $1 };
9258
9325
  });
9259
9326
  function New(state) {
@@ -9274,7 +9341,7 @@ ${input.slice(result.pos)}
9274
9341
  return result;
9275
9342
  }
9276
9343
  }
9277
- var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L74, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L3, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
9344
+ var Not$0 = $TS($S(CoffeeNotEnabled, $EXPECT($L72, fail, 'Not "not"'), NonIdContinue, $E($EXPECT($L3, fail, 'Not " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
9278
9345
  return { $loc, token: "!" };
9279
9346
  });
9280
9347
  function Not(state) {
@@ -9295,7 +9362,7 @@ ${input.slice(result.pos)}
9295
9362
  return result;
9296
9363
  }
9297
9364
  }
9298
- var Of$0 = $TV($EXPECT($L67, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
9365
+ var Of$0 = $TV($EXPECT($L66, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
9299
9366
  return { $loc, token: $1 };
9300
9367
  });
9301
9368
  function Of(state) {
@@ -9316,7 +9383,7 @@ ${input.slice(result.pos)}
9316
9383
  return result;
9317
9384
  }
9318
9385
  }
9319
- var OpenBrace$0 = $TV($EXPECT($L119, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
9386
+ var OpenBrace$0 = $TV($EXPECT($L117, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
9320
9387
  return { $loc, token: $1 };
9321
9388
  });
9322
9389
  function OpenBrace(state) {
@@ -9337,7 +9404,7 @@ ${input.slice(result.pos)}
9337
9404
  return result;
9338
9405
  }
9339
9406
  }
9340
- var OpenBracket$0 = $TV($EXPECT($L120, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
9407
+ var OpenBracket$0 = $TV($EXPECT($L118, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
9341
9408
  return { $loc, token: $1 };
9342
9409
  });
9343
9410
  function OpenBracket(state) {
@@ -9358,7 +9425,7 @@ ${input.slice(result.pos)}
9358
9425
  return result;
9359
9426
  }
9360
9427
  }
9361
- var OpenParen$0 = $TV($EXPECT($L121, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
9428
+ var OpenParen$0 = $TV($EXPECT($L119, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
9362
9429
  return { $loc, token: $1 };
9363
9430
  });
9364
9431
  function OpenParen(state) {
@@ -9379,7 +9446,7 @@ ${input.slice(result.pos)}
9379
9446
  return result;
9380
9447
  }
9381
9448
  }
9382
- var QuestionMark$0 = $TV($EXPECT($L71, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
9449
+ var QuestionMark$0 = $TV($EXPECT($L70, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
9383
9450
  return { $loc, token: $1 };
9384
9451
  });
9385
9452
  function QuestionMark(state) {
@@ -9400,7 +9467,7 @@ ${input.slice(result.pos)}
9400
9467
  return result;
9401
9468
  }
9402
9469
  }
9403
- var Return$0 = $TS($S($EXPECT($L122, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9470
+ var Return$0 = $TS($S($EXPECT($L120, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9404
9471
  return { $loc, token: $1 };
9405
9472
  });
9406
9473
  function Return(state) {
@@ -9421,7 +9488,7 @@ ${input.slice(result.pos)}
9421
9488
  return result;
9422
9489
  }
9423
9490
  }
9424
- var Semicolon$0 = $TV($EXPECT($L78, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
9491
+ var Semicolon$0 = $TV($EXPECT($L77, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
9425
9492
  return { $loc, token: $1 };
9426
9493
  });
9427
9494
  function Semicolon(state) {
@@ -9442,7 +9509,7 @@ ${input.slice(result.pos)}
9442
9509
  return result;
9443
9510
  }
9444
9511
  }
9445
- var SingleQuote$0 = $TV($EXPECT($L123, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
9512
+ var SingleQuote$0 = $TV($EXPECT($L121, fail, `SingleQuote "'"`), function($skip, $loc, $0, $1) {
9446
9513
  return { $loc, token: $1 };
9447
9514
  });
9448
9515
  function SingleQuote(state) {
@@ -9484,10 +9551,10 @@ ${input.slice(result.pos)}
9484
9551
  return result;
9485
9552
  }
9486
9553
  }
9487
- var Static$0 = $TV($EXPECT($L124, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
9554
+ var Static$0 = $TV($EXPECT($L122, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
9488
9555
  return { $loc, token: $1 };
9489
9556
  });
9490
- var Static$1 = $TS($S($EXPECT($L92, fail, 'Static "@"'), $N($EXPECT($L121, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
9557
+ var Static$1 = $TS($S($EXPECT($L90, fail, 'Static "@"'), $N($EXPECT($L119, fail, 'Static "("'))), function($skip, $loc, $0, $1, $2) {
9491
9558
  return { $loc, token: "static " };
9492
9559
  });
9493
9560
  function Static(state) {
@@ -9508,7 +9575,7 @@ ${input.slice(result.pos)}
9508
9575
  return result;
9509
9576
  }
9510
9577
  }
9511
- var SubstitutionStart$0 = $TV($EXPECT($L125, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
9578
+ var SubstitutionStart$0 = $TV($EXPECT($L123, fail, 'SubstitutionStart "${"'), function($skip, $loc, $0, $1) {
9512
9579
  return { $loc, token: $1 };
9513
9580
  });
9514
9581
  function SubstitutionStart(state) {
@@ -9529,7 +9596,7 @@ ${input.slice(result.pos)}
9529
9596
  return result;
9530
9597
  }
9531
9598
  }
9532
- var Switch$0 = $TS($S($EXPECT($L126, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9599
+ var Switch$0 = $TS($S($EXPECT($L124, fail, 'Switch "switch"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9533
9600
  return { $loc, token: $1 };
9534
9601
  });
9535
9602
  function Switch(state) {
@@ -9550,7 +9617,7 @@ ${input.slice(result.pos)}
9550
9617
  return result;
9551
9618
  }
9552
9619
  }
9553
- var Target$0 = $TV($EXPECT($L127, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
9620
+ var Target$0 = $TV($EXPECT($L125, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
9554
9621
  return { $loc, token: $1 };
9555
9622
  });
9556
9623
  function Target(state) {
@@ -9571,7 +9638,7 @@ ${input.slice(result.pos)}
9571
9638
  return result;
9572
9639
  }
9573
9640
  }
9574
- var Then$0 = $TS($S(__, $EXPECT($L128, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
9641
+ var Then$0 = $TS($S(__, $EXPECT($L126, fail, 'Then "then"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3) {
9575
9642
  return { $loc, token: "" };
9576
9643
  });
9577
9644
  function Then(state) {
@@ -9592,7 +9659,28 @@ ${input.slice(result.pos)}
9592
9659
  return result;
9593
9660
  }
9594
9661
  }
9595
- var Throw$0 = $TS($S($EXPECT($L129, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9662
+ var This$0 = $TS($S($EXPECT($L127, fail, 'This "this"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9663
+ return { $loc, token: $1 };
9664
+ });
9665
+ function This(state) {
9666
+ if (state.events) {
9667
+ const result = state.events.enter?.("This", state);
9668
+ if (result)
9669
+ return result.cache;
9670
+ }
9671
+ if (state.tokenize) {
9672
+ const result = $TOKEN("This", state, This$0(state));
9673
+ if (state.events)
9674
+ state.events.exit?.("This", state, result);
9675
+ return result;
9676
+ } else {
9677
+ const result = This$0(state);
9678
+ if (state.events)
9679
+ state.events.exit?.("This", state, result);
9680
+ return result;
9681
+ }
9682
+ }
9683
+ var Throw$0 = $TS($S($EXPECT($L128, fail, 'Throw "throw"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9596
9684
  return { $loc, token: $1 };
9597
9685
  });
9598
9686
  function Throw(state) {
@@ -9613,7 +9701,7 @@ ${input.slice(result.pos)}
9613
9701
  return result;
9614
9702
  }
9615
9703
  }
9616
- var TripleDoubleQuote$0 = $TV($EXPECT($L130, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
9704
+ var TripleDoubleQuote$0 = $TV($EXPECT($L129, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
9617
9705
  return { $loc, token: "`" };
9618
9706
  });
9619
9707
  function TripleDoubleQuote(state) {
@@ -9634,7 +9722,7 @@ ${input.slice(result.pos)}
9634
9722
  return result;
9635
9723
  }
9636
9724
  }
9637
- var TripleSingleQuote$0 = $TV($EXPECT($L131, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
9725
+ var TripleSingleQuote$0 = $TV($EXPECT($L130, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
9638
9726
  return { $loc, token: "`" };
9639
9727
  });
9640
9728
  function TripleSingleQuote(state) {
@@ -9655,7 +9743,7 @@ ${input.slice(result.pos)}
9655
9743
  return result;
9656
9744
  }
9657
9745
  }
9658
- var TripleSlash$0 = $TV($EXPECT($L132, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
9746
+ var TripleSlash$0 = $TV($EXPECT($L131, fail, 'TripleSlash "///"'), function($skip, $loc, $0, $1) {
9659
9747
  return { $loc, token: "/" };
9660
9748
  });
9661
9749
  function TripleSlash(state) {
@@ -9676,7 +9764,7 @@ ${input.slice(result.pos)}
9676
9764
  return result;
9677
9765
  }
9678
9766
  }
9679
- var TripleTick$0 = $TV($EXPECT($L133, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
9767
+ var TripleTick$0 = $TV($EXPECT($L132, fail, 'TripleTick "```"'), function($skip, $loc, $0, $1) {
9680
9768
  return { $loc, token: "`" };
9681
9769
  });
9682
9770
  function TripleTick(state) {
@@ -9697,7 +9785,7 @@ ${input.slice(result.pos)}
9697
9785
  return result;
9698
9786
  }
9699
9787
  }
9700
- var Try$0 = $TV($EXPECT($L134, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
9788
+ var Try$0 = $TV($EXPECT($L133, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
9701
9789
  return { $loc, token: $1 };
9702
9790
  });
9703
9791
  function Try(state) {
@@ -9718,7 +9806,7 @@ ${input.slice(result.pos)}
9718
9806
  return result;
9719
9807
  }
9720
9808
  }
9721
- var Typeof$0 = $TS($S($EXPECT($L135, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9809
+ var Typeof$0 = $TS($S($EXPECT($L134, fail, 'Typeof "typeof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9722
9810
  return { $loc, token: $1 };
9723
9811
  });
9724
9812
  function Typeof(state) {
@@ -9739,7 +9827,7 @@ ${input.slice(result.pos)}
9739
9827
  return result;
9740
9828
  }
9741
9829
  }
9742
- var Unless$0 = $TV($EXPECT($L136, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
9830
+ var Unless$0 = $TV($EXPECT($L135, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
9743
9831
  return { $loc, token: $1 };
9744
9832
  });
9745
9833
  function Unless(state) {
@@ -9760,7 +9848,7 @@ ${input.slice(result.pos)}
9760
9848
  return result;
9761
9849
  }
9762
9850
  }
9763
- var Until$0 = $TS($S($EXPECT($L137, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9851
+ var Until$0 = $TS($S($EXPECT($L136, fail, 'Until "until"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9764
9852
  return { $loc, token: $1 };
9765
9853
  });
9766
9854
  function Until(state) {
@@ -9781,7 +9869,7 @@ ${input.slice(result.pos)}
9781
9869
  return result;
9782
9870
  }
9783
9871
  }
9784
- var Var$0 = $TV($EXPECT($L138, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
9872
+ var Var$0 = $TV($EXPECT($L137, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
9785
9873
  return { $loc, token: $1 };
9786
9874
  });
9787
9875
  function Var(state) {
@@ -9802,7 +9890,7 @@ ${input.slice(result.pos)}
9802
9890
  return result;
9803
9891
  }
9804
9892
  }
9805
- var Void$0 = $TS($S($EXPECT($L139, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9893
+ var Void$0 = $TS($S($EXPECT($L138, fail, 'Void "void"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9806
9894
  return { $loc, token: $1 };
9807
9895
  });
9808
9896
  function Void(state) {
@@ -9823,7 +9911,7 @@ ${input.slice(result.pos)}
9823
9911
  return result;
9824
9912
  }
9825
9913
  }
9826
- var When$0 = $TS($S($EXPECT($L140, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9914
+ var When$0 = $TS($S($EXPECT($L139, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9827
9915
  return { $loc, token: "case" };
9828
9916
  });
9829
9917
  function When(state) {
@@ -9844,7 +9932,7 @@ ${input.slice(result.pos)}
9844
9932
  return result;
9845
9933
  }
9846
9934
  }
9847
- var While$0 = $TS($S($EXPECT($L141, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9935
+ var While$0 = $TS($S($EXPECT($L140, fail, 'While "while"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9848
9936
  return { $loc, token: $1 };
9849
9937
  });
9850
9938
  function While(state) {
@@ -9865,7 +9953,7 @@ ${input.slice(result.pos)}
9865
9953
  return result;
9866
9954
  }
9867
9955
  }
9868
- var Yield$0 = $TS($S($EXPECT($L142, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9956
+ var Yield$0 = $TS($S($EXPECT($L141, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
9869
9957
  return { $loc, token: $1 };
9870
9958
  });
9871
9959
  function Yield(state) {
@@ -9911,7 +9999,7 @@ ${input.slice(result.pos)}
9911
9999
  return result;
9912
10000
  }
9913
10001
  }
9914
- var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L143, fail, 'JSXSelfClosingElement "/>"'));
10002
+ var JSXSelfClosingElement$0 = $S($EXPECT($L4, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L142, fail, 'JSXSelfClosingElement "/>"'));
9915
10003
  function JSXSelfClosingElement(state) {
9916
10004
  if (state.events) {
9917
10005
  const result = state.events.enter?.("JSXSelfClosingElement", state);
@@ -9930,7 +10018,7 @@ ${input.slice(result.pos)}
9930
10018
  return result;
9931
10019
  }
9932
10020
  }
9933
- var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L58, fail, 'JSXOpeningElement ">"'));
10021
+ var JSXOpeningElement$0 = $S($EXPECT($L4, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L25, fail, 'JSXOpeningElement ">"'));
9934
10022
  function JSXOpeningElement(state) {
9935
10023
  if (state.events) {
9936
10024
  const result = state.events.enter?.("JSXOpeningElement", state);
@@ -9949,7 +10037,7 @@ ${input.slice(result.pos)}
9949
10037
  return result;
9950
10038
  }
9951
10039
  }
9952
- var JSXClosingElement$0 = $S($EXPECT($L144, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L58, fail, 'JSXClosingElement ">"'));
10040
+ var JSXClosingElement$0 = $S($EXPECT($L143, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L25, fail, 'JSXClosingElement ">"'));
9953
10041
  function JSXClosingElement(state) {
9954
10042
  if (state.events) {
9955
10043
  const result = state.events.enter?.("JSXClosingElement", state);
@@ -9968,7 +10056,7 @@ ${input.slice(result.pos)}
9968
10056
  return result;
9969
10057
  }
9970
10058
  }
9971
- var JSXFragment$0 = $S($EXPECT($L145, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L146, fail, 'JSXFragment "</>"'));
10059
+ var JSXFragment$0 = $S($EXPECT($L144, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L145, fail, 'JSXFragment "</>"'));
9972
10060
  function JSXFragment(state) {
9973
10061
  if (state.events) {
9974
10062
  const result = state.events.enter?.("JSXFragment", state);
@@ -10006,7 +10094,7 @@ ${input.slice(result.pos)}
10006
10094
  return result;
10007
10095
  }
10008
10096
  }
10009
- var JSXIdentifierName$0 = $R$0($EXPECT($R41, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
10097
+ var JSXIdentifierName$0 = $R$0($EXPECT($R42, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
10010
10098
  function JSXIdentifierName(state) {
10011
10099
  if (state.events) {
10012
10100
  const result = state.events.enter?.("JSXIdentifierName", state);
@@ -10102,8 +10190,8 @@ ${input.slice(result.pos)}
10102
10190
  return result;
10103
10191
  }
10104
10192
  }
10105
- var JSXAttributeValue$0 = $R$0($EXPECT($R42, fail, 'JSXAttributeValue /"[^"]*"/'));
10106
- var JSXAttributeValue$1 = $R$0($EXPECT($R43, fail, "JSXAttributeValue /'[^']*'/"));
10193
+ var JSXAttributeValue$0 = $R$0($EXPECT($R43, fail, 'JSXAttributeValue /"[^"]*"/'));
10194
+ var JSXAttributeValue$1 = $R$0($EXPECT($R44, fail, "JSXAttributeValue /'[^']*'/"));
10107
10195
  var JSXAttributeValue$2 = $S(OpenBrace, ExtendedExpression, __, CloseBrace);
10108
10196
  var JSXAttributeValue$3 = JSXElement;
10109
10197
  var JSXAttributeValue$4 = JSXFragment;
@@ -10166,7 +10254,7 @@ ${input.slice(result.pos)}
10166
10254
  return result;
10167
10255
  }
10168
10256
  }
10169
- var JSXText$0 = $R$0($EXPECT($R44, fail, "JSXText /[^{}<>]+/"));
10257
+ var JSXText$0 = $R$0($EXPECT($R45, fail, "JSXText /[^{}<>]+/"));
10170
10258
  function JSXText(state) {
10171
10259
  if (state.events) {
10172
10260
  const result = state.events.enter?.("JSXText", state);
@@ -10225,7 +10313,7 @@ ${input.slice(result.pos)}
10225
10313
  return result;
10226
10314
  }
10227
10315
  }
10228
- var TypeDeclarationModifier$0 = $S($EXPECT($L147, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
10316
+ var TypeDeclarationModifier$0 = $S($EXPECT($L146, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
10229
10317
  var TypeDeclarationModifier$1 = Export;
10230
10318
  function TypeDeclarationModifier(state) {
10231
10319
  if (state.events) {
@@ -10267,7 +10355,7 @@ ${input.slice(result.pos)}
10267
10355
  return result;
10268
10356
  }
10269
10357
  }
10270
- var TypeKeyword$0 = $S($EXPECT($L148, fail, 'TypeKeyword "type"'), NonIdContinue);
10358
+ var TypeKeyword$0 = $S($EXPECT($L147, fail, 'TypeKeyword "type"'), NonIdContinue);
10271
10359
  function TypeKeyword(state) {
10272
10360
  if (state.events) {
10273
10361
  const result = state.events.enter?.("TypeKeyword", state);
@@ -10286,7 +10374,7 @@ ${input.slice(result.pos)}
10286
10374
  return result;
10287
10375
  }
10288
10376
  }
10289
- var Interface$0 = $S($EXPECT($L149, fail, 'Interface "interface"'), NonIdContinue);
10377
+ var Interface$0 = $S($EXPECT($L148, fail, 'Interface "interface"'), NonIdContinue);
10290
10378
  function Interface(state) {
10291
10379
  if (state.events) {
10292
10380
  const result = state.events.enter?.("Interface", state);
@@ -10305,7 +10393,7 @@ ${input.slice(result.pos)}
10305
10393
  return result;
10306
10394
  }
10307
10395
  }
10308
- var Namespace$0 = $S($EXPECT($L150, fail, 'Namespace "namespace"'), NonIdContinue);
10396
+ var Namespace$0 = $S($EXPECT($L149, fail, 'Namespace "namespace"'), NonIdContinue);
10309
10397
  function Namespace(state) {
10310
10398
  if (state.events) {
10311
10399
  const result = state.events.enter?.("Namespace", state);
@@ -10494,7 +10582,7 @@ ${input.slice(result.pos)}
10494
10582
  return result;
10495
10583
  }
10496
10584
  }
10497
- var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R45, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L151, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R46, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
10585
+ var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R46, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L150, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R47, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
10498
10586
  function TypeIndexSignature(state) {
10499
10587
  if (state.events) {
10500
10588
  const result = state.events.enter?.("TypeIndexSignature", state);
@@ -10554,7 +10642,7 @@ ${input.slice(result.pos)}
10554
10642
  return result;
10555
10643
  }
10556
10644
  }
10557
- var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L152, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
10645
+ var ReturnTypeSuffix$0 = $TS($S(__, Colon, $E($S(__, $EXPECT($L151, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
10558
10646
  const children = [...$1, $2];
10559
10647
  if ($3)
10560
10648
  children.push($3);
@@ -10583,7 +10671,7 @@ ${input.slice(result.pos)}
10583
10671
  return result;
10584
10672
  }
10585
10673
  }
10586
- var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L62, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
10674
+ var TypePredicate$0 = $TS($S(Type, $E($S(__, $EXPECT($L61, fail, 'TypePredicate "is"'), NonIdContinue, Type))), function($skip, $loc, $0, $1, $2) {
10587
10675
  if (!$2)
10588
10676
  return $1;
10589
10677
  return $0;
@@ -10689,9 +10777,9 @@ ${input.slice(result.pos)}
10689
10777
  return result;
10690
10778
  }
10691
10779
  }
10692
- var TypeUnaryOp$0 = $EXPECT($L153, fail, 'TypeUnaryOp "keyof"');
10693
- var TypeUnaryOp$1 = $EXPECT($L135, fail, 'TypeUnaryOp "typeof"');
10694
- var TypeUnaryOp$2 = $EXPECT($L154, fail, 'TypeUnaryOp "infer"');
10780
+ var TypeUnaryOp$0 = $EXPECT($L152, fail, 'TypeUnaryOp "keyof"');
10781
+ var TypeUnaryOp$1 = $EXPECT($L134, fail, 'TypeUnaryOp "typeof"');
10782
+ var TypeUnaryOp$2 = $EXPECT($L153, fail, 'TypeUnaryOp "infer"');
10695
10783
  function TypeUnaryOp(state) {
10696
10784
  if (state.events) {
10697
10785
  const result = state.events.enter?.("TypeUnaryOp", state);
@@ -10859,10 +10947,10 @@ ${input.slice(result.pos)}
10859
10947
  }
10860
10948
  }
10861
10949
  var TypeLiteral$0 = Literal;
10862
- var TypeLiteral$1 = $TV($EXPECT($L139, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
10950
+ var TypeLiteral$1 = $TV($EXPECT($L138, fail, 'TypeLiteral "void"'), function($skip, $loc, $0, $1) {
10863
10951
  return { $loc, token: "void" };
10864
10952
  });
10865
- var TypeLiteral$2 = $TV($EXPECT($L155, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
10953
+ var TypeLiteral$2 = $TV($EXPECT($L154, fail, 'TypeLiteral "[]"'), function($skip, $loc, $0, $1) {
10866
10954
  return { $loc, token: "[]" };
10867
10955
  });
10868
10956
  function TypeLiteral(state) {
@@ -10883,10 +10971,10 @@ ${input.slice(result.pos)}
10883
10971
  return result;
10884
10972
  }
10885
10973
  }
10886
- var TypeBinaryOp$0 = $TV($EXPECT($L77, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
10974
+ var TypeBinaryOp$0 = $TV($EXPECT($L76, fail, 'TypeBinaryOp "|"'), function($skip, $loc, $0, $1) {
10887
10975
  return { $loc, token: "|" };
10888
10976
  });
10889
- var TypeBinaryOp$1 = $TV($EXPECT($L75, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
10977
+ var TypeBinaryOp$1 = $TV($EXPECT($L74, fail, 'TypeBinaryOp "&"'), function($skip, $loc, $0, $1) {
10890
10978
  return { $loc, token: "&" };
10891
10979
  });
10892
10980
  function TypeBinaryOp(state) {
@@ -10926,7 +11014,7 @@ ${input.slice(result.pos)}
10926
11014
  return result;
10927
11015
  }
10928
11016
  }
10929
- var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L58, fail, 'TypeArguments ">"'));
11017
+ var TypeArguments$0 = $S(__, $EXPECT($L4, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L25, fail, 'TypeArguments ">"'));
10930
11018
  function TypeArguments(state) {
10931
11019
  if (state.events) {
10932
11020
  const result = state.events.enter?.("TypeArguments", state);
@@ -10945,7 +11033,7 @@ ${input.slice(result.pos)}
10945
11033
  return result;
10946
11034
  }
10947
11035
  }
10948
- var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L58, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
11036
+ var TypeParameters$0 = $TS($S(__, $EXPECT($L4, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L25, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
10949
11037
  return { ts: true, children: $0 };
10950
11038
  });
10951
11039
  function TypeParameters(state) {
@@ -11005,8 +11093,8 @@ ${input.slice(result.pos)}
11005
11093
  }
11006
11094
  }
11007
11095
  var TypeParameterDelimiter$0 = $S($Q(_), Comma);
11008
- var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L58, fail, 'TypeParameterDelimiter ">"')));
11009
- var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L58, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
11096
+ var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L25, fail, 'TypeParameterDelimiter ">"')));
11097
+ var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L25, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
11010
11098
  return { $loc, token: "," };
11011
11099
  });
11012
11100
  var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -11030,7 +11118,7 @@ ${input.slice(result.pos)}
11030
11118
  return result;
11031
11119
  }
11032
11120
  }
11033
- var Shebang$0 = $S($R$0($EXPECT($R47, fail, "Shebang /#![^\\r\\n]*/")), EOL);
11121
+ var Shebang$0 = $S($R$0($EXPECT($R48, fail, "Shebang /#![^\\r\\n]*/")), EOL);
11034
11122
  function Shebang(state) {
11035
11123
  if (state.events) {
11036
11124
  const result = state.events.enter?.("Shebang", state);
@@ -11049,11 +11137,11 @@ ${input.slice(result.pos)}
11049
11137
  return result;
11050
11138
  }
11051
11139
  }
11052
- var CivetPrologue$0 = $T($S($EXPECT($R48, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
11140
+ var CivetPrologue$0 = $T($S($EXPECT($R49, fail, "CivetPrologue /[\\t ]*/"), DoubleQuote, CivetPrologueContent, DoubleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
11053
11141
  var content = value[2];
11054
11142
  return content;
11055
11143
  });
11056
- var CivetPrologue$1 = $T($S($EXPECT($R48, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
11144
+ var CivetPrologue$1 = $T($S($EXPECT($R49, fail, "CivetPrologue /[\\t ]*/"), SingleQuote, CivetPrologueContent, SingleQuote, $TEXT(StatementDelimiter), EOS), function(value) {
11057
11145
  var content = value[2];
11058
11146
  return content;
11059
11147
  });
@@ -11075,7 +11163,7 @@ ${input.slice(result.pos)}
11075
11163
  return result;
11076
11164
  }
11077
11165
  }
11078
- var CivetPrologueContent$0 = $TS($S($EXPECT($L156, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R49, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
11166
+ var CivetPrologueContent$0 = $TS($S($EXPECT($L155, fail, 'CivetPrologueContent "civet"'), $Q(CivetOption), $EXPECT($R50, fail, "CivetPrologueContent /[\\s]*/")), function($skip, $loc, $0, $1, $2, $3) {
11079
11167
  var options = $2;
11080
11168
  return {
11081
11169
  type: "CivetPrologue",
@@ -11101,7 +11189,7 @@ ${input.slice(result.pos)}
11101
11189
  return result;
11102
11190
  }
11103
11191
  }
11104
- var CivetOption$0 = $TR($EXPECT($R50, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
11192
+ var CivetOption$0 = $TR($EXPECT($R51, fail, "CivetOption /\\s+([+-]?)([a-zA-Z0-9-]+)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
11105
11193
  const optionName = $2.replace(/-+([a-z]?)/g, (_2, l) => {
11106
11194
  if (l)
11107
11195
  return l.toUpperCase();
@@ -11128,7 +11216,7 @@ ${input.slice(result.pos)}
11128
11216
  return result;
11129
11217
  }
11130
11218
  }
11131
- var UnknownPrologue$0 = $S($R$0($EXPECT($R48, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
11219
+ var UnknownPrologue$0 = $S($R$0($EXPECT($R49, fail, "UnknownPrologue /[\\t ]*/")), BasicStringLiteral, $TEXT(StatementDelimiter), EOS);
11132
11220
  function UnknownPrologue(state) {
11133
11221
  if (state.events) {
11134
11222
  const result = state.events.enter?.("UnknownPrologue", state);
@@ -11186,7 +11274,7 @@ ${input.slice(result.pos)}
11186
11274
  return result;
11187
11275
  }
11188
11276
  }
11189
- var EOL$0 = $TR($EXPECT($R51, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
11277
+ var EOL$0 = $TR($EXPECT($R52, fail, "EOL /\\r\\n|\\n|\\r|$/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
11190
11278
  return { $loc, token: $0 };
11191
11279
  });
11192
11280
  function EOL(state) {
@@ -11207,7 +11295,7 @@ ${input.slice(result.pos)}
11207
11295
  return result;
11208
11296
  }
11209
11297
  }
11210
- var Debugger$0 = $TV($EXPECT($L14, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
11298
+ var Debugger$0 = $TV($EXPECT($L13, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
11211
11299
  debugger;
11212
11300
  });
11213
11301
  function Debugger(state) {
@@ -11228,7 +11316,7 @@ ${input.slice(result.pos)}
11228
11316
  return result;
11229
11317
  }
11230
11318
  }
11231
- var InsertOpenParen$0 = $TV($EXPECT($L14, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
11319
+ var InsertOpenParen$0 = $TV($EXPECT($L13, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
11232
11320
  return { $loc, token: "(" };
11233
11321
  });
11234
11322
  function InsertOpenParen(state) {
@@ -11249,7 +11337,7 @@ ${input.slice(result.pos)}
11249
11337
  return result;
11250
11338
  }
11251
11339
  }
11252
- var InsertCloseParen$0 = $TV($EXPECT($L14, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
11340
+ var InsertCloseParen$0 = $TV($EXPECT($L13, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
11253
11341
  return { $loc, token: ")" };
11254
11342
  });
11255
11343
  function InsertCloseParen(state) {
@@ -11270,7 +11358,7 @@ ${input.slice(result.pos)}
11270
11358
  return result;
11271
11359
  }
11272
11360
  }
11273
- var InsertOpenBrace$0 = $TV($EXPECT($L14, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
11361
+ var InsertOpenBrace$0 = $TV($EXPECT($L13, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
11274
11362
  return [{ $loc, token: " " }, { $loc, token: "{" }];
11275
11363
  });
11276
11364
  function InsertOpenBrace(state) {
@@ -11291,7 +11379,7 @@ ${input.slice(result.pos)}
11291
11379
  return result;
11292
11380
  }
11293
11381
  }
11294
- var InsertCloseBrace$0 = $TV($EXPECT($L14, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
11382
+ var InsertCloseBrace$0 = $TV($EXPECT($L13, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
11295
11383
  return { $loc, token: "}" };
11296
11384
  });
11297
11385
  function InsertCloseBrace(state) {
@@ -11312,7 +11400,7 @@ ${input.slice(result.pos)}
11312
11400
  return result;
11313
11401
  }
11314
11402
  }
11315
- var InsertConst$0 = $TV($EXPECT($L14, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
11403
+ var InsertConst$0 = $TV($EXPECT($L13, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
11316
11404
  return { $loc, token: "const " };
11317
11405
  });
11318
11406
  function InsertConst(state) {
@@ -11333,7 +11421,7 @@ ${input.slice(result.pos)}
11333
11421
  return result;
11334
11422
  }
11335
11423
  }
11336
- var InsertReadonly$0 = $TV($EXPECT($L14, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
11424
+ var InsertReadonly$0 = $TV($EXPECT($L13, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
11337
11425
  return { ts: true, children: [{ $loc, token: "readonly " }] };
11338
11426
  });
11339
11427
  function InsertReadonly(state) {
@@ -11354,7 +11442,7 @@ ${input.slice(result.pos)}
11354
11442
  return result;
11355
11443
  }
11356
11444
  }
11357
- var InsertNewline$0 = $TV($EXPECT($L14, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
11445
+ var InsertNewline$0 = $TV($EXPECT($L13, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
11358
11446
  return "\n";
11359
11447
  });
11360
11448
  function InsertNewline(state) {
@@ -11375,7 +11463,7 @@ ${input.slice(result.pos)}
11375
11463
  return result;
11376
11464
  }
11377
11465
  }
11378
- var InsertIndent$0 = $TV($EXPECT($L14, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
11466
+ var InsertIndent$0 = $TV($EXPECT($L13, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
11379
11467
  return module.currentIndent.token;
11380
11468
  });
11381
11469
  function InsertIndent(state) {
@@ -11396,7 +11484,7 @@ ${input.slice(result.pos)}
11396
11484
  return result;
11397
11485
  }
11398
11486
  }
11399
- var InsertSpace$0 = $TV($EXPECT($L14, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
11487
+ var InsertSpace$0 = $TV($EXPECT($L13, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
11400
11488
  return { $loc, token: " " };
11401
11489
  });
11402
11490
  function InsertSpace(state) {
@@ -11417,7 +11505,7 @@ ${input.slice(result.pos)}
11417
11505
  return result;
11418
11506
  }
11419
11507
  }
11420
- var InsertDot$0 = $TV($EXPECT($L14, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
11508
+ var InsertDot$0 = $TV($EXPECT($L13, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
11421
11509
  return { $loc, token: "." };
11422
11510
  });
11423
11511
  function InsertDot(state) {
@@ -11438,7 +11526,7 @@ ${input.slice(result.pos)}
11438
11526
  return result;
11439
11527
  }
11440
11528
  }
11441
- var InsertBreak$0 = $TV($EXPECT($L14, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
11529
+ var InsertBreak$0 = $TV($EXPECT($L13, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
11442
11530
  return { $loc, token: ";break;" };
11443
11531
  });
11444
11532
  function InsertBreak(state) {
@@ -11459,7 +11547,7 @@ ${input.slice(result.pos)}
11459
11547
  return result;
11460
11548
  }
11461
11549
  }
11462
- var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
11550
+ var CoffeeBinaryExistentialEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeBinaryExistentialEnabled ""'), function($skip, $loc, $0, $1) {
11463
11551
  if (module.config.coffeeBinaryExistential)
11464
11552
  return;
11465
11553
  return $skip;
@@ -11482,7 +11570,7 @@ ${input.slice(result.pos)}
11482
11570
  return result;
11483
11571
  }
11484
11572
  }
11485
- var CoffeeBooleansEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
11573
+ var CoffeeBooleansEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeBooleansEnabled ""'), function($skip, $loc, $0, $1) {
11486
11574
  if (module.config.coffeeBooleans)
11487
11575
  return;
11488
11576
  return $skip;
@@ -11505,7 +11593,7 @@ ${input.slice(result.pos)}
11505
11593
  return result;
11506
11594
  }
11507
11595
  }
11508
- var CoffeeClassesEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
11596
+ var CoffeeClassesEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeClassesEnabled ""'), function($skip, $loc, $0, $1) {
11509
11597
  if (module.config.coffeeClasses)
11510
11598
  return;
11511
11599
  return $skip;
@@ -11528,7 +11616,7 @@ ${input.slice(result.pos)}
11528
11616
  return result;
11529
11617
  }
11530
11618
  }
11531
- var CoffeeCommentEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
11619
+ var CoffeeCommentEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeCommentEnabled ""'), function($skip, $loc, $0, $1) {
11532
11620
  if (module.config.coffeeComment)
11533
11621
  return;
11534
11622
  return $skip;
@@ -11551,7 +11639,7 @@ ${input.slice(result.pos)}
11551
11639
  return result;
11552
11640
  }
11553
11641
  }
11554
- var CoffeeDoEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
11642
+ var CoffeeDoEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeDoEnabled ""'), function($skip, $loc, $0, $1) {
11555
11643
  if (module.config.coffeeDo)
11556
11644
  return;
11557
11645
  return $skip;
@@ -11574,7 +11662,7 @@ ${input.slice(result.pos)}
11574
11662
  return result;
11575
11663
  }
11576
11664
  }
11577
- var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
11665
+ var CoffeeForLoopsEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeForLoopsEnabled ""'), function($skip, $loc, $0, $1) {
11578
11666
  if (module.config.coffeeForLoops)
11579
11667
  return;
11580
11668
  return $skip;
@@ -11597,7 +11685,7 @@ ${input.slice(result.pos)}
11597
11685
  return result;
11598
11686
  }
11599
11687
  }
11600
- var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
11688
+ var CoffeeInterpolationEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeInterpolationEnabled ""'), function($skip, $loc, $0, $1) {
11601
11689
  if (module.config.coffeeInterpolation)
11602
11690
  return;
11603
11691
  return $skip;
@@ -11620,7 +11708,7 @@ ${input.slice(result.pos)}
11620
11708
  return result;
11621
11709
  }
11622
11710
  }
11623
- var CoffeeIsntEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
11711
+ var CoffeeIsntEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeIsntEnabled ""'), function($skip, $loc, $0, $1) {
11624
11712
  if (module.config.coffeeIsnt)
11625
11713
  return;
11626
11714
  return $skip;
@@ -11643,7 +11731,7 @@ ${input.slice(result.pos)}
11643
11731
  return result;
11644
11732
  }
11645
11733
  }
11646
- var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
11734
+ var CoffeeLineContinuationEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeLineContinuationEnabled ""'), function($skip, $loc, $0, $1) {
11647
11735
  if (module.config.coffeeLineContinuation)
11648
11736
  return;
11649
11737
  return $skip;
@@ -11666,7 +11754,7 @@ ${input.slice(result.pos)}
11666
11754
  return result;
11667
11755
  }
11668
11756
  }
11669
- var CoffeeNotEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
11757
+ var CoffeeNotEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeNotEnabled ""'), function($skip, $loc, $0, $1) {
11670
11758
  if (module.config.coffeeNot)
11671
11759
  return;
11672
11760
  return $skip;
@@ -11689,7 +11777,7 @@ ${input.slice(result.pos)}
11689
11777
  return result;
11690
11778
  }
11691
11779
  }
11692
- var CoffeeOfEnabled$0 = $TV($EXPECT($L14, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
11780
+ var CoffeeOfEnabled$0 = $TV($EXPECT($L13, fail, 'CoffeeOfEnabled ""'), function($skip, $loc, $0, $1) {
11693
11781
  if (module.config.coffeeOf)
11694
11782
  return;
11695
11783
  return $skip;
@@ -11712,7 +11800,7 @@ ${input.slice(result.pos)}
11712
11800
  return result;
11713
11801
  }
11714
11802
  }
11715
- var Reset$0 = $TV($EXPECT($L14, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
11803
+ var Reset$0 = $TV($EXPECT($L13, fail, 'Reset ""'), function($skip, $loc, $0, $1) {
11716
11804
  module.indentLevels = [{
11717
11805
  level: 0,
11718
11806
  token: ""
@@ -11842,7 +11930,7 @@ ${input.slice(result.pos)}
11842
11930
  return result;
11843
11931
  }
11844
11932
  }
11845
- var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L14, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
11933
+ var Init$0 = $TS($S($E(Shebang), $Q(DirectivePrologue), $EXPECT($L13, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
11846
11934
  var directives = $2;
11847
11935
  directives.forEach((directive) => {
11848
11936
  if (directive.type === "CivetPrologue") {
@@ -11926,6 +12014,7 @@ ${input.slice(result.pos)}
11926
12014
  case "BlockStatement":
11927
12015
  insertPush(node.expressions[node.expressions.length - 1], ref);
11928
12016
  return;
12017
+ case "ObjectBindingPattern":
11929
12018
  case "ObjectExpression":
11930
12019
  module.insertTrimmingSpace(node.children[0], "");
11931
12020
  node.children.unshift(ref, ".push(");
@@ -12000,6 +12089,7 @@ ${input.slice(result.pos)}
12000
12089
  case "BlockStatement":
12001
12090
  insertReturn(node.expressions[node.expressions.length - 1]);
12002
12091
  return;
12092
+ case "ObjectBindingPattern":
12003
12093
  case "ObjectExpression":
12004
12094
  module.insertTrimmingSpace(node.children[0], "");
12005
12095
  node.children.unshift("return ");
@@ -12075,13 +12165,20 @@ ${input.slice(result.pos)}
12075
12165
  let i = 2;
12076
12166
  while (i < expandedOps.length) {
12077
12167
  const op = expandedOps[i];
12078
- if (op.ref) {
12168
+ if (op.special) {
12079
12169
  let [a, wsOp, op2, wsB, b] = expandedOps.slice(i - 2, i + 3);
12080
- wsOp = module.insertTrimmingSpace(wsOp, "");
12081
- wsB = module.insertTrimmingSpace(wsB, "");
12170
+ let children;
12171
+ if (op2.ref) {
12172
+ wsOp = module.insertTrimmingSpace(wsOp, "");
12173
+ wsB = module.insertTrimmingSpace(wsB, "");
12174
+ children = [wsOp, op2.ref, ".call(", wsB, b, ", ", a, ")", op2.suffix];
12175
+ } else if (op2.token === "instanceof") {
12176
+ children = ["!(", a, wsOp, op2, wsB, b, ")"];
12177
+ } else {
12178
+ throw new Error("Unknown operator: " + JSON.stringify(op2));
12179
+ }
12082
12180
  expandedOps.splice(i - 2, 5, {
12083
- type: "Call",
12084
- children: [wsOp, op2.ref, ".call(", wsB, b, ", ", a, ")", op2.suffix]
12181
+ children
12085
12182
  });
12086
12183
  } else {
12087
12184
  i += 4;
@@ -12288,7 +12385,6 @@ ${input.slice(result.pos)}
12288
12385
  return nodes;
12289
12386
  }
12290
12387
  function processParams(f) {
12291
- processAtParams(f);
12292
12388
  const { parameters, block } = f;
12293
12389
  if (!block)
12294
12390
  return;
@@ -12302,44 +12398,22 @@ ${input.slice(result.pos)}
12302
12398
  } else {
12303
12399
  indent = expressions[0][0];
12304
12400
  }
12305
- const thisAssignments = [];
12306
- const splices = [];
12307
- function insertRestSplices(s, p, thisAssignments2) {
12308
- gatherRecursiveAll(s, (n) => n.blockPrefix).forEach(({ blockPrefix: blockPrefix2 }) => {
12309
- p.push([indent, blockPrefix2, ";\n"]);
12310
- gatherRecursiveAll(blockPrefix2, (n) => n.type === "AtBinding").map(({ ref }) => {
12311
- const { base: name } = ref;
12312
- thisAssignments2.push([indent, [`this.${name} = `, ref], ";\n"]);
12313
- });
12314
- insertRestSplices(blockPrefix2, p, thisAssignments2);
12315
- });
12316
- return p;
12317
- }
12318
- insertRestSplices(parameters, splices, thisAssignments);
12319
- expressions.unshift(...splices, ...thisAssignments);
12401
+ const [splices, thisAssignments] = gatherBindingCode(parameters);
12402
+ const prefix = splices.map((s) => ["let ", s]).concat(thisAssignments).map((s) => [indent, s, ";\n"]);
12403
+ expressions.unshift(...prefix);
12320
12404
  }
12321
- function processAtParams(f) {
12322
- const { parameters, block } = f;
12323
- if (!block)
12324
- return;
12325
- const { expressions } = block;
12326
- if (!expressions)
12327
- return;
12328
- let indent;
12329
- if (expressions.length === 0) {
12330
- indent = "";
12331
- } else {
12332
- indent = expressions[0][0];
12333
- }
12334
- const thisAssignments = gatherRecursiveAll(parameters, (n) => n.type === "AtBinding").map(({ ref }) => {
12335
- const { base: name } = ref;
12336
- return [indent, [`this.${name} = `, ref], ";\n"];
12337
- });
12338
- block.expressions.unshift(...thisAssignments);
12339
- }
12340
- function adjustAtBindings(statements) {
12405
+ function adjustAtBindings(statements, asThis = false) {
12341
12406
  gatherRecursiveAll(statements, (n) => n.type === "AtBindingProperty").forEach((binding) => {
12342
12407
  const { ref } = binding;
12408
+ if (asThis) {
12409
+ const atBinding = binding.children[0];
12410
+ atBinding.children.pop();
12411
+ atBinding.type = void 0;
12412
+ binding.children.unshift(ref.base, ": this.", ref.base);
12413
+ binding.type = "Property";
12414
+ binding.ref = void 0;
12415
+ return;
12416
+ }
12343
12417
  if (ref.names[0] !== ref.base) {
12344
12418
  binding.children.unshift(ref.base, ": ");
12345
12419
  }
@@ -12379,16 +12453,21 @@ ${input.slice(result.pos)}
12379
12453
  });
12380
12454
  }
12381
12455
  }
12456
+ function processBindingPatternLHS(lhs, tail) {
12457
+ adjustAtBindings(lhs, true);
12458
+ const [splices, thisAssignments] = module.gatherBindingCode(lhs);
12459
+ tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
12460
+ }
12382
12461
  function processAssignments(statements) {
12383
12462
  gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
12384
- let $02 = exp.children, [$12, $22] = $02, tail = [], i = 0, len = $12.length;
12463
+ let { lhs: $12, exp: $22 } = exp, tail = [], i = 0, len = $12.length;
12385
12464
  let wrapped = false;
12386
12465
  while (i < len) {
12387
12466
  const lastAssignment = $12[i++];
12388
12467
  const [, lhs, , op] = lastAssignment;
12389
12468
  if (op.token !== "=")
12390
12469
  continue;
12391
- if (lhs.type === "ObjectExpression") {
12470
+ if (lhs.type === "ObjectExpression" || lhs.type === "ObjectBindingPattern") {
12392
12471
  if (!wrapped) {
12393
12472
  wrapped = true;
12394
12473
  lhs.children.splice(0, 0, "(");
@@ -12427,33 +12506,8 @@ ${input.slice(result.pos)}
12427
12506
  return;
12428
12507
  }
12429
12508
  }
12430
- } else if (lhs.type === "ObjectExpression") {
12431
- const spreadIndex = lhs.children.findIndex((child) => child.type === "SpreadProperty"), hasSpread = spreadIndex >= 0;
12432
- if (hasSpread) {
12433
- const len2 = lhs.children.length, after = lhs.children.splice(spreadIndex + 1, len2 - spreadIndex - 2);
12434
- if (after.length) {
12435
- if (after.some((child) => child.type === "SpreadProperty")) {
12436
- throw new Error("Cannot have multiple spread properties in object destructuring");
12437
- }
12438
- const lastAfterChildren = after[after.length - 1].children, afterDelimiter = lastAfterChildren.pop(), spread = lhs.children[spreadIndex], spreadDelimiter = spread.children.pop();
12439
- spread.children.push(afterDelimiter);
12440
- lastAfterChildren.push(spreadDelimiter);
12441
- lhs.children.splice(spreadIndex, 0, ...after);
12442
- }
12443
- }
12444
- } else if (lhs.type === "ArrayExpression") {
12445
- const spreadIndex = lhs.children.findIndex((child) => child.type === "SpreadElement"), hasSpread = spreadIndex >= 0;
12446
- if (hasSpread) {
12447
- const len2 = lhs.children.length, after = lhs.children.splice(spreadIndex + 1, len2 - spreadIndex - 2);
12448
- if (after.length) {
12449
- if (after.some((child) => child.type === "SpreadElement")) {
12450
- throw new Error("Cannot have multiple spread elements in array destructuring");
12451
- }
12452
- const spread = lhs.children[spreadIndex], spreadDelimiter = spread.children.pop();
12453
- const spliceRef = module.getSpliceRef();
12454
- tail.push(["\n[", after, "] = ", spliceRef, ".call(", spread.names[0], ", -", after.length.toString(), ")"]);
12455
- }
12456
- }
12509
+ } else if (lhs.type === "ObjectBindingPattern" || lhs.type === "ArrayBindingPattern") {
12510
+ processBindingPatternLHS(lhs, tail);
12457
12511
  }
12458
12512
  }
12459
12513
  i--;
@@ -12477,6 +12531,24 @@ ${input.slice(result.pos)}
12477
12531
  module.prelude.push(["", ["const ", spliceRef, typeSuffix, " = [].splice", asAny, "\n"]]);
12478
12532
  }
12479
12533
  }
12534
+ module.attachPostfixStatementAsExpression = function(exp, post) {
12535
+ let clause;
12536
+ switch (post[1].type) {
12537
+ case "IterationStatement":
12538
+ case "ForStatement":
12539
+ clause = module.addPostfixStatement(exp, ...post);
12540
+ return {
12541
+ type: "IterationExpression",
12542
+ children: [clause],
12543
+ block: clause.block
12544
+ };
12545
+ case "IfStatement":
12546
+ clause = module.expressionizeIfClause(post[1], exp);
12547
+ return clause;
12548
+ default:
12549
+ throw new Error("Unknown postfix statement");
12550
+ }
12551
+ };
12480
12552
  module.processProgram = function(statements) {
12481
12553
  processAssignments(statements);
12482
12554
  processFunctions(statements);
@@ -12535,16 +12607,13 @@ ${input.slice(result.pos)}
12535
12607
  return scopes.some((s) => s.has(name));
12536
12608
  }
12537
12609
  function findAssignments(statements2, decs2) {
12538
- const assignmentStatements = gatherNodes(statements2, (node) => {
12610
+ let assignmentStatements2 = gatherNodes(statements2, (node) => {
12539
12611
  return node.type === "AssignmentExpression";
12540
12612
  });
12541
- const undeclaredIdentifiers = assignmentStatements.flatMap((a) => {
12542
- return a.names;
12543
- });
12544
- return undeclaredIdentifiers.filter((x, i, a) => {
12545
- if (!hasDec(x))
12546
- return a.indexOf(x) === i;
12547
- });
12613
+ if (assignmentStatements2.length) {
12614
+ assignmentStatements2 = assignmentStatements2.concat(findAssignments(assignmentStatements2.map((s) => s.children), decs2));
12615
+ }
12616
+ return assignmentStatements2;
12548
12617
  }
12549
12618
  if (!pushVar) {
12550
12619
  pushVar = function(name) {
@@ -12555,7 +12624,14 @@ ${input.slice(result.pos)}
12555
12624
  const decs = findDecs(statements);
12556
12625
  scopes.push(decs);
12557
12626
  const varIds = [];
12558
- findAssignments(statements, scopes).forEach(pushVar);
12627
+ const assignmentStatements = findAssignments(statements, scopes);
12628
+ const undeclaredIdentifiers = assignmentStatements.flatMap((a) => {
12629
+ return a.names;
12630
+ });
12631
+ undeclaredIdentifiers.filter((x, i, a) => {
12632
+ if (!hasDec(x))
12633
+ return a.indexOf(x) === i;
12634
+ }).forEach(pushVar);
12559
12635
  const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
12560
12636
  const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
12561
12637
  const blockNodes = new Set(gatherNodes(statements, (s) => s.type === "BlockStatement"));
@@ -12581,6 +12657,25 @@ ${input.slice(result.pos)}
12581
12657
  statements.unshift([indent, "var ", varIds.join(", "), "\n"]);
12582
12658
  }
12583
12659
  }
12660
+ function gatherBindingCode(statements) {
12661
+ const thisAssignments = [];
12662
+ const splices = [];
12663
+ function insertRestSplices(s, p, thisAssignments2) {
12664
+ gatherRecursiveAll(s, (n) => n.blockPrefix || n.type === "AtBinding").forEach((n) => {
12665
+ if (n.type === "AtBinding") {
12666
+ const { ref } = n, { base: name } = ref;
12667
+ thisAssignments2.push([`this.${name} = `, ref]);
12668
+ return;
12669
+ }
12670
+ const { blockPrefix } = n;
12671
+ p.push(blockPrefix);
12672
+ insertRestSplices(blockPrefix, p, thisAssignments2);
12673
+ });
12674
+ }
12675
+ insertRestSplices(statements, splices, thisAssignments);
12676
+ return [splices, thisAssignments];
12677
+ }
12678
+ module.gatherBindingCode = gatherBindingCode;
12584
12679
  return $0;
12585
12680
  });
12586
12681
  function Init(state) {
@@ -12601,7 +12696,7 @@ ${input.slice(result.pos)}
12601
12696
  return result;
12602
12697
  }
12603
12698
  }
12604
- var Indent$0 = $TV($Q($C($EXPECT($L157, fail, 'Indent " "'), $EXPECT($L158, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
12699
+ var Indent$0 = $TV($Q($C($EXPECT($L156, fail, 'Indent " "'), $EXPECT($L157, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
12605
12700
  const level = $1.length;
12606
12701
  return {
12607
12702
  $loc,
@@ -12726,7 +12821,7 @@ ${input.slice(result.pos)}
12726
12821
  return result;
12727
12822
  }
12728
12823
  }
12729
- var PopIndent$0 = $TV($EXPECT($L14, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
12824
+ var PopIndent$0 = $TV($EXPECT($L13, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
12730
12825
  if (module.verbose) {
12731
12826
  console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
12732
12827
  }