@danielx/civet 0.4.0 → 0.4.1

package/dist/browser.js

@@ -409,9 +409,13 @@ var Civet = (() => {
         TopLevelStatement,
         Expression,
         Arguments,
+        ArgumentsWithTrailingCallExpressions,
         ArgumentList,
         NestedArgumentList,
         NestedArgument,
+        ImplicitApplication,
+        ApplicationStart,
+        IndentedApplicationAllowed,
         CommaExpression,
         BinaryOpExpression,
         UnaryExpression,
@@ -445,8 +449,6 @@ var Civet = (() => {
         CallExpressionRest,
         OptionalShorthand,
         NonNullAssertion,
-        SpacedApplication,
-        ApplicationStart,
         AdditionalReservedWords,
         MemberExpression,
         MemberExpressionRest,
@@ -460,8 +462,12 @@ var Civet = (() => {
         BindingPattern,
         ObjectBindingPattern,
         ArrayBindingPattern,
+        NestedBindingProperties,
+        NestedBindingProperty,
         BindingProperty,
         BindingRestProperty,
+        NestedBindingElements,
+        NestedBindingElement,
         BindingElement,
         BindingRestElement,
         FunctionDeclaration,
@@ -490,6 +496,7 @@ var Civet = (() => {
         ArrayElementExpression,
         Elision,
         ObjectLiteral,
+        NestedObjectLiteral,
         NestedPropertyDefinitions,
         NestedPropertyDefinition,
         ObjectPropertyDelimiter,
@@ -501,12 +508,6 @@ var Civet = (() => {
         MethodSignature,
         ClassElementName,
         PrivateIdentifier,
-        GeneratorMethod,
-        GeneratorBody,
-        AsyncMethod,
-        AsyncFunctionBody,
-        AsyncGeneratorMethod,
-        AsyncGeneratorBody,
         AssignmentOp,
         AssignmentOpSymbol,
         BinaryOp,
@@ -527,7 +528,6 @@ var Civet = (() => {
         ForStatement,
         ForInOfStatement,
         ForDeclaration,
-        LetOrConst,
         ForBinding,
         SwitchStatement,
         CaseBlock,
@@ -541,6 +541,8 @@ var Civet = (() => {
         Finally,
         CatchParameter,
         Condition,
+        ExpressionWithIndentedApplicationSuppressed,
+        SuppressIndentedApplication,
         ExpressionStatement,
         KeywordStatement,
         MaybeNestedExpression,
@@ -621,9 +623,11 @@ var Civet = (() => {
         For,
         From,
         Function,
+        GetOrSet,
         If,
         Import,
         In,
+        LetOrConst,
         Loop,
         New,
         Of,
@@ -712,38 +716,41 @@ var Civet = (() => {
         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("/=");
@@ -794,38 +801,38 @@ var Civet = (() => {
       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");
@@ -926,17 +933,30 @@ var Civet = (() => {
         }
       }
       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));
@@ -969,7 +989,44 @@ var Civet = (() => {
           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 (module.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");
@@ -1027,7 +1084,7 @@ var Civet = (() => {
           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) {
@@ -1070,7 +1127,7 @@ var Civet = (() => {
           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");
@@ -1089,7 +1146,7 @@ var Civet = (() => {
           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 " =>";
@@ -1105,15 +1162,7 @@ var Civet = (() => {
         }
       }
       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);
@@ -1153,7 +1202,7 @@ var Civet = (() => {
       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) {
@@ -1173,7 +1222,7 @@ var Civet = (() => {
           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");
@@ -1193,10 +1242,10 @@ var Civet = (() => {
           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) {
@@ -1266,11 +1315,11 @@ var Civet = (() => {
           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) {
@@ -1280,7 +1329,7 @@ var Civet = (() => {
           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) {
@@ -1311,8 +1360,8 @@ var Civet = (() => {
           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) {
@@ -1321,15 +1370,14 @@ var Civet = (() => {
           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));
@@ -1342,7 +1390,7 @@ var Civet = (() => {
           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) {
@@ -1354,31 +1402,6 @@ var Civet = (() => {
           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)
@@ -1399,10 +1422,10 @@ var Civet = (() => {
           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";
@@ -1425,7 +1448,7 @@ var Civet = (() => {
           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");
@@ -1436,7 +1459,7 @@ var Civet = (() => {
         }
       }
       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) {
@@ -1447,7 +1470,7 @@ var Civet = (() => {
         }
       }
       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) {
@@ -1468,8 +1491,8 @@ var Civet = (() => {
         }
       }
       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) {
@@ -1482,7 +1505,7 @@ var Civet = (() => {
           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");
@@ -1492,8 +1515,8 @@ var Civet = (() => {
           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));
@@ -1501,28 +1524,54 @@ var Civet = (() => {
           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));
@@ -1530,7 +1579,7 @@ var Civet = (() => {
           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");
@@ -1540,6 +1589,34 @@ var Civet = (() => {
           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)
@@ -1550,7 +1627,7 @@ var Civet = (() => {
           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");
@@ -1571,7 +1648,7 @@ var Civet = (() => {
         }
       }
       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));
@@ -1600,7 +1677,7 @@ var Civet = (() => {
           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) {
@@ -1693,7 +1770,7 @@ var Civet = (() => {
           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) {
@@ -1705,7 +1782,7 @@ var Civet = (() => {
           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) {
@@ -1717,7 +1794,7 @@ var Civet = (() => {
           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) {
@@ -1799,7 +1876,7 @@ var Civet = (() => {
         }
       }
       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: "," };
       });
@@ -1830,7 +1907,7 @@ var Civet = (() => {
           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");
@@ -1853,7 +1930,7 @@ var Civet = (() => {
       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));
@@ -1861,6 +1938,16 @@ var Civet = (() => {
           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)
@@ -1887,18 +1974,15 @@ var Civet = (() => {
         }
       }
       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)));
@@ -1913,7 +1997,7 @@ var Civet = (() => {
       }
       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) {
@@ -1925,7 +2009,7 @@ var Civet = (() => {
       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));
@@ -1933,27 +2017,25 @@ var Civet = (() => {
           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);
@@ -1975,7 +2057,7 @@ var Civet = (() => {
           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");
@@ -1985,66 +2067,6 @@ var Civet = (() => {
           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 };
       });
@@ -2096,7 +2118,7 @@ var Civet = (() => {
         }
       }
       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 "+"');
@@ -2104,7 +2126,7 @@ var Civet = (() => {
       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 ">"');
@@ -2185,7 +2207,7 @@ var Civet = (() => {
           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;
@@ -2319,7 +2341,7 @@ var Civet = (() => {
         var cond = $3;
         if (kind === "until") {
           cond[1] = "(!(";
-          cond[5] = "))";
+          cond[4] = "))";
           return ["while", cond];
         }
         return $0;
@@ -2333,7 +2355,7 @@ var Civet = (() => {
           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");
@@ -2343,8 +2365,8 @@ var Civet = (() => {
           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) {
@@ -2364,18 +2386,6 @@ var Civet = (() => {
           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) {
@@ -2429,9 +2439,9 @@ var Civet = (() => {
           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));
@@ -2440,7 +2450,7 @@ var Civet = (() => {
         }
       }
       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) {
@@ -2486,7 +2496,7 @@ var Civet = (() => {
           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");
@@ -2505,8 +2515,8 @@ var Civet = (() => {
           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));
@@ -2514,6 +2524,34 @@ var Civet = (() => {
           return Condition$0(state) || Condition$1(state);
         }
       }
+      var ExpressionWithIndentedApplicationSuppressed$0 = $TS($S(SuppressIndentedApplication, $E(Expression)), function($skip, $loc, $0, $1, $2) {
+        var exp = $2;
+        module.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) {
+        module.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)
@@ -2524,11 +2562,11 @@ var Civet = (() => {
           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));
@@ -2545,7 +2583,7 @@ var Civet = (() => {
           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);
@@ -2568,7 +2606,7 @@ var Civet = (() => {
           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) {
@@ -2590,7 +2628,7 @@ var Civet = (() => {
           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");
@@ -2683,7 +2721,7 @@ var Civet = (() => {
           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) {
@@ -2693,7 +2731,7 @@ var Civet = (() => {
           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) {
@@ -2760,7 +2798,7 @@ var Civet = (() => {
           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) {
@@ -2906,10 +2944,10 @@ var Civet = (() => {
         var e = $3;
         return [s, module.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) {
@@ -3005,7 +3043,7 @@ var Civet = (() => {
           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");
@@ -3015,7 +3053,7 @@ var Civet = (() => {
           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");
@@ -3074,7 +3112,7 @@ var Civet = (() => {
           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) {
@@ -3100,7 +3138,7 @@ var Civet = (() => {
           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) {
@@ -3112,7 +3150,7 @@ var Civet = (() => {
           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) {
@@ -3189,7 +3227,7 @@ var Civet = (() => {
         }
       }
       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) {
@@ -3209,7 +3247,7 @@ var Civet = (() => {
           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) {
@@ -3221,7 +3259,7 @@ var Civet = (() => {
           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) {
@@ -3233,7 +3271,7 @@ var Civet = (() => {
           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) {
@@ -3245,7 +3283,7 @@ var Civet = (() => {
           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) {
@@ -3257,7 +3295,7 @@ var Civet = (() => {
           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) {
@@ -3269,7 +3307,7 @@ var Civet = (() => {
           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) {
@@ -3281,7 +3319,7 @@ var Civet = (() => {
           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) {
@@ -3293,7 +3331,7 @@ var Civet = (() => {
           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) {
@@ -3305,7 +3343,7 @@ var Civet = (() => {
           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) {
@@ -3317,7 +3355,7 @@ var Civet = (() => {
           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) {
@@ -3329,7 +3367,7 @@ var Civet = (() => {
           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) {
@@ -3341,7 +3379,7 @@ var Civet = (() => {
           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) {
@@ -3365,7 +3403,7 @@ var Civet = (() => {
           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) {
@@ -3377,7 +3415,7 @@ var Civet = (() => {
           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) {
@@ -3389,7 +3427,7 @@ var Civet = (() => {
           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) {
@@ -3401,7 +3439,7 @@ var Civet = (() => {
           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) {
@@ -3413,7 +3451,19 @@ var Civet = (() => {
           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) {
@@ -3425,7 +3475,7 @@ var Civet = (() => {
           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) {
@@ -3449,6 +3499,18 @@ var Civet = (() => {
           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)" };
       });
@@ -3560,13 +3622,14 @@ var Civet = (() => {
       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) {
@@ -3679,7 +3742,7 @@ var Civet = (() => {
           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");
@@ -3689,7 +3752,7 @@ var Civet = (() => {
           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");
@@ -3749,7 +3812,7 @@ var Civet = (() => {
           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) {
@@ -3821,7 +3884,7 @@ var Civet = (() => {
           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");
@@ -4111,7 +4174,7 @@ var Civet = (() => {
           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");
@@ -4140,7 +4203,7 @@ var Civet = (() => {
           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");
@@ -4150,7 +4213,7 @@ var Civet = (() => {
           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");
@@ -4160,7 +4223,7 @@ var Civet = (() => {
           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) {
@@ -4182,7 +4245,7 @@ var Civet = (() => {
           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");
@@ -4257,7 +4320,7 @@ var Civet = (() => {
           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) {
@@ -4269,7 +4332,7 @@ var Civet = (() => {
           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) {
@@ -4281,7 +4344,7 @@ var Civet = (() => {
           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) {
@@ -4293,7 +4356,7 @@ var Civet = (() => {
           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) {
@@ -4305,7 +4368,7 @@ var Civet = (() => {
           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) {
@@ -4317,7 +4380,7 @@ var Civet = (() => {
           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) {
@@ -4329,7 +4392,7 @@ var Civet = (() => {
           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) {
@@ -4341,7 +4404,7 @@ var Civet = (() => {
           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) {
@@ -4353,8 +4416,8 @@ var Civet = (() => {
           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(module.currentIndent * 2);
       });
       function InsertIndent(state) {
         if (state.verbose)
@@ -4365,7 +4428,7 @@ var Civet = (() => {
           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) {
@@ -4377,7 +4440,7 @@ var Civet = (() => {
           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) {
@@ -4389,7 +4452,7 @@ var Civet = (() => {
           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) {
@@ -4401,11 +4464,13 @@ var Civet = (() => {
           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;
+        module.lastIndent = 0;
+        module.trackedIndents = [0];
+        module.currentIndent = 0;
+        module.indentLevels = [0];
+        module.verbose = false;
         if (directives) {
           const compatRe = /use coffee-compat/;
           module.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
@@ -4436,7 +4501,13 @@ var Civet = (() => {
         }
       }
       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;
+        module.lastIndent = level;
+        return {
+          $loc,
+          token: "".padStart(level * 2),
+          level
+        };
       });
       function Indent(state) {
         if (state.verbose)
@@ -4447,13 +4518,70 @@ var Civet = (() => {
           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) {
+        module.trackedIndents.push(module.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 = module.trackedIndents.pop();
+        module.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 === module.trackedIndents[module.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 > module.trackedIndents[module.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) {
+        module.currentIndent++;
+        if (module.verbose) {
+          console.log("pushing indent", module.currentIndent);
+        }
+        module.indentLevels.push(module.currentIndent);
+        return module.currentIndent;
       });
       function PushIndent(state) {
         if (state.verbose)
@@ -4464,13 +4592,13 @@ var Civet = (() => {
           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 (module.verbose) {
+          console.log("popping indent", module.indentLevels[module.indentLevels.length - 1], "->", module.indentLevels[module.indentLevels.length - 2]);
         }
-        global.indentLevels.pop();
-        global.currentIndent = global.indentLevels[global.indentLevels.length - 1];
-        return global.currentIndent;
+        module.indentLevels.pop();
+        module.currentIndent = module.indentLevels[module.indentLevels.length - 1];
+        return module.currentIndent;
       });
       function PopIndent(state) {
         if (state.verbose)
@@ -4484,18 +4612,19 @@ var Civet = (() => {
       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 = module.indentLevels[module.indentLevels.length - 1];
+        if (module.verbose) {
+          console.log("global indent", module.currentIndent);
+          console.log("Indented", level, currentIndent);
+        }
+        if (level !== currentIndent) {
+          if (module.verbose) {
             console.log("skipped nested");
           }
           return $skip;
         }
-        return [eos, "".padStart(indent * 2)];
+        return $0;
       });
       function Nested(state) {
         if (state.verbose)
@@ -4506,31 +4635,6 @@ var Civet = (() => {
           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);
-        }
-      }
       module.exports = {
         parse
       };