@danielx/civet 0.4.0 → 0.4.1

package/dist/main.js

@@ -408,9 +408,13 @@ var require_parser = __commonJS({
       TopLevelStatement,
       Expression,
       Arguments,
+      ArgumentsWithTrailingCallExpressions,
       ArgumentList,
       NestedArgumentList,
       NestedArgument,
+      ImplicitApplication,
+      ApplicationStart,
+      IndentedApplicationAllowed,
       CommaExpression,
       BinaryOpExpression,
       UnaryExpression,
@@ -444,8 +448,6 @@ var require_parser = __commonJS({
       CallExpressionRest,
       OptionalShorthand,
       NonNullAssertion,
-      SpacedApplication,
-      ApplicationStart,
       AdditionalReservedWords,
       MemberExpression,
       MemberExpressionRest,
@@ -459,8 +461,12 @@ var require_parser = __commonJS({
       BindingPattern,
       ObjectBindingPattern,
       ArrayBindingPattern,
+      NestedBindingProperties,
+      NestedBindingProperty,
       BindingProperty,
       BindingRestProperty,
+      NestedBindingElements,
+      NestedBindingElement,
       BindingElement,
       BindingRestElement,
       FunctionDeclaration,
@@ -489,6 +495,7 @@ var require_parser = __commonJS({
       ArrayElementExpression,
       Elision,
       ObjectLiteral,
+      NestedObjectLiteral,
       NestedPropertyDefinitions,
       NestedPropertyDefinition,
       ObjectPropertyDelimiter,
@@ -500,12 +507,6 @@ var require_parser = __commonJS({
       MethodSignature,
       ClassElementName,
       PrivateIdentifier,
-      GeneratorMethod,
-      GeneratorBody,
-      AsyncMethod,
-      AsyncFunctionBody,
-      AsyncGeneratorMethod,
-      AsyncGeneratorBody,
       AssignmentOp,
       AssignmentOpSymbol,
       BinaryOp,
@@ -526,7 +527,6 @@ var require_parser = __commonJS({
       ForStatement,
       ForInOfStatement,
       ForDeclaration,
-      LetOrConst,
       ForBinding,
       SwitchStatement,
       CaseBlock,
@@ -540,6 +540,8 @@ var require_parser = __commonJS({
       Finally,
       CatchParameter,
       Condition,
+      ExpressionWithIndentedApplicationSuppressed,
+      SuppressIndentedApplication,
       ExpressionStatement,
       KeywordStatement,
       MaybeNestedExpression,
@@ -620,9 +622,11 @@ var require_parser = __commonJS({
       For,
       From,
       Function,
+      GetOrSet,
       If,
       Import,
       In,
+      LetOrConst,
       Loop,
       New,
       Of,
@@ -711,38 +715,41 @@ var require_parser = __commonJS({
       InsertBreak,
       Init,
       Indent,
+      TrackIndent,
+      RestoreIndent,
+      Samedent,
+      IndentedFurther,
       PushIndent,
       PopIndent,
-      Nested,
-      NestedFurther
-    });
-    var $L0 = $L("++");
-    var $L1 = $L("--");
-    var $L2 = $L("yield");
-    var $L3 = $L("*");
-    var $L4 = $L("=>");
-    var $L5 = $L("<");
-    var $L6 = $L("extends");
-    var $L7 = $L("this");
-    var $L8 = $L("#");
-    var $L9 = $L("@");
-    var $L10 = $L("super");
-    var $L11 = $L("import");
-    var $L12 = $L("!");
-    var $L13 = $L("::");
-    var $L14 = $L("super[");
-    var $L15 = $L("import.meta");
-    var $L16 = $L("");
-    var $L17 = $L(")");
-    var $L18 = $L("...");
-    var $L19 = $L("->");
-    var $L20 = $L("null");
-    var $L21 = $L("true");
-    var $L22 = $L("false");
-    var $L23 = $L(",");
-    var $L24 = $L("]");
-    var $L25 = $L("get");
-    var $L26 = $L("set");
+      Nested
+    });
+    var $L0 = $L("`");
+    var $L1 = $L("");
+    var $L2 = $L("++");
+    var $L3 = $L("--");
+    var $L4 = $L("yield");
+    var $L5 = $L("*");
+    var $L6 = $L("=>");
+    var $L7 = $L("<");
+    var $L8 = $L("extends");
+    var $L9 = $L("this");
+    var $L10 = $L("#");
+    var $L11 = $L("@");
+    var $L12 = $L("super");
+    var $L13 = $L("import");
+    var $L14 = $L("!");
+    var $L15 = $L("::");
+    var $L16 = $L("super[");
+    var $L17 = $L("import.meta");
+    var $L18 = $L(")");
+    var $L19 = $L("...");
+    var $L20 = $L("->");
+    var $L21 = $L("null");
+    var $L22 = $L("true");
+    var $L23 = $L("false");
+    var $L24 = $L(",");
+    var $L25 = $L("]");
+    var $L26 = $L("}");
     var $L27 = $L("**=");
     var $L28 = $L("*=");
     var $L29 = $L("/=");
@@ -793,38 +800,38 @@ var require_parser = __commonJS({
     var $L74 = $L("do");
     var $L75 = $L("while");
     var $L76 = $L("until");
-    var $L77 = $L("let");
-    var $L78 = $L("const");
-    var $L79 = $L("case");
-    var $L80 = $L("default");
-    var $L81 = $L("finally");
-    var $L82 = $L("break");
-    var $L83 = $L("continue");
-    var $L84 = $L("debugger");
-    var $L85 = $L("throw");
-    var $L86 = $L("import type");
-    var $L87 = $L(":=");
-    var $L88 = $L('"');
-    var $L89 = $L("'");
-    var $L90 = $L("`");
-    var $L91 = $L("${");
-    var $L92 = $L("/*");
-    var $L93 = $L("*/");
-    var $L94 = $L("###");
-    var $L95 = $L("as");
-    var $L96 = $L("async");
-    var $L97 = $L("await");
-    var $L98 = $L("catch");
-    var $L99 = $L("class");
-    var $L100 = $L("}");
-    var $L101 = $L(":");
-    var $L102 = $L(".");
-    var $L103 = $L("else");
-    var $L104 = $L("export");
-    var $L105 = $L("for");
-    var $L106 = $L("from");
-    var $L107 = $L("function");
-    var $L108 = $L("if");
+    var $L77 = $L("case");
+    var $L78 = $L("default");
+    var $L79 = $L("finally");
+    var $L80 = $L("break");
+    var $L81 = $L("continue");
+    var $L82 = $L("debugger");
+    var $L83 = $L("throw");
+    var $L84 = $L("import type");
+    var $L85 = $L(":=");
+    var $L86 = $L('"');
+    var $L87 = $L("'");
+    var $L88 = $L("${");
+    var $L89 = $L("/*");
+    var $L90 = $L("*/");
+    var $L91 = $L("###");
+    var $L92 = $L("as");
+    var $L93 = $L("async");
+    var $L94 = $L("await");
+    var $L95 = $L("catch");
+    var $L96 = $L("class");
+    var $L97 = $L(":");
+    var $L98 = $L(".");
+    var $L99 = $L("else");
+    var $L100 = $L("export");
+    var $L101 = $L("for");
+    var $L102 = $L("from");
+    var $L103 = $L("function");
+    var $L104 = $L("get");
+    var $L105 = $L("set");
+    var $L106 = $L("if");
+    var $L107 = $L("let");
+    var $L108 = $L("const");
     var $L109 = $L("loop");
     var $L110 = $L("new");
     var $L111 = $L("of");
@@ -925,17 +932,30 @@ var require_parser = __commonJS({
       }
     }
     var Arguments$0 = $S(OpenParen, $E(ArgumentList), $E($S(__, Comma)), __, CloseParen);
+    var Arguments$1 = ImplicitApplication;
     function Arguments(state) {
+      if (state.tokenize) {
+        return $TOKEN("Arguments", state, Arguments$0(state) || Arguments$1(state));
+      } else {
+        return Arguments$0(state) || Arguments$1(state);
+      }
+    }
+    var ArgumentsWithTrailingCallExpressions$0 = $TS($S(TrackIndent, $C($S(Arguments, $Q($S($Y(EOS), Samedent, $N($EXPECT($L0, fail, 'ArgumentsWithTrailingCallExpressions "`"')), CallExpressionRest)), RestoreIndent), RestoreIndent)), function($skip, $loc, $0, $1, $2) {
+      if (!$2)
+        return $skip;
+      return $2;
+    });
+    function ArgumentsWithTrailingCallExpressions(state) {
       if (state.verbose)
-        console.log("ENTER:", "Arguments");
+        console.log("ENTER:", "ArgumentsWithTrailingCallExpressions");
       if (state.tokenize) {
-        return $TOKEN("Arguments", state, Arguments$0(state));
+        return $TOKEN("ArgumentsWithTrailingCallExpressions", state, ArgumentsWithTrailingCallExpressions$0(state));
       } else {
-        return Arguments$0(state);
+        return ArgumentsWithTrailingCallExpressions$0(state);
       }
     }
     var ArgumentList$0 = $S($Y(EOS), NestedArgumentList);
-    var ArgumentList$1 = $S(__, Expression, $Q(CommaExpression));
+    var ArgumentList$1 = $S(Expression, $Q(CommaExpression));
     function ArgumentList(state) {
       if (state.tokenize) {
         return $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state));
@@ -968,7 +988,44 @@ var require_parser = __commonJS({
         return NestedArgument$0(state);
       }
     }
-    var CommaExpression$0 = $S(__, Comma, __, Expression);
+    var ImplicitApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
+    function ImplicitApplication(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ImplicitApplication");
+      if (state.tokenize) {
+        return $TOKEN("ImplicitApplication", state, ImplicitApplication$0(state));
+      } else {
+        return ImplicitApplication$0(state);
+      }
+    }
+    var ApplicationStart$0 = $TS($S($N(EOS), _, $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
+      var spacing = $2;
+      spacing[0].token = spacing[0].token.replace(/^ ?/, "(");
+      return spacing;
+    });
+    var ApplicationStart$1 = $S(IndentedApplicationAllowed, $Y(NestedObjectLiteral), InsertOpenParen);
+    function ApplicationStart(state) {
+      if (state.tokenize) {
+        return $TOKEN("ApplicationStart", state, ApplicationStart$0(state) || ApplicationStart$1(state));
+      } else {
+        return ApplicationStart$0(state) || ApplicationStart$1(state);
+      }
+    }
+    var IndentedApplicationAllowed$0 = $TV($EXPECT($L1, fail, 'IndentedApplicationAllowed ""'), function($skip, $loc, $0, $1) {
+      if (module2.suppressIndentedApplication)
+        return $skip;
+      return;
+    });
+    function IndentedApplicationAllowed(state) {
+      if (state.verbose)
+        console.log("ENTER:", "IndentedApplicationAllowed");
+      if (state.tokenize) {
+        return $TOKEN("IndentedApplicationAllowed", state, IndentedApplicationAllowed$0(state));
+      } else {
+        return IndentedApplicationAllowed$0(state);
+      }
+    }
+    var CommaExpression$0 = $S(__, Comma, Expression);
     function CommaExpression(state) {
       if (state.verbose)
         console.log("ENTER:", "CommaExpression");
@@ -1026,7 +1083,7 @@ var require_parser = __commonJS({
         return UpdateExpression$0(state) || UpdateExpression$1(state);
       }
     }
-    var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L0, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L1, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
+    var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L2, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L3, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function UpdateExpressionSymbol(state) {
@@ -1069,7 +1126,7 @@ var require_parser = __commonJS({
         return AwaitExpression$0(state);
       }
     }
-    var YieldExpression$0 = $S($EXPECT($L2, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L3, fail, 'YieldExpression "*"'))), AssignmentExpression);
+    var YieldExpression$0 = $S($EXPECT($L4, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L5, fail, 'YieldExpression "*"'))), AssignmentExpression);
     function YieldExpression(state) {
       if (state.verbose)
         console.log("ENTER:", "YieldExpression");
@@ -1088,7 +1145,7 @@ var require_parser = __commonJS({
         return ArrowFunction$0(state) || ArrowFunction$1(state);
       }
     }
-    var FatArrow$0 = $TS($S(__, $EXPECT($L4, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
+    var FatArrow$0 = $TS($S(__, $EXPECT($L6, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
       var ws = $1;
       if (!ws.length)
         return " =>";
@@ -1104,15 +1161,7 @@ var require_parser = __commonJS({
       }
     }
     var FatArrowBody$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
-    var FatArrowBody$1 = $TS($S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-      var eos = $2;
-      var exps = $3;
-      if (exps.length == 1) {
-        exps[0].pop();
-        return [eos, exps];
-      }
-      return $0;
-    });
+    var FatArrowBody$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
     var FatArrowBody$2 = AssignmentExpression;
     var FatArrowBody$3 = $S(__, AssignmentExpression);
     var FatArrowBody$4 = $S(InsertOpenBrace, InsertCloseBrace);
@@ -1152,7 +1201,7 @@ var require_parser = __commonJS({
     var PrimaryExpression$6 = ClassExpression;
     var PrimaryExpression$7 = RegularExpressionLiteral;
     var PrimaryExpression$8 = TemplateLiteral;
-    var PrimaryExpression$9 = $S(OpenParen, __, Expression, __, CloseParen);
+    var PrimaryExpression$9 = $S(OpenParen, Expression, __, CloseParen);
     var PrimaryExpression$10 = JSXElement;
     var PrimaryExpression$11 = JSXFragment;
     function PrimaryExpression(state) {
@@ -1172,7 +1221,7 @@ var require_parser = __commonJS({
         return ClassDeclaration$0(state);
       }
     }
-    var ClassExpression$0 = $S(Class, $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
+    var ClassExpression$0 = $S(Class, $E(BindingIdentifier), $E($S(__, ClassHeritage)), ClassBody);
     function ClassExpression(state) {
       if (state.verbose)
         console.log("ENTER:", "ClassExpression");
@@ -1192,10 +1241,10 @@ var require_parser = __commonJS({
         return ClassHeritage$0(state);
       }
     }
-    var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
+    var ExtendsToken$0 = $TV($EXPECT($L7, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
       return { $loc, token: "extends" };
     });
-    var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
+    var ExtendsToken$1 = $TV($EXPECT($L8, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function ExtendsToken(state) {
@@ -1265,11 +1314,11 @@ var require_parser = __commonJS({
         return FieldDefinition$0(state) || FieldDefinition$1(state);
       }
     }
-    var This$0 = $TV($EXPECT($L7, fail, 'This "this"'), function($skip, $loc, $0, $1) {
+    var This$0 = $TV($EXPECT($L9, fail, 'This "this"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
-    var This$1 = $S(AtAccessor, $S($E($EXPECT($L8, fail, 'This "#"')), IdentifierName));
-    var This$2 = $TV($EXPECT($L9, fail, 'This "@"'), function($skip, $loc, $0, $1) {
+    var This$1 = $S(AtAccessor, $S($E($EXPECT($L10, fail, 'This "#"')), IdentifierName));
+    var This$2 = $TV($EXPECT($L11, fail, 'This "@"'), function($skip, $loc, $0, $1) {
       return { $loc, token: "this" };
     });
     function This(state) {
@@ -1279,7 +1328,7 @@ var require_parser = __commonJS({
         return This$0(state) || This$1(state) || This$2(state);
       }
     }
-    var AtAccessor$0 = $TV($EXPECT($L9, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
+    var AtAccessor$0 = $TV($EXPECT($L11, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
       return { $loc, token: "this." };
     });
     function AtAccessor(state) {
@@ -1310,8 +1359,8 @@ var require_parser = __commonJS({
         return NewExpression$0(state);
       }
     }
-    var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), __, Arguments);
-    var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
+    var CallExpression$0 = $S($EXPECT($L12, fail, 'CallExpression "super"'), ArgumentsWithTrailingCallExpressions);
+    var CallExpression$1 = $S($EXPECT($L13, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
     var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
     function CallExpression(state) {
       if (state.tokenize) {
@@ -1320,15 +1369,14 @@ var require_parser = __commonJS({
         return CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
       }
     }
-    var CallExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), Arguments);
-    var CallExpressionRest$1 = MemberExpressionRest;
-    var CallExpressionRest$2 = SpacedApplication;
-    var CallExpressionRest$3 = TemplateLiteral;
+    var CallExpressionRest$0 = MemberExpressionRest;
+    var CallExpressionRest$1 = TemplateLiteral;
+    var CallExpressionRest$2 = $S($E($C(OptionalShorthand, NonNullAssertion)), ArgumentsWithTrailingCallExpressions);
     function CallExpressionRest(state) {
       if (state.tokenize) {
-        return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state));
+        return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state));
       } else {
-        return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
+        return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state);
       }
     }
     var OptionalShorthand$0 = $S(QuestionMark, $C(Dot, InsertDot));
@@ -1341,7 +1389,7 @@ var require_parser = __commonJS({
         return OptionalShorthand$0(state);
       }
     }
-    var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
+    var NonNullAssertion$0 = $T($EXPECT($L14, fail, 'NonNullAssertion "!"'), function(value) {
       return { "ts": true, "children": value };
     });
     function NonNullAssertion(state) {
@@ -1353,31 +1401,6 @@ var require_parser = __commonJS({
         return NonNullAssertion$0(state);
       }
     }
-    var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen, $Q($S($Y(EOS), Nested, CallExpressionRest)));
-    function SpacedApplication(state) {
-      if (state.verbose)
-        console.log("ENTER:", "SpacedApplication");
-      if (state.tokenize) {
-        return $TOKEN("SpacedApplication", state, SpacedApplication$0(state));
-      } else {
-        return SpacedApplication$0(state);
-      }
-    }
-    var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $N(EOS), _, $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3, $4) {
-      var opt = $1;
-      var spacing = $3;
-      spacing[0].token = spacing[0].token.replace(/^ ?/, "(");
-      return [opt, spacing];
-    });
-    function ApplicationStart(state) {
-      if (state.verbose)
-        console.log("ENTER:", "ApplicationStart");
-      if (state.tokenize) {
-        return $TOKEN("ApplicationStart", state, ApplicationStart$0(state));
-      } else {
-        return ApplicationStart$0(state);
-      }
-    }
     var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
     function AdditionalReservedWords(state) {
       if (state.verbose)
@@ -1398,10 +1421,10 @@ var require_parser = __commonJS({
         return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
       }
     }
-    var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, __, Expression, __, CloseBracket);
-    var MemberExpressionRest$1 = $S($E($S(EOS, NestedFurther)), PropertyAccess);
-    var MemberExpressionRest$2 = $TS($S($EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
-      var id = $2;
+    var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), OpenBracket, Expression, __, CloseBracket);
+    var MemberExpressionRest$1 = $S($E($S($Y(EOS), IndentedFurther)), PropertyAccess);
+    var MemberExpressionRest$2 = $TS($S($E($S($Y(EOS), IndentedFurther)), $EXPECT($L15, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2, $3) {
+      var id = $3;
       if (id)
         return [".prototype.", id];
       return ".prototype";
@@ -1424,7 +1447,7 @@ var require_parser = __commonJS({
         return PropertyAccess$0(state);
       }
     }
-    var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), __, Expression, __, CloseBracket);
+    var SuperProperty$0 = $S($EXPECT($L16, fail, 'SuperProperty "super["'), Expression, __, CloseBracket);
     function SuperProperty(state) {
       if (state.verbose)
         console.log("ENTER:", "SuperProperty");
@@ -1435,7 +1458,7 @@ var require_parser = __commonJS({
       }
     }
     var MetaProperty$0 = $S(New, Dot, Target);
-    var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
+    var MetaProperty$1 = $TV($EXPECT($L17, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function MetaProperty(state) {
@@ -1446,7 +1469,7 @@ var require_parser = __commonJS({
       }
     }
     var Parameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
-    var Parameters$1 = $TV($EXPECT($L16, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
+    var Parameters$1 = $TV($EXPECT($L1, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: "()" };
     });
     function Parameters(state) {
@@ -1467,8 +1490,8 @@ var require_parser = __commonJS({
       }
     }
     var ParameterElementDelimiter$0 = $S($Q(_), Comma);
-    var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L17, fail, 'ParameterElementDelimiter ")"')));
-    var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L17, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
+    var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L18, fail, 'ParameterElementDelimiter ")"')));
+    var ParameterElementDelimiter$2 = $TV($Y($S(__, $EXPECT($L18, fail, 'ParameterElementDelimiter ")"'))), function($skip, $loc, $0, $1) {
       return { $loc, token: "," };
     });
     var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
@@ -1481,7 +1504,7 @@ var require_parser = __commonJS({
         return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state) || ParameterElementDelimiter$3(state);
       }
     }
-    var BindingIdentifier$0 = Identifier;
+    var BindingIdentifier$0 = $S(__, Identifier);
     function BindingIdentifier(state) {
       if (state.verbose)
         console.log("ENTER:", "BindingIdentifier");
@@ -1491,8 +1514,8 @@ var require_parser = __commonJS({
         return BindingIdentifier$0(state);
       }
     }
-    var BindingPattern$0 = ObjectBindingPattern;
-    var BindingPattern$1 = ArrayBindingPattern;
+    var BindingPattern$0 = $S(__, ObjectBindingPattern);
+    var BindingPattern$1 = $S(__, ArrayBindingPattern);
     function BindingPattern(state) {
       if (state.tokenize) {
         return $TOKEN("BindingPattern", state, BindingPattern$0(state) || BindingPattern$1(state));
@@ -1500,28 +1523,54 @@ var require_parser = __commonJS({
         return BindingPattern$0(state) || BindingPattern$1(state);
       }
     }
-    var ObjectBindingPattern$0 = $S(OpenBrace, $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, CloseBrace);
+    var ObjectBindingPattern$0 = $S(OpenBrace, $Y(EOS), NestedBindingProperties, __, CloseBrace);
+    var ObjectBindingPattern$1 = $S(OpenBrace, $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, CloseBrace);
     function ObjectBindingPattern(state) {
-      if (state.verbose)
-        console.log("ENTER:", "ObjectBindingPattern");
       if (state.tokenize) {
-        return $TOKEN("ObjectBindingPattern", state, ObjectBindingPattern$0(state));
+        return $TOKEN("ObjectBindingPattern", state, ObjectBindingPattern$0(state) || ObjectBindingPattern$1(state));
       } else {
-        return ObjectBindingPattern$0(state);
+        return ObjectBindingPattern$0(state) || ObjectBindingPattern$1(state);
       }
     }
-    var ArrayBindingPattern$0 = $S(OpenBracket, $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, CloseBracket);
+    var ArrayBindingPattern$0 = $S(OpenBracket, $Y(EOS), NestedBindingElements, __, CloseBracket);
+    var ArrayBindingPattern$1 = $S(OpenBracket, $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, CloseBracket);
     function ArrayBindingPattern(state) {
+      if (state.tokenize) {
+        return $TOKEN("ArrayBindingPattern", state, ArrayBindingPattern$0(state) || ArrayBindingPattern$1(state));
+      } else {
+        return ArrayBindingPattern$0(state) || ArrayBindingPattern$1(state);
+      }
+    }
+    var NestedBindingProperties$0 = $TS($S(PushIndent, $Q(NestedBindingProperty), $E($S(Nested, BindingRestProperty)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var props = $2;
+      var rest = $3;
+      if (!props.length)
+        return $skip;
+      if (rest)
+        props.push(rest);
+      return props;
+    });
+    function NestedBindingProperties(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedBindingProperties");
+      if (state.tokenize) {
+        return $TOKEN("NestedBindingProperties", state, NestedBindingProperties$0(state));
+      } else {
+        return NestedBindingProperties$0(state);
+      }
+    }
+    var NestedBindingProperty$0 = $S(Nested, BindingProperty);
+    function NestedBindingProperty(state) {
       if (state.verbose)
-        console.log("ENTER:", "ArrayBindingPattern");
+        console.log("ENTER:", "NestedBindingProperty");
       if (state.tokenize) {
-        return $TOKEN("ArrayBindingPattern", state, ArrayBindingPattern$0(state));
+        return $TOKEN("NestedBindingProperty", state, NestedBindingProperty$0(state));
       } else {
-        return ArrayBindingPattern$0(state);
+        return NestedBindingProperty$0(state);
       }
     }
-    var BindingProperty$0 = $S(__, PropertyName, __, Colon, __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
-    var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
+    var BindingProperty$0 = $S(__, PropertyName, __, Colon, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
+    var BindingProperty$1 = $S(BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
     function BindingProperty(state) {
       if (state.tokenize) {
         return $TOKEN("BindingProperty", state, BindingProperty$0(state) || BindingProperty$1(state));
@@ -1529,7 +1578,7 @@ var require_parser = __commonJS({
         return BindingProperty$0(state) || BindingProperty$1(state);
       }
     }
-    var BindingRestProperty$0 = $S($EXPECT($L18, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
+    var BindingRestProperty$0 = $S($EXPECT($L19, fail, 'BindingRestProperty "..."'), BindingIdentifier);
     function BindingRestProperty(state) {
       if (state.verbose)
         console.log("ENTER:", "BindingRestProperty");
@@ -1539,6 +1588,34 @@ var require_parser = __commonJS({
         return BindingRestProperty$0(state);
       }
     }
+    var NestedBindingElements$0 = $TS($S(PushIndent, $Q(NestedBindingElement), $E($S(Nested, BindingRestElement)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var props = $2;
+      var rest = $3;
+      if (!props.length)
+        return $skip;
+      if (rest)
+        props.push(rest);
+      return props;
+    });
+    function NestedBindingElements(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedBindingElements");
+      if (state.tokenize) {
+        return $TOKEN("NestedBindingElements", state, NestedBindingElements$0(state));
+      } else {
+        return NestedBindingElements$0(state);
+      }
+    }
+    var NestedBindingElement$0 = $S(Nested, BindingElement);
+    function NestedBindingElement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedBindingElement");
+      if (state.tokenize) {
+        return $TOKEN("NestedBindingElement", state, NestedBindingElement$0(state));
+      } else {
+        return NestedBindingElement$0(state);
+      }
+    }
     var BindingElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(Initializer), ArrayElementDelimiter);
     function BindingElement(state) {
       if (state.verbose)
@@ -1549,7 +1626,7 @@ var require_parser = __commonJS({
         return BindingElement$0(state);
       }
     }
-    var BindingRestElement$0 = $S($EXPECT($L18, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
+    var BindingRestElement$0 = $S($EXPECT($L19, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
     function BindingRestElement(state) {
       if (state.verbose)
         console.log("ENTER:", "BindingRestElement");
@@ -1570,7 +1647,7 @@ var require_parser = __commonJS({
       }
     }
     var FunctionExpression$0 = ThinArrowFunction;
-    var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S($EXPECT($L3, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
+    var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S($EXPECT($L5, fail, 'FunctionExpression "*"'), __)), $E(BindingIdentifier), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
     function FunctionExpression(state) {
       if (state.tokenize) {
         return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1599,7 +1676,7 @@ var require_parser = __commonJS({
         return ThinArrowFunction$0(state);
       }
     }
-    var Arrow$0 = $TV($EXPECT($L19, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
+    var Arrow$0 = $TV($EXPECT($L20, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function Arrow(state) {
@@ -1692,7 +1769,7 @@ var require_parser = __commonJS({
         return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
       }
     }
-    var NullLiteral$0 = $TV($EXPECT($L20, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
+    var NullLiteral$0 = $TV($EXPECT($L21, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function NullLiteral(state) {
@@ -1704,7 +1781,7 @@ var require_parser = __commonJS({
         return NullLiteral$0(state);
       }
     }
-    var BooleanLiteral$0 = $TV($C($EXPECT($L21, fail, 'BooleanLiteral "true"'), $EXPECT($L22, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
+    var BooleanLiteral$0 = $TV($C($EXPECT($L22, fail, 'BooleanLiteral "true"'), $EXPECT($L23, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function BooleanLiteral(state) {
@@ -1716,7 +1793,7 @@ var require_parser = __commonJS({
         return BooleanLiteral$0(state);
       }
     }
-    var Comma$0 = $TV($EXPECT($L23, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
+    var Comma$0 = $TV($EXPECT($L24, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function Comma(state) {
@@ -1798,7 +1875,7 @@ var require_parser = __commonJS({
       }
     }
     var ArrayElementDelimiter$0 = $S($Q(_), Comma);
-    var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L24, fail, 'ArrayElementDelimiter "]"')));
+    var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L25, fail, 'ArrayElementDelimiter "]"')));
     var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
       return { $loc, token: "," };
     });
@@ -1829,7 +1906,7 @@ var require_parser = __commonJS({
         return InlineElementList$0(state);
       }
     }
-    var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L18, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
+    var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L19, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
     function ArrayElementExpression(state) {
       if (state.verbose)
         console.log("ENTER:", "ArrayElementExpression");
@@ -1852,7 +1929,7 @@ var require_parser = __commonJS({
     var ObjectLiteral$0 = $S(OpenBrace, $Y(EOS), NestedPropertyDefinitions, __, CloseBrace);
     var ObjectLiteral$1 = $S(OpenBrace, __, PropertyDefinitionList, __, $E($S(Comma, __)), CloseBrace);
     var ObjectLiteral$2 = $S(OpenBrace, __, CloseBrace);
-    var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
+    var ObjectLiteral$3 = NestedObjectLiteral;
     function ObjectLiteral(state) {
       if (state.tokenize) {
         return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state) || ObjectLiteral$3(state));
@@ -1860,6 +1937,16 @@ var require_parser = __commonJS({
         return ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state) || ObjectLiteral$3(state);
       }
     }
+    var NestedObjectLiteral$0 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
+    function NestedObjectLiteral(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedObjectLiteral");
+      if (state.tokenize) {
+        return $TOKEN("NestedObjectLiteral", state, NestedObjectLiteral$0(state));
+      } else {
+        return NestedObjectLiteral$0(state);
+      }
+    }
     var NestedPropertyDefinitions$0 = $TS($S(PushIndent, $Q(NestedPropertyDefinition), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
       var defs = $2;
       if (!defs.length)
@@ -1886,18 +1973,15 @@ var require_parser = __commonJS({
       }
     }
     var ObjectPropertyDelimiter$0 = $S($Q(_), Comma);
-    var ObjectPropertyDelimiter$1 = $Y($S($Q(_), CloseBrace));
-    var ObjectPropertyDelimiter$2 = $TV($Y($S(__, CloseBrace)), function($skip, $loc, $0, $1) {
-      return { $loc, token: "," };
-    });
-    var ObjectPropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
+    var ObjectPropertyDelimiter$1 = $Y($S(__, $EXPECT($L26, fail, 'ObjectPropertyDelimiter "}"')));
+    var ObjectPropertyDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
       return { $loc, token: "," };
     });
     function ObjectPropertyDelimiter(state) {
       if (state.tokenize) {
-        return $TOKEN("ObjectPropertyDelimiter", state, ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state) || ObjectPropertyDelimiter$3(state));
+        return $TOKEN("ObjectPropertyDelimiter", state, ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state));
       } else {
-        return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state) || ObjectPropertyDelimiter$3(state);
+        return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state);
       }
     }
     var PropertyDefinitionList$0 = $S(PropertyDefinition, $Q($S(__, Comma, __, PropertyDefinition)));
@@ -1912,7 +1996,7 @@ var require_parser = __commonJS({
     }
     var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
     var PropertyDefinition$1 = MethodDefinition;
-    var PropertyDefinition$2 = $S($EXPECT($L18, fail, 'PropertyDefinition "..."'), AssignmentExpression);
+    var PropertyDefinition$2 = $S($EXPECT($L19, fail, 'PropertyDefinition "..."'), AssignmentExpression);
     var PropertyDefinition$3 = IdentifierReference;
     function PropertyDefinition(state) {
       if (state.tokenize) {
@@ -1924,7 +2008,7 @@ var require_parser = __commonJS({
     var PropertyName$0 = NumericLiteral;
     var PropertyName$1 = StringLiteral;
     var PropertyName$2 = IdentifierName;
-    var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L24, fail, 'PropertyName "]"'));
+    var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L25, fail, 'PropertyName "]"'));
     function PropertyName(state) {
       if (state.tokenize) {
         return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1932,27 +2016,25 @@ var require_parser = __commonJS({
         return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
       }
     }
-    var MethodDefinition$0 = $S($EXPECT($L25, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
-    var MethodDefinition$1 = $S($EXPECT($L26, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
-    var MethodDefinition$2 = AsyncGeneratorMethod;
-    var MethodDefinition$3 = AsyncMethod;
-    var MethodDefinition$4 = GeneratorMethod;
-    var MethodDefinition$5 = $S(ClassElementName, $Q(_), Parameters, BracedBlock);
+    var MethodDefinition$0 = $S(MethodSignature, BracedBlock);
     function MethodDefinition(state) {
+      if (state.verbose)
+        console.log("ENTER:", "MethodDefinition");
       if (state.tokenize) {
-        return $TOKEN("MethodDefinition", state, MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state));
+        return $TOKEN("MethodDefinition", state, MethodDefinition$0(state));
       } else {
-        return MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state);
+        return MethodDefinition$0(state);
       }
     }
-    var MethodModifier$0 = $S($C($EXPECT($L25, fail, 'MethodModifier "get"'), $EXPECT($L26, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
+    var MethodModifier$0 = $S(GetOrSet, $Q(TrailingComment));
+    var MethodModifier$1 = $S($S(Async, __), $E($S($EXPECT($L5, fail, 'MethodModifier "*"'), __)));
+    var MethodModifier$2 = $S($EXPECT($L5, fail, 'MethodModifier "*"'), __);
+    var MethodModifier$3 = $S(Async, __);
     function MethodModifier(state) {
-      if (state.verbose)
-        console.log("ENTER:", "MethodModifier");
       if (state.tokenize) {
-        return $TOKEN("MethodModifier", state, MethodModifier$0(state));
+        return $TOKEN("MethodModifier", state, MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state));
       } else {
-        return MethodModifier$0(state);
+        return MethodModifier$0(state) || MethodModifier$1(state) || MethodModifier$2(state) || MethodModifier$3(state);
       }
     }
     var MethodSignature$0 = $S($E(MethodModifier), ClassElementName, $Q(_), Parameters);
@@ -1974,7 +2056,7 @@ var require_parser = __commonJS({
         return ClassElementName$0(state) || ClassElementName$1(state);
       }
     }
-    var PrivateIdentifier$0 = $S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName);
+    var PrivateIdentifier$0 = $S($EXPECT($L10, fail, 'PrivateIdentifier "#"'), IdentifierName);
     function PrivateIdentifier(state) {
       if (state.verbose)
         console.log("ENTER:", "PrivateIdentifier");
@@ -1984,66 +2066,6 @@ var require_parser = __commonJS({
         return PrivateIdentifier$0(state);
       }
     }
-    var GeneratorMethod$0 = $S($EXPECT($L3, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
-    function GeneratorMethod(state) {
-      if (state.verbose)
-        console.log("ENTER:", "GeneratorMethod");
-      if (state.tokenize) {
-        return $TOKEN("GeneratorMethod", state, GeneratorMethod$0(state));
-      } else {
-        return GeneratorMethod$0(state);
-      }
-    }
-    var GeneratorBody$0 = BracedBlock;
-    function GeneratorBody(state) {
-      if (state.verbose)
-        console.log("ENTER:", "GeneratorBody");
-      if (state.tokenize) {
-        return $TOKEN("GeneratorBody", state, GeneratorBody$0(state));
-      } else {
-        return GeneratorBody$0(state);
-      }
-    }
-    var AsyncMethod$0 = $S(Async, $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
-    function AsyncMethod(state) {
-      if (state.verbose)
-        console.log("ENTER:", "AsyncMethod");
-      if (state.tokenize) {
-        return $TOKEN("AsyncMethod", state, AsyncMethod$0(state));
-      } else {
-        return AsyncMethod$0(state);
-      }
-    }
-    var AsyncFunctionBody$0 = BracedBlock;
-    function AsyncFunctionBody(state) {
-      if (state.verbose)
-        console.log("ENTER:", "AsyncFunctionBody");
-      if (state.tokenize) {
-        return $TOKEN("AsyncFunctionBody", state, AsyncFunctionBody$0(state));
-      } else {
-        return AsyncFunctionBody$0(state);
-      }
-    }
-    var AsyncGeneratorMethod$0 = $S(Async, $N(EOS), __, $EXPECT($L3, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
-    function AsyncGeneratorMethod(state) {
-      if (state.verbose)
-        console.log("ENTER:", "AsyncGeneratorMethod");
-      if (state.tokenize) {
-        return $TOKEN("AsyncGeneratorMethod", state, AsyncGeneratorMethod$0(state));
-      } else {
-        return AsyncGeneratorMethod$0(state);
-      }
-    }
-    var AsyncGeneratorBody$0 = BracedBlock;
-    function AsyncGeneratorBody(state) {
-      if (state.verbose)
-        console.log("ENTER:", "AsyncGeneratorBody");
-      if (state.tokenize) {
-        return $TOKEN("AsyncGeneratorBody", state, AsyncGeneratorBody$0(state));
-      } else {
-        return AsyncGeneratorBody$0(state);
-      }
-    }
     var AssignmentOp$0 = $TS($S(AssignmentOpSymbol), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
@@ -2095,7 +2117,7 @@ var require_parser = __commonJS({
       }
     }
     var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
-    var BinaryOpSymbol$1 = $EXPECT($L3, fail, 'BinaryOpSymbol "*"');
+    var BinaryOpSymbol$1 = $EXPECT($L5, fail, 'BinaryOpSymbol "*"');
     var BinaryOpSymbol$2 = $EXPECT($L45, fail, 'BinaryOpSymbol "/"');
     var BinaryOpSymbol$3 = $EXPECT($L46, fail, 'BinaryOpSymbol "%"');
     var BinaryOpSymbol$4 = $EXPECT($L47, fail, 'BinaryOpSymbol "+"');
@@ -2103,7 +2125,7 @@ var require_parser = __commonJS({
     var BinaryOpSymbol$6 = $EXPECT($L49, fail, 'BinaryOpSymbol "<="');
     var BinaryOpSymbol$7 = $EXPECT($L50, fail, 'BinaryOpSymbol ">="');
     var BinaryOpSymbol$8 = $EXPECT($L51, fail, 'BinaryOpSymbol "<<"');
-    var BinaryOpSymbol$9 = $EXPECT($L5, fail, 'BinaryOpSymbol "<"');
+    var BinaryOpSymbol$9 = $EXPECT($L7, fail, 'BinaryOpSymbol "<"');
     var BinaryOpSymbol$10 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>>"');
     var BinaryOpSymbol$11 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>"');
     var BinaryOpSymbol$12 = $EXPECT($L54, fail, 'BinaryOpSymbol ">"');
@@ -2184,7 +2206,7 @@ var require_parser = __commonJS({
         return StatementListItem$0(state);
       }
     }
-    var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C(If, Unless), NonIdContinue, Loc, Expression, Loc), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+    var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C(If, Unless), NonIdContinue, Loc, ExpressionWithIndentedApplicationSuppressed, Loc), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
       var ws = $1;
       var cond = $2;
       var l1 = $4;
@@ -2318,7 +2340,7 @@ var require_parser = __commonJS({
       var cond = $3;
       if (kind === "until") {
         cond[1] = "(!(";
-        cond[5] = "))";
+        cond[4] = "))";
         return ["while", cond];
       }
       return $0;
@@ -2332,7 +2354,7 @@ var require_parser = __commonJS({
         return WhileClause$0(state);
       }
     }
-    var ForStatement$0 = $S(For, __, OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, __, $E(Expression), Semicolon, __, $E(Expression), CloseParen, Block);
+    var ForStatement$0 = $S(For, __, OpenParen, __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, Semicolon, $E(Expression), Semicolon, $E(Expression), CloseParen, Block);
     function ForStatement(state) {
       if (state.verbose)
         console.log("ENTER:", "ForStatement");
@@ -2342,8 +2364,8 @@ var require_parser = __commonJS({
         return ForStatement$0(state);
       }
     }
-    var ForInOfStatement$0 = $S(For, __, OpenParen, __, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, __, Expression, __, CloseParen, Block);
-    var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, __, Expression, InsertCloseParen, Block);
+    var ForInOfStatement$0 = $S(For, __, OpenParen, __, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, Expression, __, CloseParen, Block);
+    var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, In, Expression, InsertCloseParen, Block);
     var ForInOfStatement$2 = $S(For, $E($S(__, Await)), __, OpenParen, __, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, Of, AssignmentExpression, __, CloseParen, Block);
     var ForInOfStatement$3 = $S(For, $E($S(__, Await)), __, InsertOpenParen, $C($S(Var, __, ForBinding), ForDeclaration, LeftHandSideExpression), __, Of, AssignmentExpression, InsertCloseParen, Block);
     function ForInOfStatement(state) {
@@ -2363,18 +2385,6 @@ var require_parser = __commonJS({
         return ForDeclaration$0(state);
       }
     }
-    var LetOrConst$0 = $TV($C($EXPECT($L77, fail, 'LetOrConst "let"'), $EXPECT($L78, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
-      return { $loc, token: $1 };
-    });
-    function LetOrConst(state) {
-      if (state.verbose)
-        console.log("ENTER:", "LetOrConst");
-      if (state.tokenize) {
-        return $TOKEN("LetOrConst", state, LetOrConst$0(state));
-      } else {
-        return LetOrConst$0(state);
-      }
-    }
     var ForBinding$0 = BindingIdentifier;
     var ForBinding$1 = BindingPattern;
     function ForBinding(state) {
@@ -2428,9 +2438,9 @@ var require_parser = __commonJS({
         return NestedCaseClause$0(state);
       }
     }
-    var CaseClause$0 = $S($EXPECT($L79, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
-    var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
-    var CaseClause$2 = $S($EXPECT($L80, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
+    var CaseClause$0 = $S($EXPECT($L77, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon, NestedBlockExpressions);
+    var CaseClause$1 = $S(When, $Q(_), ExpressionWithIndentedApplicationSuppressed, ImpliedColon, NestedBlockExpressions, InsertBreak);
+    var CaseClause$2 = $S($EXPECT($L78, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
     function CaseClause(state) {
       if (state.tokenize) {
         return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2439,7 +2449,7 @@ var require_parser = __commonJS({
       }
     }
     var ImpliedColon$0 = $S(__, Colon);
-    var ImpliedColon$1 = $TV($EXPECT($L16, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
+    var ImpliedColon$1 = $TV($EXPECT($L1, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: ":" };
     });
     function ImpliedColon(state) {
@@ -2485,7 +2495,7 @@ var require_parser = __commonJS({
         return CatchBind$0(state) || CatchBind$1(state);
       }
     }
-    var Finally$0 = $S(__, $EXPECT($L81, fail, 'Finally "finally"'), BracedBlock);
+    var Finally$0 = $S(__, $EXPECT($L79, fail, 'Finally "finally"'), BracedBlock);
     function Finally(state) {
       if (state.verbose)
         console.log("ENTER:", "Finally");
@@ -2504,8 +2514,8 @@ var require_parser = __commonJS({
         return CatchParameter$0(state) || CatchParameter$1(state);
       }
     }
-    var Condition$0 = $S(__, OpenParen, __, Expression, __, CloseParen);
-    var Condition$1 = $S($N(EOS), __, InsertOpenParen, Expression, InsertCloseParen);
+    var Condition$0 = $S(__, OpenParen, Expression, __, CloseParen);
+    var Condition$1 = $S($N(EOS), __, InsertOpenParen, ExpressionWithIndentedApplicationSuppressed, InsertCloseParen);
     function Condition(state) {
       if (state.tokenize) {
         return $TOKEN("Condition", state, Condition$0(state) || Condition$1(state));
@@ -2513,6 +2523,34 @@ var require_parser = __commonJS({
         return Condition$0(state) || Condition$1(state);
       }
     }
+    var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(Expression)), function($skip, $loc, $0, $1, $2) {
+      var exp = $2;
+      module2.suppressIndentedApplication = false;
+      if (exp)
+        return exp;
+      return $skip;
+    });
+    function ExpressionWithIndentedApplicationSuppressed(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ExpressionWithIndentedApplicationSuppressed");
+      if (state.tokenize) {
+        return $TOKEN("ExpressionWithIndentedApplicationSuppressed", state, ExpressionWithIndentedApplicationSuppressed$0(state));
+      } else {
+        return ExpressionWithIndentedApplicationSuppressed$0(state);
+      }
+    }
+    var SuppressIndentedApplication$0 = $TV($EXPECT($L1, fail, 'SuppressIndentedApplication ""'), function($skip, $loc, $0, $1) {
+      module2.suppressIndentedApplication = true;
+    });
+    function SuppressIndentedApplication(state) {
+      if (state.verbose)
+        console.log("ENTER:", "SuppressIndentedApplication");
+      if (state.tokenize) {
+        return $TOKEN("SuppressIndentedApplication", state, SuppressIndentedApplication$0(state));
+      } else {
+        return SuppressIndentedApplication$0(state);
+      }
+    }
     var ExpressionStatement$0 = Expression;
     function ExpressionStatement(state) {
       if (state.verbose)
@@ -2523,11 +2561,11 @@ var require_parser = __commonJS({
         return ExpressionStatement$0(state);
       }
     }
-    var KeywordStatement$0 = $S($EXPECT($L82, fail, 'KeywordStatement "break"'), NonIdContinue);
-    var KeywordStatement$1 = $S($EXPECT($L83, fail, 'KeywordStatement "continue"'), NonIdContinue);
-    var KeywordStatement$2 = $S($EXPECT($L84, fail, 'KeywordStatement "debugger"'), NonIdContinue);
+    var KeywordStatement$0 = $S($EXPECT($L80, fail, 'KeywordStatement "break"'), NonIdContinue);
+    var KeywordStatement$1 = $S($EXPECT($L81, fail, 'KeywordStatement "continue"'), NonIdContinue);
+    var KeywordStatement$2 = $S($EXPECT($L82, fail, 'KeywordStatement "debugger"'), NonIdContinue);
     var KeywordStatement$3 = $S(Return, $E(MaybeNestedExpression));
-    var KeywordStatement$4 = $S($EXPECT($L85, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
+    var KeywordStatement$4 = $S($EXPECT($L83, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
     function KeywordStatement(state) {
       if (state.tokenize) {
         return $TOKEN("KeywordStatement", state, KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state));
@@ -2544,7 +2582,7 @@ var require_parser = __commonJS({
         return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
       }
     }
-    var ImportDeclaration$0 = $T($S($EXPECT($L86, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
+    var ImportDeclaration$0 = $T($S($EXPECT($L84, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
       return { "ts": true, "children": value };
     });
     var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
@@ -2567,7 +2605,7 @@ var require_parser = __commonJS({
         return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
       }
     }
-    var ImpliedImport$0 = $TV($EXPECT($L16, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
+    var ImpliedImport$0 = $TV($EXPECT($L1, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: "import " };
     });
     function ImpliedImport(state) {
@@ -2589,7 +2627,7 @@ var require_parser = __commonJS({
         return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
       }
     }
-    var NameSpaceImport$0 = $S($EXPECT($L3, fail, 'NameSpaceImport "*"'), __, As, NonIdContinue, __, ImportedBinding);
+    var NameSpaceImport$0 = $S($EXPECT($L5, fail, 'NameSpaceImport "*"'), __, As, NonIdContinue, __, ImportedBinding);
     function NameSpaceImport(state) {
       if (state.verbose)
         console.log("ENTER:", "NameSpaceImport");
@@ -2682,7 +2720,7 @@ var require_parser = __commonJS({
         return ImportedBinding$0(state);
       }
     }
-    var ExportDeclaration$0 = $S(Export, __, $EXPECT($L80, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
+    var ExportDeclaration$0 = $S(Export, __, $EXPECT($L78, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
     var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
     var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
     function ExportDeclaration(state) {
@@ -2692,7 +2730,7 @@ var require_parser = __commonJS({
         return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
       }
     }
-    var ExportFromClause$0 = $S($EXPECT($L3, fail, 'ExportFromClause "*"'), $E($S(__, As, NonIdContinue, __, ModuleExportName)));
+    var ExportFromClause$0 = $S($EXPECT($L5, fail, 'ExportFromClause "*"'), $E($S(__, As, NonIdContinue, __, ModuleExportName)));
     var ExportFromClause$1 = NamedExports;
     function ExportFromClause(state) {
       if (state.tokenize) {
@@ -2759,7 +2797,7 @@ var require_parser = __commonJS({
         return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
       }
     }
-    var ConstAssignment$0 = $TV($EXPECT($L87, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
+    var ConstAssignment$0 = $TV($EXPECT($L85, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
       return { $loc, token: "=" };
     });
     function ConstAssignment(state) {
@@ -2905,10 +2943,10 @@ var require_parser = __commonJS({
       var e = $3;
       return [s, module2.dedentBlockString(str), e];
     });
-    var StringLiteral$2 = $TV($TEXT($S($EXPECT($L88, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L88, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
+    var StringLiteral$2 = $TV($TEXT($S($EXPECT($L86, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L86, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
-    var StringLiteral$3 = $TV($TEXT($S($EXPECT($L89, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L89, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
+    var StringLiteral$3 = $TV($TEXT($S($EXPECT($L87, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L87, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function StringLiteral(state) {
@@ -3004,7 +3042,7 @@ var require_parser = __commonJS({
         return RegularExpressionFlags$0(state);
       }
     }
-    var TemplateLiteral$0 = $S($EXPECT($L90, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L90, fail, 'TemplateLiteral "`"'));
+    var TemplateLiteral$0 = $S($EXPECT($L0, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L0, fail, 'TemplateLiteral "`"'));
     function TemplateLiteral(state) {
       if (state.verbose)
         console.log("ENTER:", "TemplateLiteral");
@@ -3014,7 +3052,7 @@ var require_parser = __commonJS({
         return TemplateLiteral$0(state);
       }
     }
-    var TemplateSubstitution$0 = $S($EXPECT($L91, fail, 'TemplateSubstitution "${"'), __, Expression, __, CloseBrace);
+    var TemplateSubstitution$0 = $S($EXPECT($L88, fail, 'TemplateSubstitution "${"'), Expression, __, CloseBrace);
     function TemplateSubstitution(state) {
       if (state.verbose)
         console.log("ENTER:", "TemplateSubstitution");
@@ -3073,7 +3111,7 @@ var require_parser = __commonJS({
         return MultiLineComment$0(state) || MultiLineComment$1(state);
       }
     }
-    var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L93, fail, 'JSMultiLineComment "*/"')), $EXPECT($R19, fail, "JSMultiLineComment /./"))), $EXPECT($L93, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
+    var JSMultiLineComment$0 = $TV($TEXT($S($EXPECT($L89, fail, 'JSMultiLineComment "/*"'), $Q($S($N($EXPECT($L90, fail, 'JSMultiLineComment "*/"')), $EXPECT($R19, fail, "JSMultiLineComment /./"))), $EXPECT($L90, fail, 'JSMultiLineComment "*/"'))), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function JSMultiLineComment(state) {
@@ -3099,7 +3137,7 @@ var require_parser = __commonJS({
         return CoffeeSingleLineComment$0(state);
       }
     }
-    var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L94, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L94, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L93, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R19, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L94, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
+    var CoffeeMultiLineComment$0 = $TS($S($EXPECT($L91, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($C($EXPECT($L91, fail, 'CoffeeMultiLineComment "###"'), $EXPECT($L90, fail, 'CoffeeMultiLineComment "*/"'))), $EXPECT($R19, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L91, fail, 'CoffeeMultiLineComment "###"')), function($skip, $loc, $0, $1, $2, $3) {
       return { $loc, token: `/*${$2}*/` };
     });
     function CoffeeMultiLineComment(state) {
@@ -3111,7 +3149,7 @@ var require_parser = __commonJS({
         return CoffeeMultiLineComment$0(state);
       }
     }
-    var InlineComment$0 = $TV($TEXT($S($EXPECT($L92, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L93, fail, 'InlineComment "*/"')), $EXPECT($R21, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L93, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
+    var InlineComment$0 = $TV($TEXT($S($EXPECT($L89, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L90, fail, 'InlineComment "*/"')), $EXPECT($R21, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L90, fail, 'InlineComment "*/"'))), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function InlineComment(state) {
@@ -3188,7 +3226,7 @@ var require_parser = __commonJS({
       }
     }
     var StatementDelimiter$0 = $S($Q(TrailingComment), Semicolon, $Q(TrailingComment));
-    var StatementDelimiter$1 = $TS($S($EXPECT($L16, fail, 'StatementDelimiter ""'), $Y(EOS)), function($skip, $loc, $0, $1, $2) {
+    var StatementDelimiter$1 = $TS($S($EXPECT($L1, fail, 'StatementDelimiter ""'), $Y(EOS)), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: ";" };
     });
     function StatementDelimiter(state) {
@@ -3208,7 +3246,7 @@ var require_parser = __commonJS({
         return NonIdContinue$0(state);
       }
     }
-    var Loc$0 = $TV($EXPECT($L16, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
+    var Loc$0 = $TV($EXPECT($L1, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: "" };
     });
     function Loc(state) {
@@ -3220,7 +3258,7 @@ var require_parser = __commonJS({
         return Loc$0(state);
       }
     }
-    var As$0 = $TS($S($EXPECT($L95, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var As$0 = $TS($S($EXPECT($L92, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function As(state) {
@@ -3232,7 +3270,7 @@ var require_parser = __commonJS({
         return As$0(state);
       }
     }
-    var Async$0 = $TV($EXPECT($L96, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
+    var Async$0 = $TV($EXPECT($L93, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function Async(state) {
@@ -3244,7 +3282,7 @@ var require_parser = __commonJS({
         return Async$0(state);
       }
     }
-    var Await$0 = $TS($S($EXPECT($L97, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Await$0 = $TS($S($EXPECT($L94, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function Await(state) {
@@ -3256,7 +3294,7 @@ var require_parser = __commonJS({
         return Await$0(state);
       }
     }
-    var Catch$0 = $TV($EXPECT($L98, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
+    var Catch$0 = $TV($EXPECT($L95, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function Catch(state) {
@@ -3268,7 +3306,7 @@ var require_parser = __commonJS({
         return Catch$0(state);
       }
     }
-    var Class$0 = $TV($EXPECT($L99, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
+    var Class$0 = $TV($EXPECT($L96, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function Class(state) {
@@ -3280,7 +3318,7 @@ var require_parser = __commonJS({
         return Class$0(state);
       }
     }
-    var CloseBrace$0 = $TV($EXPECT($L100, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
+    var CloseBrace$0 = $TV($EXPECT($L26, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function CloseBrace(state) {
@@ -3292,7 +3330,7 @@ var require_parser = __commonJS({
         return CloseBrace$0(state);
       }
     }
-    var CloseBracket$0 = $TV($EXPECT($L24, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
+    var CloseBracket$0 = $TV($EXPECT($L25, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function CloseBracket(state) {
@@ -3304,7 +3342,7 @@ var require_parser = __commonJS({
         return CloseBracket$0(state);
       }
     }
-    var CloseParen$0 = $TV($EXPECT($L17, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
+    var CloseParen$0 = $TV($EXPECT($L18, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function CloseParen(state) {
@@ -3316,7 +3354,7 @@ var require_parser = __commonJS({
         return CloseParen$0(state);
       }
     }
-    var Colon$0 = $TV($EXPECT($L101, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
+    var Colon$0 = $TV($EXPECT($L97, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function Colon(state) {
@@ -3328,7 +3366,7 @@ var require_parser = __commonJS({
         return Colon$0(state);
       }
     }
-    var Dot$0 = $TV($EXPECT($L102, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
+    var Dot$0 = $TV($EXPECT($L98, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function Dot(state) {
@@ -3340,7 +3378,7 @@ var require_parser = __commonJS({
         return Dot$0(state);
       }
     }
-    var Else$0 = $TV($EXPECT($L103, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
+    var Else$0 = $TV($EXPECT($L99, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function Else(state) {
@@ -3364,7 +3402,7 @@ var require_parser = __commonJS({
         return Equals$0(state);
       }
     }
-    var Export$0 = $TS($S($EXPECT($L104, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var Export$0 = $TS($S($EXPECT($L100, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function Export(state) {
@@ -3376,7 +3414,7 @@ var require_parser = __commonJS({
         return Export$0(state);
       }
     }
-    var For$0 = $TS($S($EXPECT($L105, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var For$0 = $TS($S($EXPECT($L101, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function For(state) {
@@ -3388,7 +3426,7 @@ var require_parser = __commonJS({
         return For$0(state);
       }
     }
-    var From$0 = $TS($S($EXPECT($L106, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+    var From$0 = $TS($S($EXPECT($L102, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function From(state) {
@@ -3400,7 +3438,7 @@ var require_parser = __commonJS({
         return From$0(state);
       }
     }
-    var Function$0 = $TV($EXPECT($L107, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
+    var Function$0 = $TV($EXPECT($L103, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function Function(state) {
@@ -3412,7 +3450,19 @@ var require_parser = __commonJS({
         return Function$0(state);
       }
     }
-    var If$0 = $TV($EXPECT($L108, fail, 'If "if"'), function($skip, $loc, $0, $1) {
+    var GetOrSet$0 = $TS($S($C($EXPECT($L104, fail, 'GetOrSet "get"'), $EXPECT($L105, fail, 'GetOrSet "set"')), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      return { $loc, token: $1 };
+    });
+    function GetOrSet(state) {
+      if (state.verbose)
+        console.log("ENTER:", "GetOrSet");
+      if (state.tokenize) {
+        return $TOKEN("GetOrSet", state, GetOrSet$0(state));
+      } else {
+        return GetOrSet$0(state);
+      }
+    }
+    var If$0 = $TV($EXPECT($L106, fail, 'If "if"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
     function If(state) {
@@ -3424,7 +3474,7 @@ var require_parser = __commonJS({
         return If$0(state);
       }
     }
-    var Import$0 = $TS($S($EXPECT($L11, fail, 'Import "import"'), $Y($EXPECT($R26, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
+    var Import$0 = $TS($S($EXPECT($L13, fail, 'Import "import"'), $Y($EXPECT($R26, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function Import(state) {
@@ -3448,6 +3498,18 @@ var require_parser = __commonJS({
         return In$0(state);
       }
     }
+    var LetOrConst$0 = $TV($C($EXPECT($L107, fail, 'LetOrConst "let"'), $EXPECT($L108, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
+      return { $loc, token: $1 };
+    });
+    function LetOrConst(state) {
+      if (state.verbose)
+        console.log("ENTER:", "LetOrConst");
+      if (state.tokenize) {
+        return $TOKEN("LetOrConst", state, LetOrConst$0(state));
+      } else {
+        return LetOrConst$0(state);
+      }
+    }
     var Loop$0 = $TS($S($EXPECT($L109, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: "while(true)" };
     });
@@ -3559,13 +3621,14 @@ var require_parser = __commonJS({
     var Static$0 = $TV($EXPECT($L117, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
+    var Static$1 = $TV($EXPECT($L11, fail, 'Static "@"'), function($skip, $loc, $0, $1) {
+      return { $loc, token: "static " };
+    });
     function Static(state) {
-      if (state.verbose)
-        console.log("ENTER:", "Static");
       if (state.tokenize) {
-        return $TOKEN("Static", state, Static$0(state));
+        return $TOKEN("Static", state, Static$0(state) || Static$1(state));
       } else {
-        return Static$0(state);
+        return Static$0(state) || Static$1(state);
       }
     }
     var Switch$0 = $TV($EXPECT($L118, fail, 'Switch "switch"'), function($skip, $loc, $0, $1) {
@@ -3678,7 +3741,7 @@ var require_parser = __commonJS({
         return JSXElement$0(state) || JSXElement$1(state);
       }
     }
-    var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L126, fail, 'JSXSelfClosingElement "/>"'));
+    var JSXSelfClosingElement$0 = $S($EXPECT($L7, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L126, fail, 'JSXSelfClosingElement "/>"'));
     function JSXSelfClosingElement(state) {
       if (state.verbose)
         console.log("ENTER:", "JSXSelfClosingElement");
@@ -3688,7 +3751,7 @@ var require_parser = __commonJS({
         return JSXSelfClosingElement$0(state);
       }
     }
-    var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L54, fail, 'JSXOpeningElement ">"'));
+    var JSXOpeningElement$0 = $S($EXPECT($L7, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L54, fail, 'JSXOpeningElement ">"'));
     function JSXOpeningElement(state) {
       if (state.verbose)
         console.log("ENTER:", "JSXOpeningElement");
@@ -3748,7 +3811,7 @@ var require_parser = __commonJS({
         return JSXAttributes$0(state);
       }
     }
-    var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L18, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
+    var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L19, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
     var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
     function JSXAttribute(state) {
       if (state.tokenize) {
@@ -3820,7 +3883,7 @@ var require_parser = __commonJS({
         return JSXText$0(state);
       }
     }
-    var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L18, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
+    var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L19, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
     function JSXChildExpression(state) {
       if (state.verbose)
         console.log("ENTER:", "JSXChildExpression");
@@ -4110,7 +4173,7 @@ var require_parser = __commonJS({
         return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
       }
     }
-    var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
+    var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L8, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
     function TypeConditional(state) {
       if (state.verbose)
         console.log("ENTER:", "TypeConditional");
@@ -4139,7 +4202,7 @@ var require_parser = __commonJS({
         return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
       }
     }
-    var FunctionType$0 = $S(Parameters, __, $EXPECT($L4, fail, 'FunctionType "=>"'), Type);
+    var FunctionType$0 = $S(Parameters, __, $EXPECT($L6, fail, 'FunctionType "=>"'), Type);
     function FunctionType(state) {
       if (state.verbose)
         console.log("ENTER:", "FunctionType");
@@ -4149,7 +4212,7 @@ var require_parser = __commonJS({
         return FunctionType$0(state);
       }
     }
-    var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeArguments ">"'));
+    var TypeArguments$0 = $S(__, $EXPECT($L7, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeArguments ">"'));
     function TypeArguments(state) {
       if (state.verbose)
         console.log("ENTER:", "TypeArguments");
@@ -4159,7 +4222,7 @@ var require_parser = __commonJS({
         return TypeArguments$0(state);
       }
     }
-    var TypeParameters$0 = $TS($S(__, $EXPECT($L5, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+    var TypeParameters$0 = $TS($S(__, $EXPECT($L7, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
       return { ts: true, children: $0 };
     });
     function TypeParameters(state) {
@@ -4181,7 +4244,7 @@ var require_parser = __commonJS({
         return TypeParameter$0(state);
       }
     }
-    var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
+    var TypeConstraint$0 = $S(__, $EXPECT($L8, fail, 'TypeConstraint "extends"'), Type);
     function TypeConstraint(state) {
       if (state.verbose)
         console.log("ENTER:", "TypeConstraint");
@@ -4256,7 +4319,7 @@ var require_parser = __commonJS({
         return EOF$0(state);
       }
     }
-    var Debugger$0 = $TV($EXPECT($L16, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
+    var Debugger$0 = $TV($EXPECT($L1, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
       debugger;
     });
     function Debugger(state) {
@@ -4268,7 +4331,7 @@ var require_parser = __commonJS({
         return Debugger$0(state);
       }
     }
-    var InsertOpenParen$0 = $TV($EXPECT($L16, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
+    var InsertOpenParen$0 = $TV($EXPECT($L1, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: "(" };
     });
     function InsertOpenParen(state) {
@@ -4280,7 +4343,7 @@ var require_parser = __commonJS({
         return InsertOpenParen$0(state);
       }
     }
-    var InsertCloseParen$0 = $TV($EXPECT($L16, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
+    var InsertCloseParen$0 = $TV($EXPECT($L1, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: ")" };
     });
     function InsertCloseParen(state) {
@@ -4292,7 +4355,7 @@ var require_parser = __commonJS({
         return InsertCloseParen$0(state);
       }
     }
-    var InsertOpenBrace$0 = $TV($EXPECT($L16, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
+    var InsertOpenBrace$0 = $TV($EXPECT($L1, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
       return [{ $loc, token: " " }, { $loc, token: "{" }];
     });
     function InsertOpenBrace(state) {
@@ -4304,7 +4367,7 @@ var require_parser = __commonJS({
         return InsertOpenBrace$0(state);
       }
     }
-    var InsertCloseBrace$0 = $TV($EXPECT($L16, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
+    var InsertCloseBrace$0 = $TV($EXPECT($L1, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: "}" };
     });
     function InsertCloseBrace(state) {
@@ -4316,7 +4379,7 @@ var require_parser = __commonJS({
         return InsertCloseBrace$0(state);
       }
     }
-    var InsertConst$0 = $TV($EXPECT($L16, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
+    var InsertConst$0 = $TV($EXPECT($L1, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: "const " };
     });
     function InsertConst(state) {
@@ -4328,7 +4391,7 @@ var require_parser = __commonJS({
         return InsertConst$0(state);
       }
     }
-    var InsertReadonly$0 = $TV($EXPECT($L16, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
+    var InsertReadonly$0 = $TV($EXPECT($L1, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
       return { ts: true, children: [{ $loc, token: "readonly " }] };
     });
     function InsertReadonly(state) {
@@ -4340,7 +4403,7 @@ var require_parser = __commonJS({
         return InsertReadonly$0(state);
       }
     }
-    var InsertNewline$0 = $TV($EXPECT($L16, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
+    var InsertNewline$0 = $TV($EXPECT($L1, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
       return "\n";
     });
     function InsertNewline(state) {
@@ -4352,8 +4415,8 @@ var require_parser = __commonJS({
         return InsertNewline$0(state);
       }
     }
-    var InsertIndent$0 = $TV($EXPECT($L16, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
-      return "".padStart(global.currentIndent * 2);
+    var InsertIndent$0 = $TV($EXPECT($L1, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
+      return "".padStart(module2.currentIndent * 2);
     });
     function InsertIndent(state) {
       if (state.verbose)
@@ -4364,7 +4427,7 @@ var require_parser = __commonJS({
         return InsertIndent$0(state);
       }
     }
-    var InsertSpace$0 = $TV($EXPECT($L16, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
+    var InsertSpace$0 = $TV($EXPECT($L1, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: " " };
     });
     function InsertSpace(state) {
@@ -4376,7 +4439,7 @@ var require_parser = __commonJS({
         return InsertSpace$0(state);
       }
     }
-    var InsertDot$0 = $TV($EXPECT($L16, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
+    var InsertDot$0 = $TV($EXPECT($L1, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: "." };
     });
     function InsertDot(state) {
@@ -4388,7 +4451,7 @@ var require_parser = __commonJS({
         return InsertDot$0(state);
       }
     }
-    var InsertBreak$0 = $TV($EXPECT($L16, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
+    var InsertBreak$0 = $TV($EXPECT($L1, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
       return { $loc, token: "break;" };
     });
     function InsertBreak(state) {
@@ -4400,11 +4463,13 @@ var require_parser = __commonJS({
         return InsertBreak$0(state);
       }
     }
-    var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L16, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
+    var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L1, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
       var directives = $2;
-      global.currentIndent = 0;
-      global.indentLevels = [0];
-      global.verbose = false;
+      module2.lastIndent = 0;
+      module2.trackedIndents = [0];
+      module2.currentIndent = 0;
+      module2.indentLevels = [0];
+      module2.verbose = false;
       if (directives) {
         const compatRe = /use coffee-compat/;
         module2.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
@@ -4435,7 +4500,13 @@ var require_parser = __commonJS({
       }
     }
     var Indent$0 = $TV($Q($C($EXPECT($L139, fail, 'Indent "  "'), $EXPECT($L140, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
-      return $1.length;
+      const level = $1.length;
+      module2.lastIndent = level;
+      return {
+        $loc,
+        token: "".padStart(level * 2),
+        level
+      };
     });
     function Indent(state) {
       if (state.verbose)
@@ -4446,13 +4517,70 @@ var require_parser = __commonJS({
         return Indent$0(state);
       }
     }
-    var PushIndent$0 = $TV($EXPECT($L16, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
-      global.currentIndent++;
-      if (global.verbose) {
-        console.log("pushing indent", global.currentIndent);
+    var TrackIndent$0 = $TV($EXPECT($L1, fail, 'TrackIndent ""'), function($skip, $loc, $0, $1) {
+      module2.trackedIndents.push(module2.lastIndent);
+    });
+    function TrackIndent(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TrackIndent");
+      if (state.tokenize) {
+        return $TOKEN("TrackIndent", state, TrackIndent$0(state));
+      } else {
+        return TrackIndent$0(state);
+      }
+    }
+    var RestoreIndent$0 = $TV($EXPECT($L1, fail, 'RestoreIndent ""'), function($skip, $loc, $0, $1) {
+      const topLevel = module2.trackedIndents.pop();
+      module2.lastIndent = topLevel;
+    });
+    function RestoreIndent(state) {
+      if (state.verbose)
+        console.log("ENTER:", "RestoreIndent");
+      if (state.tokenize) {
+        return $TOKEN("RestoreIndent", state, RestoreIndent$0(state));
+      } else {
+        return RestoreIndent$0(state);
+      }
+    }
+    var Samedent$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
+      var indent = $2;
+      if (indent.level === module2.trackedIndents[module2.trackedIndents.length - 1]) {
+        return $0;
       }
-      global.indentLevels.push(global.currentIndent);
-      return global.currentIndent;
+      return $skip;
+    });
+    function Samedent(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Samedent");
+      if (state.tokenize) {
+        return $TOKEN("Samedent", state, Samedent$0(state));
+      } else {
+        return Samedent$0(state);
+      }
+    }
+    var IndentedFurther$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
+      var indent = $2;
+      if (indent.level > module2.trackedIndents[module2.trackedIndents.length - 1]) {
+        return $0;
+      }
+      return $skip;
+    });
+    function IndentedFurther(state) {
+      if (state.verbose)
+        console.log("ENTER:", "IndentedFurther");
+      if (state.tokenize) {
+        return $TOKEN("IndentedFurther", state, IndentedFurther$0(state));
+      } else {
+        return IndentedFurther$0(state);
+      }
+    }
+    var PushIndent$0 = $TV($EXPECT($L1, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
+      module2.currentIndent++;
+      if (module2.verbose) {
+        console.log("pushing indent", module2.currentIndent);
+      }
+      module2.indentLevels.push(module2.currentIndent);
+      return module2.currentIndent;
     });
     function PushIndent(state) {
       if (state.verbose)
@@ -4463,13 +4591,13 @@ var require_parser = __commonJS({
         return PushIndent$0(state);
       }
     }
-    var PopIndent$0 = $TV($EXPECT($L16, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
-      if (global.verbose) {
-        console.log("popping indent", global.indentLevels[global.indentLevels.length - 1], "->", global.indentLevels[global.indentLevels.length - 2]);
+    var PopIndent$0 = $TV($EXPECT($L1, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
+      if (module2.verbose) {
+        console.log("popping indent", module2.indentLevels[module2.indentLevels.length - 1], "->", module2.indentLevels[module2.indentLevels.length - 2]);
       }
-      global.indentLevels.pop();
-      global.currentIndent = global.indentLevels[global.indentLevels.length - 1];
-      return global.currentIndent;
+      module2.indentLevels.pop();
+      module2.currentIndent = module2.indentLevels[module2.indentLevels.length - 1];
+      return module2.currentIndent;
     });
     function PopIndent(state) {
       if (state.verbose)
@@ -4483,18 +4611,19 @@ var require_parser = __commonJS({
     var Nested$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
       var eos = $1;
       var indent = $2;
-      const currentIndent = global.indentLevels[global.indentLevels.length - 1];
-      if (global.verbose) {
-        console.log("global indent", global.currentIndent);
-        console.log("Indented", indent, currentIndent);
-      }
-      if (indent !== currentIndent) {
-        if (global.verbose) {
+      const { level } = indent;
+      const currentIndent = module2.indentLevels[module2.indentLevels.length - 1];
+      if (module2.verbose) {
+        console.log("global indent", module2.currentIndent);
+        console.log("Indented", level, currentIndent);
+      }
+      if (level !== currentIndent) {
+        if (module2.verbose) {
           console.log("skipped nested");
         }
         return $skip;
       }
-      return [eos, "".padStart(indent * 2)];
+      return $0;
     });
     function Nested(state) {
       if (state.verbose)
@@ -4505,31 +4634,6 @@ var require_parser = __commonJS({
         return Nested$0(state);
       }
     }
-    var NestedFurther$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
-      var eos = $1;
-      var indent = $2;
-      const currentIndent = global.indentLevels[global.indentLevels.length - 1];
-      if (global.verbose) {
-        console.log("global indent", global.currentIndent);
-        console.log("Indented", indent, currentIndent);
-      }
-      if (indent !== currentIndent + 1) {
-        if (global.verbose) {
-          console.log("skipped nested");
-        }
-        return $skip;
-      }
-      return [eos, "".padStart(indent * 2)];
-    });
-    function NestedFurther(state) {
-      if (state.verbose)
-        console.log("ENTER:", "NestedFurther");
-      if (state.tokenize) {
-        return $TOKEN("NestedFurther", state, NestedFurther$0(state));
-      } else {
-        return NestedFurther$0(state);
-      }
-    }
     module2.exports = {
       parse: parse2
     };