@danielx/civet 0.3.15 → 0.4.0

package/dist/browser.js

@@ -430,14 +430,12 @@ var Civet = (() => {
         PrimaryExpression,
         ClassDeclaration,
         ClassExpression,
-        Class,
         ClassHeritage,
         ExtendsToken,
         ClassBody,
         NestedClassElements,
         NestedClassElement,
         ClassElement,
-        Static,
         FieldDefinition,
         This,
         AtAccessor,
@@ -528,7 +526,6 @@ var Civet = (() => {
         WhileClause,
         ForStatement,
         ForInOfStatement,
-        For,
         ForDeclaration,
         LetOrConst,
         ForBinding,
@@ -537,10 +534,9 @@ var Civet = (() => {
         NestedCaseClauses,
         NestedCaseClause,
         CaseClause,
-        When,
         ImpliedColon,
         TryStatement,
-        Catch,
+        CatchClause,
         CatchBind,
         Finally,
         CatchParameter,
@@ -548,15 +544,12 @@ var Civet = (() => {
         ExpressionStatement,
         KeywordStatement,
         MaybeNestedExpression,
-        Return,
         ImportDeclaration,
         ImpliedImport,
-        Import,
         ImportClause,
         NameSpaceImport,
         NamedImports,
         FromClause,
-        From,
         ImportSpecifier,
         ModuleExportName,
         ModuleSpecifier,
@@ -564,8 +557,6 @@ var Civet = (() => {
         UnquotedSpecifier,
         ImportedBinding,
         ExportDeclaration,
-        As,
-        Export,
         ExportFromClause,
         NamedExports,
         ExportSpecifier,
@@ -588,8 +579,8 @@ var Civet = (() => {
         StringLiteral,
         DoubleStringCharacter,
         SingleStringCharacter,
-        TripleDoubleStringCharacter,
-        TripleSingleStringCharacter,
+        TripleDoubleStringCharacters,
+        TripleSingleStringCharacters,
         RegularExpressionLiteral,
         RegularExpressionBody,
         RegExpCharacter,
@@ -608,9 +599,49 @@ var Civet = (() => {
         RestOfLine,
         TrailingComment,
         _,
+        NonNewlineWhitespace,
         __,
+        Whitespace,
         StatementDelimiter,
         NonIdContinue,
+        Loc,
+        As,
+        Async,
+        Await,
+        Catch,
+        Class,
+        CloseBrace,
+        CloseBracket,
+        CloseParen,
+        Colon,
+        Dot,
+        Else,
+        Equals,
+        Export,
+        For,
+        From,
+        Function,
+        If,
+        Import,
+        In,
+        Loop,
+        New,
+        Of,
+        OpenBrace,
+        OpenBracket,
+        OpenParen,
+        QuestionMark,
+        Return,
+        Semicolon,
+        Static,
+        Switch,
+        Target,
+        TripleDoubleQuote,
+        TripleSingleQuote,
+        Try,
+        Unless,
+        Var,
+        When,
         JSXElement,
         JSXSelfClosingElement,
         JSXOpeningElement,
@@ -672,6 +703,8 @@ var Civet = (() => {
         InsertCloseParen,
         InsertOpenBrace,
         InsertCloseBrace,
+        InsertConst,
+        InsertReadonly,
         InsertNewline,
         InsertIndent,
         InsertSpace,
@@ -684,132 +717,132 @@ var Civet = (() => {
         Nested,
         NestedFurther
       });
-      var $L0 = $L(",");
-      var $L1 = $L("(");
-      var $L2 = $L(")");
-      var $L3 = $L("?");
-      var $L4 = $L("as");
-      var $L5 = $L("++");
-      var $L6 = $L("--");
-      var $L7 = $L("async");
-      var $L8 = $L("await");
-      var $L9 = $L("yield");
-      var $L10 = $L("*");
-      var $L11 = $L("=>");
-      var $L12 = $L("{");
-      var $L13 = $L("}");
-      var $L14 = $L(":");
-      var $L15 = $L("class");
-      var $L16 = $L("<");
-      var $L17 = $L("extends");
-      var $L18 = $L("static");
-      var $L19 = $L("this");
-      var $L20 = $L("#");
-      var $L21 = $L("@");
-      var $L22 = $L("new");
-      var $L23 = $L("super");
-      var $L24 = $L("import");
-      var $L25 = $L(".");
-      var $L26 = $L("!");
-      var $L27 = $L("[");
-      var $L28 = $L("]");
-      var $L29 = $L("::");
-      var $L30 = $L("super[");
-      var $L31 = $L("new.target");
-      var $L32 = $L("import.meta");
-      var $L33 = $L("");
-      var $L34 = $L("...");
-      var $L35 = $L("function");
-      var $L36 = $L("->");
-      var $L37 = $L("null");
-      var $L38 = $L("true");
-      var $L39 = $L("false");
-      var $L40 = $L("get");
-      var $L41 = $L("set");
-      var $L42 = $L("**=");
-      var $L43 = $L("*=");
-      var $L44 = $L("/=");
-      var $L45 = $L("%=");
-      var $L46 = $L("+=");
-      var $L47 = $L("-=");
-      var $L48 = $L("<<=");
-      var $L49 = $L(">>>=");
-      var $L50 = $L(">>=");
-      var $L51 = $L("&&=");
-      var $L52 = $L("&=");
-      var $L53 = $L("^=");
-      var $L54 = $L("||=");
-      var $L55 = $L("|=");
-      var $L56 = $L("??=");
-      var $L57 = $L("?=");
-      var $L58 = $L("=");
-      var $L59 = $L("**");
-      var $L60 = $L("/");
-      var $L61 = $L("%");
-      var $L62 = $L("+");
-      var $L63 = $L("-");
-      var $L64 = $L("<=");
-      var $L65 = $L(">=");
-      var $L66 = $L("<<");
-      var $L67 = $L(">>>");
-      var $L68 = $L(">>");
-      var $L69 = $L(">");
-      var $L70 = $L("!==");
-      var $L71 = $L("!=");
-      var $L72 = $L("is");
-      var $L73 = $L("===");
-      var $L74 = $L("==");
-      var $L75 = $L("and");
-      var $L76 = $L("&&");
-      var $L77 = $L("or");
-      var $L78 = $L("||");
-      var $L79 = $L("??");
-      var $L80 = $L("instanceof");
-      var $L81 = $L("in");
-      var $L82 = $L("&");
-      var $L83 = $L("^");
-      var $L84 = $L("|");
-      var $L85 = $L("delete");
-      var $L86 = $L("void");
-      var $L87 = $L("typeof");
-      var $L88 = $L("if");
-      var $L89 = $L("unless");
-      var $L90 = $L(";");
-      var $L91 = $L("else");
-      var $L92 = $L("loop");
-      var $L93 = $L("do");
-      var $L94 = $L("while");
-      var $L95 = $L("until");
-      var $L96 = $L("var");
-      var $L97 = $L("of");
-      var $L98 = $L("for");
-      var $L99 = $L("let");
-      var $L100 = $L("const");
-      var $L101 = $L("switch");
-      var $L102 = $L("case");
-      var $L103 = $L("default");
-      var $L104 = $L("when");
-      var $L105 = $L("try");
-      var $L106 = $L("catch");
-      var $L107 = $L("finally");
-      var $L108 = $L("break");
-      var $L109 = $L("continue");
-      var $L110 = $L("debugger");
-      var $L111 = $L("throw");
-      var $L112 = $L("return");
-      var $L113 = $L("import type");
-      var $L114 = $L("from");
-      var $L115 = $L("export");
-      var $L116 = $L(":=");
-      var $L117 = $L('"""');
-      var $L118 = $L("'''");
-      var $L119 = $L('"');
-      var $L120 = $L("'");
-      var $L121 = $L("`");
-      var $L122 = $L("${");
-      var $L123 = $L("/*");
-      var $L124 = $L("*/");
-      var $L125 = $L("###");
+      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");
+      var $L27 = $L("**=");
+      var $L28 = $L("*=");
+      var $L29 = $L("/=");
+      var $L30 = $L("%=");
+      var $L31 = $L("+=");
+      var $L32 = $L("-=");
+      var $L33 = $L("<<=");
+      var $L34 = $L(">>>=");
+      var $L35 = $L(">>=");
+      var $L36 = $L("&&=");
+      var $L37 = $L("&=");
+      var $L38 = $L("^=");
+      var $L39 = $L("||=");
+      var $L40 = $L("|=");
+      var $L41 = $L("??=");
+      var $L42 = $L("?=");
+      var $L43 = $L("=");
+      var $L44 = $L("**");
+      var $L45 = $L("/");
+      var $L46 = $L("%");
+      var $L47 = $L("+");
+      var $L48 = $L("-");
+      var $L49 = $L("<=");
+      var $L50 = $L(">=");
+      var $L51 = $L("<<");
+      var $L52 = $L(">>>");
+      var $L53 = $L(">>");
+      var $L54 = $L(">");
+      var $L55 = $L("!==");
+      var $L56 = $L("!=");
+      var $L57 = $L("is");
+      var $L58 = $L("===");
+      var $L59 = $L("==");
+      var $L60 = $L("and");
+      var $L61 = $L("&&");
+      var $L62 = $L("or");
+      var $L63 = $L("||");
+      var $L64 = $L("??");
+      var $L65 = $L("instanceof");
+      var $L66 = $L("in");
+      var $L67 = $L("&");
+      var $L68 = $L("^");
+      var $L69 = $L("|");
+      var $L70 = $L("delete");
+      var $L71 = $L("void");
+      var $L72 = $L("typeof");
+      var $L73 = $L(";");
+      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 $L109 = $L("loop");
+      var $L110 = $L("new");
+      var $L111 = $L("of");
+      var $L112 = $L("{");
+      var $L113 = $L("[");
+      var $L114 = $L("(");
+      var $L115 = $L("?");
+      var $L116 = $L("return");
+      var $L117 = $L("static");
+      var $L118 = $L("switch");
+      var $L119 = $L("target");
+      var $L120 = $L('"""');
+      var $L121 = $L("'''");
+      var $L122 = $L("try");
+      var $L123 = $L("unless");
+      var $L124 = $L("var");
+      var $L125 = $L("when");
       var $L126 = $L("/>");
       var $L127 = $L("</");
       var $L128 = $L("<>");
@@ -828,30 +861,30 @@ var Civet = (() => {
       var $R0 = $R(new RegExp("(of)(?!\\p{ID_Continue})", "suy"));
       var $R1 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
       var $R2 = $R(new RegExp("[!~+-]", "suy"));
-      var $R3 = $R(new RegExp("\\s", "suy"));
-      var $R4 = $R(new RegExp('[^;"\\s]+', "suy"));
-      var $R5 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
-      var $R6 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
-      var $R7 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
-      var $R8 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
-      var $R9 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
-      var $R10 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
-      var $R11 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
-      var $R12 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])+', "suy"));
-      var $R13 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])+", "suy"));
-      var $R14 = $R(new RegExp("[^*\\/\\r\\n]", "suy"));
-      var $R15 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
-      var $R16 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
-      var $R17 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
-      var $R18 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
-      var $R19 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
-      var $R20 = $R(new RegExp(".", "suy"));
-      var $R21 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
-      var $R22 = $R(new RegExp("[^\\r\\n]", "suy"));
-      var $R23 = $R(new RegExp("[ \\t]+", "suy"));
-      var $R24 = $R(new RegExp("[\\t ]+", "suy"));
-      var $R25 = $R(new RegExp("[\\s]+", "suy"));
-      var $R26 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
+      var $R3 = $R(new RegExp('[^;"\\s]+', "suy"));
+      var $R4 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
+      var $R5 = $R(new RegExp("\\d+(?:\\.\\d*)?", "suy"));
+      var $R6 = $R(new RegExp("0[bB][01](?:[01]|_[01])*", "suy"));
+      var $R7 = $R(new RegExp("0[oO][0-7](?:[0-7]|_[0-7])*", "suy"));
+      var $R8 = $R(new RegExp("0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*", "suy"));
+      var $R9 = $R(new RegExp('(?:\\\\.|[^"])+', "suy"));
+      var $R10 = $R(new RegExp("(?:\\\\.|[^'])+", "suy"));
+      var $R11 = $R(new RegExp('(?:"(?!"")|\\\\.|[^"])*', "suy"));
+      var $R12 = $R(new RegExp("(?:'(?!'')|\\\\.|[^'])*", "suy"));
+      var $R13 = $R(new RegExp("[*\\/\\r\\n]", "suy"));
+      var $R14 = $R(new RegExp("(?:\\\\.|[^\\/\\r\\n])+", "suy"));
+      var $R15 = $R(new RegExp("(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
+      var $R16 = $R(new RegExp("(?:\\$(?!\\{)|\\\\.|[^$`])+", "suy"));
+      var $R17 = $R(new RegExp("(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})", "suy"));
+      var $R18 = $R(new RegExp("\\/\\/[^\\r\\n]*", "suy"));
+      var $R19 = $R(new RegExp(".", "suy"));
+      var $R20 = $R(new RegExp("#([^\\r\\n]*)", "suy"));
+      var $R21 = $R(new RegExp("[^\\r\\n]", "suy"));
+      var $R22 = $R(new RegExp("[ \\t]+", "suy"));
+      var $R23 = $R(new RegExp("[\\t ]+", "suy"));
+      var $R24 = $R(new RegExp("[\\s]+", "suy"));
+      var $R25 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
+      var $R26 = $R(new RegExp("\\s", "suy"));
       var $R27 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
       var $R28 = $R(new RegExp('"[^"]*"', "suy"));
       var $R29 = $R(new RegExp("'[^']*'", "suy"));
@@ -882,7 +915,7 @@ var Civet = (() => {
           return TopLevelStatement$0(state);
         }
       }
-      var Expression$0 = $S(AssignmentExpression, $Q($S(__, $EXPECT($L0, fail, 'Expression ","'), AssignmentExpression)));
+      var Expression$0 = $S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression)));
       function Expression(state) {
         if (state.verbose)
           console.log("ENTER:", "Expression");
@@ -892,7 +925,7 @@ var Civet = (() => {
           return Expression$0(state);
         }
       }
-      var Arguments$0 = $S($EXPECT($L1, fail, 'Arguments "("'), $E(ArgumentList), $E($S(__, $EXPECT($L0, fail, 'Arguments ","'))), __, $EXPECT($L2, fail, 'Arguments ")"'));
+      var Arguments$0 = $S(OpenParen, $E(ArgumentList), $E($S(__, Comma)), __, CloseParen);
       function Arguments(state) {
         if (state.verbose)
           console.log("ENTER:", "Arguments");
@@ -936,7 +969,7 @@ var Civet = (() => {
           return NestedArgument$0(state);
         }
       }
-      var CommaExpression$0 = $S(__, $EXPECT($L0, fail, 'CommaExpression ","'), __, Expression);
+      var CommaExpression$0 = $S(__, Comma, __, Expression);
       function CommaExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "CommaExpression");
@@ -960,7 +993,7 @@ var Civet = (() => {
         var pre = $1;
         var exp = $2;
         var post = $3;
-        if (post === "?") {
+        if (post?.token === "?") {
           return ["(", pre, , "(", exp, ") != null)"];
         }
         return [pre, exp, post];
@@ -974,8 +1007,8 @@ var Civet = (() => {
           return UnaryExpression$0(state);
         }
       }
-      var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
-      var UnaryPostfix$1 = $T($S(__, $EXPECT($L4, fail, 'UnaryPostfix "as"'), NonIdContinue, Type), function(value) {
+      var UnaryPostfix$0 = QuestionMark;
+      var UnaryPostfix$1 = $T($S(__, As, NonIdContinue, Type), function(value) {
         return { "ts": true, "children": value };
       });
       function UnaryPostfix(state) {
@@ -994,7 +1027,7 @@ var Civet = (() => {
           return UpdateExpression$0(state) || UpdateExpression$1(state);
         }
       }
-      var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L5, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L6, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
+      var UpdateExpressionSymbol$0 = $TV($C($EXPECT($L0, fail, 'UpdateExpressionSymbol "++"'), $EXPECT($L1, fail, 'UpdateExpressionSymbol "--"')), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function UpdateExpressionSymbol(state) {
@@ -1017,7 +1050,7 @@ var Civet = (() => {
       }
       var AssignmentExpressionRest$0 = AwaitExpression;
       var AssignmentExpressionRest$1 = YieldExpression;
-      var AssignmentExpressionRest$2 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
+      var AssignmentExpressionRest$2 = $S($E($S(Async, __)), ArrowFunction);
       var AssignmentExpressionRest$3 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
       var AssignmentExpressionRest$4 = ConditionalExpression;
       function AssignmentExpressionRest(state) {
@@ -1027,7 +1060,7 @@ var Civet = (() => {
           return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state) || AssignmentExpressionRest$4(state);
         }
       }
-      var AwaitExpression$0 = $S($EXPECT($L8, fail, 'AwaitExpression "await"'), NonIdContinue, $Q(TrailingComment), AssignmentExpression);
+      var AwaitExpression$0 = $S(Await, $Q(TrailingComment), AssignmentExpression);
       function AwaitExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "AwaitExpression");
@@ -1037,7 +1070,7 @@ var Civet = (() => {
           return AwaitExpression$0(state);
         }
       }
-      var YieldExpression$0 = $S($EXPECT($L9, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L10, fail, 'YieldExpression "*"'))), AssignmentExpression);
+      var YieldExpression$0 = $S($EXPECT($L2, fail, 'YieldExpression "yield"'), NonIdContinue, $E($S($Q(TrailingComment), $EXPECT($L3, fail, 'YieldExpression "*"'))), AssignmentExpression);
       function YieldExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "YieldExpression");
@@ -1056,7 +1089,7 @@ var Civet = (() => {
           return ArrowFunction$0(state) || ArrowFunction$1(state);
         }
       }
-      var FatArrow$0 = $TS($S(__, $EXPECT($L11, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
+      var FatArrow$0 = $TS($S(__, $EXPECT($L4, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
         var ws = $1;
         if (!ws.length)
           return " =>";
@@ -1071,7 +1104,7 @@ var Civet = (() => {
           return FatArrow$0(state);
         }
       }
-      var FatArrowBody$0 = $S(__, $EXPECT($L12, fail, 'FatArrowBody "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'FatArrowBody "}"'));
+      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;
@@ -1091,7 +1124,7 @@ var Civet = (() => {
           return FatArrowBody$0(state) || FatArrowBody$1(state) || FatArrowBody$2(state) || FatArrowBody$3(state) || FatArrowBody$4(state);
         }
       }
-      var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L14, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
+      var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, QuestionMark, AssignmentExpression, __, Colon, AssignmentExpression)));
       function ConditionalExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "ConditionalExpression");
@@ -1120,7 +1153,7 @@ var Civet = (() => {
       var PrimaryExpression$6 = ClassExpression;
       var PrimaryExpression$7 = RegularExpressionLiteral;
       var PrimaryExpression$8 = TemplateLiteral;
-      var PrimaryExpression$9 = $S($EXPECT($L1, fail, 'PrimaryExpression "("'), __, Expression, __, $EXPECT($L2, fail, 'PrimaryExpression ")"'));
+      var PrimaryExpression$9 = $S(OpenParen, __, Expression, __, CloseParen);
       var PrimaryExpression$10 = JSXElement;
       var PrimaryExpression$11 = JSXFragment;
       function PrimaryExpression(state) {
@@ -1150,18 +1183,6 @@ var Civet = (() => {
           return ClassExpression$0(state);
         }
       }
-      var Class$0 = $TV($EXPECT($L15, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
-        return { $loc, token: $1 };
-      });
-      function Class(state) {
-        if (state.verbose)
-          console.log("ENTER:", "Class");
-        if (state.tokenize) {
-          return $TOKEN("Class", state, Class$0(state));
-        } else {
-          return Class$0(state);
-        }
-      }
       var ClassHeritage$0 = $S(ExtendsToken, __, MemberExpression);
       function ClassHeritage(state) {
         if (state.verbose)
@@ -1172,10 +1193,10 @@ var Civet = (() => {
           return ClassHeritage$0(state);
         }
       }
-      var ExtendsToken$0 = $TV($EXPECT($L16, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
+      var ExtendsToken$0 = $TV($EXPECT($L5, fail, 'ExtendsToken "<"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "extends" };
       });
-      var ExtendsToken$1 = $TV($EXPECT($L17, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
+      var ExtendsToken$1 = $TV($EXPECT($L6, fail, 'ExtendsToken "extends"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function ExtendsToken(state) {
@@ -1185,7 +1206,7 @@ var Civet = (() => {
           return ExtendsToken$0(state) || ExtendsToken$1(state);
         }
       }
-      var ClassBody$0 = $S(__, $EXPECT($L12, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L13, fail, 'ClassBody "}"'));
+      var ClassBody$0 = $S(__, OpenBrace, $E($S(EOS, NestedClassElements)), __, CloseBrace);
       var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
       function ClassBody(state) {
         if (state.tokenize) {
@@ -1228,32 +1249,14 @@ var Civet = (() => {
           return ClassElement$0(state) || ClassElement$1(state);
         }
       }
-      var Static$0 = $TV($EXPECT($L18, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
-        return { $loc, token: $1 };
-      });
-      function Static(state) {
-        if (state.verbose)
-          console.log("ENTER:", "Static");
-        if (state.tokenize) {
-          return $TOKEN("Static", state, Static$0(state));
-        } else {
-          return Static$0(state);
-        }
-      }
-      var FieldDefinition$0 = $TS($S(ClassElementName, $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-        var name = $1;
-        var suffix = $2;
-        var ws = $3;
-        var ca = $4;
-        var exp = $5;
-        return [
-          { ts: true, children: ["readonly "] },
-          name,
-          suffix,
-          ws,
-          { $loc: ca.$loc, token: "=" },
-          exp
-        ];
+      var FieldDefinition$0 = $TS($S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var r = $1;
+        var ca = $5;
+        r.children[0].$loc = {
+          pos: ca.$loc.pos - 1,
+          length: ca.$loc.length + 1
+        };
+        return $0;
       });
       var FieldDefinition$1 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
       function FieldDefinition(state) {
@@ -1263,11 +1266,11 @@ var Civet = (() => {
           return FieldDefinition$0(state) || FieldDefinition$1(state);
         }
       }
-      var This$0 = $TV($EXPECT($L19, fail, 'This "this"'), function($skip, $loc, $0, $1) {
+      var This$0 = $TV($EXPECT($L7, fail, 'This "this"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
-      var This$1 = $S(AtAccessor, $S($E($EXPECT($L20, fail, 'This "#"')), IdentifierName));
-      var This$2 = $TV($EXPECT($L21, fail, 'This "@"'), function($skip, $loc, $0, $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) {
         return { $loc, token: "this" };
       });
       function This(state) {
@@ -1277,7 +1280,7 @@ var Civet = (() => {
           return This$0(state) || This$1(state) || This$2(state);
         }
       }
-      var AtAccessor$0 = $TV($EXPECT($L21, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
+      var AtAccessor$0 = $TV($EXPECT($L9, fail, 'AtAccessor "@"'), function($skip, $loc, $0, $1) {
         return { $loc, token: "this." };
       });
       function AtAccessor(state) {
@@ -1298,7 +1301,7 @@ var Civet = (() => {
           return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
         }
       }
-      var NewExpression$0 = $S($P($S($EXPECT($L22, fail, 'NewExpression "new"'), __)), CallExpression);
+      var NewExpression$0 = $S($P($S(New, __)), CallExpression);
       function NewExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "NewExpression");
@@ -1308,8 +1311,8 @@ var Civet = (() => {
           return NewExpression$0(state);
         }
       }
-      var CallExpression$0 = $S($EXPECT($L23, fail, 'CallExpression "super"'), __, Arguments);
-      var CallExpression$1 = $S($EXPECT($L24, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
+      var CallExpression$0 = $S($EXPECT($L10, fail, 'CallExpression "super"'), __, Arguments);
+      var CallExpression$1 = $S($EXPECT($L11, fail, 'CallExpression "import"'), __, OpenParen, AssignmentExpression, __, CloseParen);
       var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest));
       function CallExpression(state) {
         if (state.tokenize) {
@@ -1329,7 +1332,7 @@ var Civet = (() => {
           return CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state);
         }
       }
-      var OptionalShorthand$0 = $S($EXPECT($L3, fail, 'OptionalShorthand "?"'), $C($EXPECT($L25, fail, 'OptionalShorthand "."'), InsertDot));
+      var OptionalShorthand$0 = $S(QuestionMark, $C(Dot, InsertDot));
       function OptionalShorthand(state) {
         if (state.verbose)
           console.log("ENTER:", "OptionalShorthand");
@@ -1339,7 +1342,7 @@ var Civet = (() => {
           return OptionalShorthand$0(state);
         }
       }
-      var NonNullAssertion$0 = $T($EXPECT($L26, fail, 'NonNullAssertion "!"'), function(value) {
+      var NonNullAssertion$0 = $T($EXPECT($L12, fail, 'NonNullAssertion "!"'), function(value) {
         return { "ts": true, "children": value };
       });
       function NonNullAssertion(state) {
@@ -1361,10 +1364,11 @@ var Civet = (() => {
           return SpacedApplication$0(state);
         }
       }
-      var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $N(EOS), $TEXT($P(_)), $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      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;
-        return [opt, "(", spacing.replace(/^ /, "")];
+        spacing[0].token = spacing[0].token.replace(/^ ?/, "(");
+        return [opt, spacing];
       });
       function ApplicationStart(state) {
         if (state.verbose)
@@ -1395,9 +1399,9 @@ var Civet = (() => {
           return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
         }
       }
-      var MemberExpressionRest$0 = $S($E($C(OptionalShorthand, NonNullAssertion)), $EXPECT($L27, fail, 'MemberExpressionRest "["'), __, Expression, __, $EXPECT($L28, fail, 'MemberExpressionRest "]"'));
+      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($L29, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
+      var MemberExpressionRest$2 = $TS($S($EXPECT($L13, fail, 'MemberExpressionRest "::"'), $E(IdentifierName)), function($skip, $loc, $0, $1, $2) {
         var id = $2;
         if (id)
           return [".prototype.", id];
@@ -1411,7 +1415,7 @@ var Civet = (() => {
           return MemberExpressionRest$0(state) || MemberExpressionRest$1(state) || MemberExpressionRest$2(state) || MemberExpressionRest$3(state);
         }
       }
-      var PropertyAccess$0 = $S($E($C($EXPECT($L3, fail, 'PropertyAccess "?"'), NonNullAssertion)), $EXPECT($L25, fail, 'PropertyAccess "."'), $C(IdentifierName, PrivateIdentifier));
+      var PropertyAccess$0 = $S($E($C(QuestionMark, NonNullAssertion)), Dot, $C(IdentifierName, PrivateIdentifier));
       function PropertyAccess(state) {
         if (state.verbose)
           console.log("ENTER:", "PropertyAccess");
@@ -1421,7 +1425,7 @@ var Civet = (() => {
           return PropertyAccess$0(state);
         }
       }
-      var SuperProperty$0 = $S($EXPECT($L30, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L28, fail, 'SuperProperty "]"'));
+      var SuperProperty$0 = $S($EXPECT($L14, fail, 'SuperProperty "super["'), __, Expression, __, CloseBracket);
       function SuperProperty(state) {
         if (state.verbose)
           console.log("ENTER:", "SuperProperty");
@@ -1431,8 +1435,10 @@ var Civet = (() => {
           return SuperProperty$0(state);
         }
       }
-      var MetaProperty$0 = $EXPECT($L31, fail, 'MetaProperty "new.target"');
-      var MetaProperty$1 = $EXPECT($L32, fail, 'MetaProperty "import.meta"');
+      var MetaProperty$0 = $S(New, Dot, Target);
+      var MetaProperty$1 = $TV($EXPECT($L15, fail, 'MetaProperty "import.meta"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
       function MetaProperty(state) {
         if (state.tokenize) {
           return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
@@ -1440,9 +1446,9 @@ var Civet = (() => {
           return MetaProperty$0(state) || MetaProperty$1(state);
         }
       }
-      var Parameters$0 = $S($E(TypeParameters), $EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
-      var Parameters$1 = $T($EXPECT($L33, fail, 'Parameters ""'), function(value) {
-        return "()";
+      var Parameters$0 = $S($E(TypeParameters), OpenParen, $Q(ParameterElement), __, CloseParen);
+      var Parameters$1 = $TV($EXPECT($L16, fail, 'Parameters ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "()" };
       });
       function Parameters(state) {
         if (state.tokenize) {
@@ -1461,13 +1467,13 @@ var Civet = (() => {
           return ParameterElement$0(state);
         }
       }
-      var ParameterElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ParameterElementDelimiter ","'));
-      var ParameterElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L2, fail, 'ParameterElementDelimiter ")"')));
-      var ParameterElementDelimiter$2 = $T($Y($S(__, $EXPECT($L2, fail, 'ParameterElementDelimiter ")"'))), function(value) {
-        return ",";
+      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) {
+        return { $loc, token: "," };
       });
-      var ParameterElementDelimiter$3 = $T($Y(EOS), function(value) {
-        return ",";
+      var ParameterElementDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
+        return { $loc, token: "," };
       });
       function ParameterElementDelimiter(state) {
         if (state.tokenize) {
@@ -1495,7 +1501,7 @@ var Civet = (() => {
           return BindingPattern$0(state) || BindingPattern$1(state);
         }
       }
-      var ObjectBindingPattern$0 = $S($EXPECT($L12, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L13, fail, 'ObjectBindingPattern "}"'));
+      var ObjectBindingPattern$0 = $S(OpenBrace, $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, CloseBrace);
       function ObjectBindingPattern(state) {
         if (state.verbose)
           console.log("ENTER:", "ObjectBindingPattern");
@@ -1505,7 +1511,7 @@ var Civet = (() => {
           return ObjectBindingPattern$0(state);
         }
       }
-      var ArrayBindingPattern$0 = $S($EXPECT($L27, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L28, fail, 'ArrayBindingPattern "]"'));
+      var ArrayBindingPattern$0 = $S(OpenBracket, $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, CloseBracket);
       function ArrayBindingPattern(state) {
         if (state.verbose)
           console.log("ENTER:", "ArrayBindingPattern");
@@ -1515,7 +1521,7 @@ var Civet = (() => {
           return ArrayBindingPattern$0(state);
         }
       }
-      var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L14, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $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) {
@@ -1524,7 +1530,7 @@ var Civet = (() => {
           return BindingProperty$0(state) || BindingProperty$1(state);
         }
       }
-      var BindingRestProperty$0 = $S($EXPECT($L34, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
+      var BindingRestProperty$0 = $S($EXPECT($L18, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
       function BindingRestProperty(state) {
         if (state.verbose)
           console.log("ENTER:", "BindingRestProperty");
@@ -1544,7 +1550,7 @@ var Civet = (() => {
           return BindingElement$0(state);
         }
       }
-      var BindingRestElement$0 = $S($EXPECT($L34, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
+      var BindingRestElement$0 = $S($EXPECT($L18, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
       function BindingRestElement(state) {
         if (state.verbose)
           console.log("ENTER:", "BindingRestElement");
@@ -1565,7 +1571,7 @@ var Civet = (() => {
         }
       }
       var FunctionExpression$0 = ThinArrowFunction;
-      var FunctionExpression$1 = $S($E($S($EXPECT($L7, fail, 'FunctionExpression "async"'), __)), $EXPECT($L35, fail, 'FunctionExpression "function"'), $E($S($EXPECT($L10, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
+      var FunctionExpression$1 = $S($E($S(Async, __)), Function, $E($S($EXPECT($L3, fail, 'FunctionExpression "*"'), __)), $E($S(__, BindingIdentifier)), __, Parameters, $E(ReturnTypeSuffix), BracedBlock);
       function FunctionExpression(state) {
         if (state.tokenize) {
           return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
@@ -1594,7 +1600,7 @@ var Civet = (() => {
           return ThinArrowFunction$0(state);
         }
       }
-      var Arrow$0 = $TV($EXPECT($L36, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
+      var Arrow$0 = $TV($EXPECT($L19, fail, 'Arrow "->"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function Arrow(state) {
@@ -1606,7 +1612,7 @@ var Civet = (() => {
           return Arrow$0(state);
         }
       }
-      var Block$0 = $S(__, $EXPECT($L12, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'Block "}"'));
+      var Block$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
       var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
       var Block$2 = Statement;
       var Block$3 = $S(__, Statement);
@@ -1626,7 +1632,7 @@ var Civet = (() => {
           return BracedOrEmptyBlock$0(state) || BracedOrEmptyBlock$1(state);
         }
       }
-      var BracedBlock$0 = $S(__, $EXPECT($L12, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'BracedBlock "}"'));
+      var BracedBlock$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
       var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
       var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
       function BracedBlock(state) {
@@ -1687,7 +1693,7 @@ var Civet = (() => {
           return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state);
         }
       }
-      var NullLiteral$0 = $TV($EXPECT($L37, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
+      var NullLiteral$0 = $TV($EXPECT($L20, fail, 'NullLiteral "null"'), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function NullLiteral(state) {
@@ -1699,7 +1705,7 @@ var Civet = (() => {
           return NullLiteral$0(state);
         }
       }
-      var BooleanLiteral$0 = $TV($C($EXPECT($L38, fail, 'BooleanLiteral "true"'), $EXPECT($L39, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
+      var BooleanLiteral$0 = $TV($C($EXPECT($L21, fail, 'BooleanLiteral "true"'), $EXPECT($L22, fail, 'BooleanLiteral "false"')), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function BooleanLiteral(state) {
@@ -1711,7 +1717,9 @@ var Civet = (() => {
           return BooleanLiteral$0(state);
         }
       }
-      var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
+      var Comma$0 = $TV($EXPECT($L23, fail, 'Comma ","'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
       function Comma(state) {
         if (state.verbose)
           console.log("ENTER:", "Comma");
@@ -1756,8 +1764,8 @@ var Civet = (() => {
           return IdentifierReference$0(state);
         }
       }
-      var ArrayLiteral$0 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
-      var ArrayLiteral$1 = $S($EXPECT($L27, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L28, fail, 'ArrayLiteral "]"'));
+      var ArrayLiteral$0 = $S(OpenBracket, NestedElementList, __, CloseBracket);
+      var ArrayLiteral$1 = $S(OpenBracket, ElementList, __, CloseBracket);
       function ArrayLiteral(state) {
         if (state.tokenize) {
           return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
@@ -1790,10 +1798,10 @@ var Civet = (() => {
           return NestedElement$0(state);
         }
       }
-      var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
-      var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L28, fail, 'ArrayElementDelimiter "]"')));
-      var ArrayElementDelimiter$2 = $T($Y(EOS), function(value) {
-        return ",";
+      var ArrayElementDelimiter$0 = $S($Q(_), Comma);
+      var ArrayElementDelimiter$1 = $Y($S(__, $EXPECT($L24, fail, 'ArrayElementDelimiter "]"')));
+      var ArrayElementDelimiter$2 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
+        return { $loc, token: "," };
       });
       function ArrayElementDelimiter(state) {
         if (state.tokenize) {
@@ -1802,7 +1810,7 @@ var Civet = (() => {
           return ArrayElementDelimiter$0(state) || ArrayElementDelimiter$1(state) || ArrayElementDelimiter$2(state);
         }
       }
-      var ElementList$0 = $S(ArrayElementExpression, $Q($S(__, $EXPECT($L0, fail, 'ElementList ","'), __, ArrayElementExpression)));
+      var ElementList$0 = $S(ArrayElementExpression, $Q($S(__, Comma, __, ArrayElementExpression)));
       function ElementList(state) {
         if (state.verbose)
           console.log("ENTER:", "ElementList");
@@ -1812,7 +1820,7 @@ var Civet = (() => {
           return ElementList$0(state);
         }
       }
-      var InlineElementList$0 = $S(ArrayElementExpression, $Q($S($Q(_), $EXPECT($L0, fail, 'InlineElementList ","'), $Q(_), ArrayElementExpression)));
+      var InlineElementList$0 = $S(ArrayElementExpression, $Q($S($Q(_), Comma, $Q(_), ArrayElementExpression)));
       function InlineElementList(state) {
         if (state.verbose)
           console.log("ENTER:", "InlineElementList");
@@ -1822,7 +1830,7 @@ var Civet = (() => {
           return InlineElementList$0(state);
         }
       }
-      var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L34, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
+      var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L18, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
       function ArrayElementExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "ArrayElementExpression");
@@ -1832,7 +1840,7 @@ var Civet = (() => {
           return ArrayElementExpression$0(state);
         }
       }
-      var Elision$0 = $S(__, $EXPECT($L0, fail, 'Elision ","'));
+      var Elision$0 = $S(__, Comma);
       function Elision(state) {
         if (state.verbose)
           console.log("ENTER:", "Elision");
@@ -1842,9 +1850,9 @@ var Civet = (() => {
           return Elision$0(state);
         }
       }
-      var ObjectLiteral$0 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L13, fail, 'ObjectLiteral "}"'));
-      var ObjectLiteral$1 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L13, fail, 'ObjectLiteral "}"'));
-      var ObjectLiteral$2 = $S($EXPECT($L12, fail, 'ObjectLiteral "{"'), __, $EXPECT($L13, fail, 'ObjectLiteral "}"'));
+      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);
       function ObjectLiteral(state) {
         if (state.tokenize) {
@@ -1878,13 +1886,13 @@ var Civet = (() => {
           return NestedPropertyDefinition$0(state);
         }
       }
-      var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
-      var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L13, fail, 'ObjectPropertyDelimiter "}"')));
-      var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L13, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
-        return ",";
+      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 = $T($Y(EOS), function(value) {
-        return ",";
+      var ObjectPropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
+        return { $loc, token: "," };
       });
       function ObjectPropertyDelimiter(state) {
         if (state.tokenize) {
@@ -1893,7 +1901,7 @@ var Civet = (() => {
           return ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state) || ObjectPropertyDelimiter$3(state);
         }
       }
-      var PropertyDefinitionList$0 = $S(PropertyDefinition, $Q($S(__, $EXPECT($L0, fail, 'PropertyDefinitionList ","'), __, PropertyDefinition)));
+      var PropertyDefinitionList$0 = $S(PropertyDefinition, $Q($S(__, Comma, __, PropertyDefinition)));
       function PropertyDefinitionList(state) {
         if (state.verbose)
           console.log("ENTER:", "PropertyDefinitionList");
@@ -1903,9 +1911,9 @@ var Civet = (() => {
           return PropertyDefinitionList$0(state);
         }
       }
-      var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L14, fail, 'PropertyDefinition ":"'), AssignmentExpression);
+      var PropertyDefinition$0 = $S(PropertyName, __, Colon, AssignmentExpression);
       var PropertyDefinition$1 = MethodDefinition;
-      var PropertyDefinition$2 = $S($EXPECT($L34, fail, 'PropertyDefinition "..."'), AssignmentExpression);
+      var PropertyDefinition$2 = $S($EXPECT($L18, fail, 'PropertyDefinition "..."'), AssignmentExpression);
       var PropertyDefinition$3 = IdentifierReference;
       function PropertyDefinition(state) {
         if (state.tokenize) {
@@ -1917,7 +1925,7 @@ var Civet = (() => {
       var PropertyName$0 = NumericLiteral;
       var PropertyName$1 = StringLiteral;
       var PropertyName$2 = IdentifierName;
-      var PropertyName$3 = $S($EXPECT($L27, fail, 'PropertyName "["'), AssignmentExpression, __, $EXPECT($L28, fail, 'PropertyName "]"'));
+      var PropertyName$3 = $S(OpenBracket, AssignmentExpression, __, $EXPECT($L24, fail, 'PropertyName "]"'));
       function PropertyName(state) {
         if (state.tokenize) {
           return $TOKEN("PropertyName", state, PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state));
@@ -1925,8 +1933,8 @@ var Civet = (() => {
           return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
         }
       }
-      var MethodDefinition$0 = $S($EXPECT($L40, fail, 'MethodDefinition "get"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
-      var MethodDefinition$1 = $S($EXPECT($L41, fail, 'MethodDefinition "set"'), NonIdContinue, $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
+      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;
@@ -1938,7 +1946,7 @@ var Civet = (() => {
           return MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state);
         }
       }
-      var MethodModifier$0 = $S($C($EXPECT($L40, fail, 'MethodModifier "get"'), $EXPECT($L41, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
+      var MethodModifier$0 = $S($C($EXPECT($L25, fail, 'MethodModifier "get"'), $EXPECT($L26, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
       function MethodModifier(state) {
         if (state.verbose)
           console.log("ENTER:", "MethodModifier");
@@ -1967,7 +1975,7 @@ var Civet = (() => {
           return ClassElementName$0(state) || ClassElementName$1(state);
         }
       }
-      var PrivateIdentifier$0 = $S($EXPECT($L20, fail, 'PrivateIdentifier "#"'), IdentifierName);
+      var PrivateIdentifier$0 = $S($EXPECT($L8, fail, 'PrivateIdentifier "#"'), IdentifierName);
       function PrivateIdentifier(state) {
         if (state.verbose)
           console.log("ENTER:", "PrivateIdentifier");
@@ -1977,7 +1985,7 @@ var Civet = (() => {
           return PrivateIdentifier$0(state);
         }
       }
-      var GeneratorMethod$0 = $S($EXPECT($L10, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
+      var GeneratorMethod$0 = $S($EXPECT($L3, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
       function GeneratorMethod(state) {
         if (state.verbose)
           console.log("ENTER:", "GeneratorMethod");
@@ -1997,7 +2005,7 @@ var Civet = (() => {
           return GeneratorBody$0(state);
         }
       }
-      var AsyncMethod$0 = $S($EXPECT($L7, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
+      var AsyncMethod$0 = $S(Async, $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
       function AsyncMethod(state) {
         if (state.verbose)
           console.log("ENTER:", "AsyncMethod");
@@ -2017,7 +2025,7 @@ var Civet = (() => {
           return AsyncFunctionBody$0(state);
         }
       }
-      var AsyncGeneratorMethod$0 = $S($EXPECT($L7, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L10, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
+      var AsyncGeneratorMethod$0 = $S(Async, $N(EOS), __, $EXPECT($L3, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
       function AsyncGeneratorMethod(state) {
         if (state.verbose)
           console.log("ENTER:", "AsyncGeneratorMethod");
@@ -2049,25 +2057,25 @@ var Civet = (() => {
           return AssignmentOp$0(state);
         }
       }
-      var AssignmentOpSymbol$0 = $EXPECT($L42, fail, 'AssignmentOpSymbol "**="');
-      var AssignmentOpSymbol$1 = $EXPECT($L43, fail, 'AssignmentOpSymbol "*="');
-      var AssignmentOpSymbol$2 = $EXPECT($L44, fail, 'AssignmentOpSymbol "/="');
-      var AssignmentOpSymbol$3 = $EXPECT($L45, fail, 'AssignmentOpSymbol "%="');
-      var AssignmentOpSymbol$4 = $EXPECT($L46, fail, 'AssignmentOpSymbol "+="');
-      var AssignmentOpSymbol$5 = $EXPECT($L47, fail, 'AssignmentOpSymbol "-="');
-      var AssignmentOpSymbol$6 = $EXPECT($L48, fail, 'AssignmentOpSymbol "<<="');
-      var AssignmentOpSymbol$7 = $EXPECT($L49, fail, 'AssignmentOpSymbol ">>>="');
-      var AssignmentOpSymbol$8 = $EXPECT($L50, fail, 'AssignmentOpSymbol ">>="');
-      var AssignmentOpSymbol$9 = $EXPECT($L51, fail, 'AssignmentOpSymbol "&&="');
-      var AssignmentOpSymbol$10 = $EXPECT($L52, fail, 'AssignmentOpSymbol "&="');
-      var AssignmentOpSymbol$11 = $EXPECT($L53, fail, 'AssignmentOpSymbol "^="');
-      var AssignmentOpSymbol$12 = $EXPECT($L54, fail, 'AssignmentOpSymbol "||="');
-      var AssignmentOpSymbol$13 = $EXPECT($L55, fail, 'AssignmentOpSymbol "|="');
-      var AssignmentOpSymbol$14 = $EXPECT($L56, fail, 'AssignmentOpSymbol "??="');
-      var AssignmentOpSymbol$15 = $T($EXPECT($L57, fail, 'AssignmentOpSymbol "?="'), function(value) {
+      var AssignmentOpSymbol$0 = $EXPECT($L27, fail, 'AssignmentOpSymbol "**="');
+      var AssignmentOpSymbol$1 = $EXPECT($L28, fail, 'AssignmentOpSymbol "*="');
+      var AssignmentOpSymbol$2 = $EXPECT($L29, fail, 'AssignmentOpSymbol "/="');
+      var AssignmentOpSymbol$3 = $EXPECT($L30, fail, 'AssignmentOpSymbol "%="');
+      var AssignmentOpSymbol$4 = $EXPECT($L31, fail, 'AssignmentOpSymbol "+="');
+      var AssignmentOpSymbol$5 = $EXPECT($L32, fail, 'AssignmentOpSymbol "-="');
+      var AssignmentOpSymbol$6 = $EXPECT($L33, fail, 'AssignmentOpSymbol "<<="');
+      var AssignmentOpSymbol$7 = $EXPECT($L34, fail, 'AssignmentOpSymbol ">>>="');
+      var AssignmentOpSymbol$8 = $EXPECT($L35, fail, 'AssignmentOpSymbol ">>="');
+      var AssignmentOpSymbol$9 = $EXPECT($L36, fail, 'AssignmentOpSymbol "&&="');
+      var AssignmentOpSymbol$10 = $EXPECT($L37, fail, 'AssignmentOpSymbol "&="');
+      var AssignmentOpSymbol$11 = $EXPECT($L38, fail, 'AssignmentOpSymbol "^="');
+      var AssignmentOpSymbol$12 = $EXPECT($L39, fail, 'AssignmentOpSymbol "||="');
+      var AssignmentOpSymbol$13 = $EXPECT($L40, fail, 'AssignmentOpSymbol "|="');
+      var AssignmentOpSymbol$14 = $EXPECT($L41, fail, 'AssignmentOpSymbol "??="');
+      var AssignmentOpSymbol$15 = $T($EXPECT($L42, fail, 'AssignmentOpSymbol "?="'), function(value) {
         return "??=";
       });
-      var AssignmentOpSymbol$16 = $EXPECT($L58, fail, 'AssignmentOpSymbol "="');
+      var AssignmentOpSymbol$16 = $EXPECT($L43, fail, 'AssignmentOpSymbol "="');
       function AssignmentOpSymbol(state) {
         if (state.tokenize) {
           return $TOKEN("AssignmentOpSymbol", state, AssignmentOpSymbol$0(state) || AssignmentOpSymbol$1(state) || AssignmentOpSymbol$2(state) || AssignmentOpSymbol$3(state) || AssignmentOpSymbol$4(state) || AssignmentOpSymbol$5(state) || AssignmentOpSymbol$6(state) || AssignmentOpSymbol$7(state) || AssignmentOpSymbol$8(state) || AssignmentOpSymbol$9(state) || AssignmentOpSymbol$10(state) || AssignmentOpSymbol$11(state) || AssignmentOpSymbol$12(state) || AssignmentOpSymbol$13(state) || AssignmentOpSymbol$14(state) || AssignmentOpSymbol$15(state) || AssignmentOpSymbol$16(state));
@@ -2087,52 +2095,52 @@ var Civet = (() => {
           return BinaryOp$0(state);
         }
       }
-      var BinaryOpSymbol$0 = $EXPECT($L59, fail, 'BinaryOpSymbol "**"');
-      var BinaryOpSymbol$1 = $EXPECT($L10, fail, 'BinaryOpSymbol "*"');
-      var BinaryOpSymbol$2 = $EXPECT($L60, fail, 'BinaryOpSymbol "/"');
-      var BinaryOpSymbol$3 = $EXPECT($L61, fail, 'BinaryOpSymbol "%"');
-      var BinaryOpSymbol$4 = $EXPECT($L62, fail, 'BinaryOpSymbol "+"');
-      var BinaryOpSymbol$5 = $EXPECT($L63, fail, 'BinaryOpSymbol "-"');
-      var BinaryOpSymbol$6 = $EXPECT($L64, fail, 'BinaryOpSymbol "<="');
-      var BinaryOpSymbol$7 = $EXPECT($L65, fail, 'BinaryOpSymbol ">="');
-      var BinaryOpSymbol$8 = $EXPECT($L66, fail, 'BinaryOpSymbol "<<"');
-      var BinaryOpSymbol$9 = $EXPECT($L16, fail, 'BinaryOpSymbol "<"');
-      var BinaryOpSymbol$10 = $EXPECT($L67, fail, 'BinaryOpSymbol ">>>"');
-      var BinaryOpSymbol$11 = $EXPECT($L68, fail, 'BinaryOpSymbol ">>"');
-      var BinaryOpSymbol$12 = $EXPECT($L69, fail, 'BinaryOpSymbol ">"');
-      var BinaryOpSymbol$13 = $EXPECT($L70, fail, 'BinaryOpSymbol "!=="');
-      var BinaryOpSymbol$14 = $TV($EXPECT($L71, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
+      var BinaryOpSymbol$0 = $EXPECT($L44, fail, 'BinaryOpSymbol "**"');
+      var BinaryOpSymbol$1 = $EXPECT($L3, fail, 'BinaryOpSymbol "*"');
+      var BinaryOpSymbol$2 = $EXPECT($L45, fail, 'BinaryOpSymbol "/"');
+      var BinaryOpSymbol$3 = $EXPECT($L46, fail, 'BinaryOpSymbol "%"');
+      var BinaryOpSymbol$4 = $EXPECT($L47, fail, 'BinaryOpSymbol "+"');
+      var BinaryOpSymbol$5 = $EXPECT($L48, fail, 'BinaryOpSymbol "-"');
+      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$10 = $EXPECT($L52, fail, 'BinaryOpSymbol ">>>"');
+      var BinaryOpSymbol$11 = $EXPECT($L53, fail, 'BinaryOpSymbol ">>"');
+      var BinaryOpSymbol$12 = $EXPECT($L54, fail, 'BinaryOpSymbol ">"');
+      var BinaryOpSymbol$13 = $EXPECT($L55, fail, 'BinaryOpSymbol "!=="');
+      var BinaryOpSymbol$14 = $TV($EXPECT($L56, fail, 'BinaryOpSymbol "!="'), function($skip, $loc, $0, $1) {
         if (module.coffeeCompat)
           return "!==";
         return $1;
       });
-      var BinaryOpSymbol$15 = $T($S($EXPECT($L72, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
+      var BinaryOpSymbol$15 = $T($S($EXPECT($L57, fail, 'BinaryOpSymbol "is"'), NonIdContinue), function(value) {
         return "===";
       });
-      var BinaryOpSymbol$16 = $EXPECT($L73, fail, 'BinaryOpSymbol "==="');
-      var BinaryOpSymbol$17 = $TV($EXPECT($L74, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
+      var BinaryOpSymbol$16 = $EXPECT($L58, fail, 'BinaryOpSymbol "==="');
+      var BinaryOpSymbol$17 = $TV($EXPECT($L59, fail, 'BinaryOpSymbol "=="'), function($skip, $loc, $0, $1) {
         if (module.coffeeCompat)
           return "===";
         return $1;
       });
-      var BinaryOpSymbol$18 = $T($S($EXPECT($L75, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
+      var BinaryOpSymbol$18 = $T($S($EXPECT($L60, fail, 'BinaryOpSymbol "and"'), NonIdContinue), function(value) {
         return "&&";
       });
-      var BinaryOpSymbol$19 = $EXPECT($L76, fail, 'BinaryOpSymbol "&&"');
-      var BinaryOpSymbol$20 = $T($S($EXPECT($L77, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
+      var BinaryOpSymbol$19 = $EXPECT($L61, fail, 'BinaryOpSymbol "&&"');
+      var BinaryOpSymbol$20 = $T($S($EXPECT($L62, fail, 'BinaryOpSymbol "or"'), NonIdContinue), function(value) {
         return "||";
       });
-      var BinaryOpSymbol$21 = $EXPECT($L78, fail, 'BinaryOpSymbol "||"');
-      var BinaryOpSymbol$22 = $EXPECT($L79, fail, 'BinaryOpSymbol "??"');
-      var BinaryOpSymbol$23 = $TS($S($EXPECT($L80, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var BinaryOpSymbol$21 = $EXPECT($L63, fail, 'BinaryOpSymbol "||"');
+      var BinaryOpSymbol$22 = $EXPECT($L64, fail, 'BinaryOpSymbol "??"');
+      var BinaryOpSymbol$23 = $TS($S($EXPECT($L65, fail, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return $1;
       });
-      var BinaryOpSymbol$24 = $TS($S($EXPECT($L81, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      var BinaryOpSymbol$24 = $TS($S($EXPECT($L66, fail, 'BinaryOpSymbol "in"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return $1;
       });
-      var BinaryOpSymbol$25 = $EXPECT($L82, fail, 'BinaryOpSymbol "&"');
-      var BinaryOpSymbol$26 = $EXPECT($L83, fail, 'BinaryOpSymbol "^"');
-      var BinaryOpSymbol$27 = $EXPECT($L84, fail, 'BinaryOpSymbol "|"');
+      var BinaryOpSymbol$25 = $EXPECT($L67, fail, 'BinaryOpSymbol "&"');
+      var BinaryOpSymbol$26 = $EXPECT($L68, fail, 'BinaryOpSymbol "^"');
+      var BinaryOpSymbol$27 = $EXPECT($L69, fail, 'BinaryOpSymbol "|"');
       function BinaryOpSymbol(state) {
         if (state.tokenize) {
           return $TOKEN("BinaryOpSymbol", state, BinaryOpSymbol$0(state) || BinaryOpSymbol$1(state) || BinaryOpSymbol$2(state) || BinaryOpSymbol$3(state) || BinaryOpSymbol$4(state) || BinaryOpSymbol$5(state) || BinaryOpSymbol$6(state) || BinaryOpSymbol$7(state) || BinaryOpSymbol$8(state) || BinaryOpSymbol$9(state) || BinaryOpSymbol$10(state) || BinaryOpSymbol$11(state) || BinaryOpSymbol$12(state) || BinaryOpSymbol$13(state) || BinaryOpSymbol$14(state) || BinaryOpSymbol$15(state) || BinaryOpSymbol$16(state) || BinaryOpSymbol$17(state) || BinaryOpSymbol$18(state) || BinaryOpSymbol$19(state) || BinaryOpSymbol$20(state) || BinaryOpSymbol$21(state) || BinaryOpSymbol$22(state) || BinaryOpSymbol$23(state) || BinaryOpSymbol$24(state) || BinaryOpSymbol$25(state) || BinaryOpSymbol$26(state) || BinaryOpSymbol$27(state));
@@ -2141,7 +2149,7 @@ var Civet = (() => {
         }
       }
       var UnaryOp$0 = $R$0($EXPECT($R2, fail, "UnaryOp /[!~+-]/"));
-      var UnaryOp$1 = $S($C($EXPECT($L85, fail, 'UnaryOp "delete"'), $EXPECT($L86, fail, 'UnaryOp "void"'), $EXPECT($L87, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
+      var UnaryOp$1 = $S($C($EXPECT($L70, fail, 'UnaryOp "delete"'), $EXPECT($L71, fail, 'UnaryOp "void"'), $EXPECT($L72, fail, 'UnaryOp "typeof"')), NonIdContinue, __);
       function UnaryOp(state) {
         if (state.tokenize) {
           return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
@@ -2159,11 +2167,13 @@ var Civet = (() => {
           return ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state);
         }
       }
-      var StatementListItem$0 = $TS($S($C(Declaration, Statement), $E(PostfixConditional)), function($skip, $loc, $0, $1, $2) {
+      var StatementListItem$0 = $TS($S($C(Declaration, Statement), $E(PostfixConditional), Loc), function($skip, $loc, $0, $1, $2, $3) {
         var statement = $1;
         var cond = $2;
+        var l = $3;
         if (cond)
-          return [cond, statement, "}"];
+          return [cond, statement, { $loc: l.$loc, token: "}" }];
+        $0.pop();
         return $0;
       });
       function StatementListItem(state) {
@@ -2175,13 +2185,24 @@ var Civet = (() => {
           return StatementListItem$0(state);
         }
       }
-      var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L88, fail, 'PostfixConditional "if"'), $EXPECT($L89, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
+      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 ws = $1;
         var cond = $2;
-        var exp = $4;
-        if (cond === "if")
-          return [ws, "if(", exp, ") {"];
-        return [ws, "if(!(", exp, ")) {"];
+        var l1 = $4;
+        var exp = $5;
+        var l2 = $6;
+        let openParens = { $loc: l1.$loc, token: "(!(" };
+        let closingParens = { $loc: l2.$loc, token: "))" };
+        let space = { $loc: l2.$loc, token: " " };
+        let openingBrace = { $loc: l2.$loc, token: "{" };
+        if (cond.token === "if") {
+          cond.token = "if";
+          closingParens.token = ")";
+          openParens.token = "(";
+        } else {
+          cond.token = "if";
+        }
+        return [ws, cond, openParens, exp, closingParens, space, openingBrace];
       });
       function PostfixConditional(state) {
         if (state.verbose)
@@ -2208,7 +2229,7 @@ var Civet = (() => {
           return Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
         }
       }
-      var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L90, fail, 'EmptyStatement ";"')));
+      var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L73, fail, 'EmptyStatement ";"')));
       function EmptyStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "EmptyStatement");
@@ -2218,7 +2239,7 @@ var Civet = (() => {
           return EmptyStatement$0(state);
         }
       }
-      var BlockStatement$0 = $S(__, $EXPECT($L12, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L13, fail, 'BlockStatement "}"'));
+      var BlockStatement$0 = $S(__, OpenBrace, EOS, NestedBlockExpressions, __, CloseBrace);
       function BlockStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "BlockStatement");
@@ -2228,17 +2249,21 @@ var Civet = (() => {
           return BlockStatement$0(state);
         }
       }
-      var IfStatement$0 = $S($EXPECT($L88, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L91, fail, 'IfStatement "else"'), Block)));
-      var IfStatement$1 = $TS($S($EXPECT($L89, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
+      var IfStatement$0 = $S(If, Condition, Block, $E($S(__, Else, Block)));
+      var IfStatement$1 = $TS($S(Unless, Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
+        var kind = $1;
         var condition = $2;
         var block = $3;
-        return ["if", condition.map((c) => {
-          if (c === "(")
-            return "(!(";
-          if (c === ")")
-            return "))";
-          return c;
-        }), block];
+        condition.forEach((c) => {
+          if (!c)
+            return;
+          if (c.token === "(")
+            c.token = "(!(";
+          if (c.token === ")")
+            c.token = "))";
+        });
+        kind.token = "if";
+        return [kind, condition, block];
       });
       function IfStatement(state) {
         if (state.tokenize) {
@@ -2259,10 +2284,7 @@ var Civet = (() => {
           return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
         }
       }
-      var LoopStatement$0 = $TS($S($EXPECT($L92, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
-        var b = $3;
-        return ["while(true)", b];
-      });
+      var LoopStatement$0 = $S(Loop, Block);
       function LoopStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "LoopStatement");
@@ -2272,7 +2294,7 @@ var Civet = (() => {
           return LoopStatement$0(state);
         }
       }
-      var DoWhileStatement$0 = $S($EXPECT($L93, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
+      var DoWhileStatement$0 = $S($EXPECT($L74, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, WhileClause);
       function DoWhileStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "DoWhileStatement");
@@ -2292,7 +2314,7 @@ var Civet = (() => {
           return WhileStatement$0(state);
         }
       }
-      var WhileClause$0 = $TS($S($C($EXPECT($L94, fail, 'WhileClause "while"'), $EXPECT($L95, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
+      var WhileClause$0 = $TS($S($C($EXPECT($L75, fail, 'WhileClause "while"'), $EXPECT($L76, fail, 'WhileClause "until"')), NonIdContinue, Condition), function($skip, $loc, $0, $1, $2, $3) {
         var kind = $1;
         var cond = $3;
         if (kind === "until") {
@@ -2311,7 +2333,7 @@ var Civet = (() => {
           return WhileClause$0(state);
         }
       }
-      var ForStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L90, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L90, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), 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");
@@ -2321,10 +2343,10 @@ var Civet = (() => {
           return ForStatement$0(state);
         }
       }
-      var ForInOfStatement$0 = $S(For, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L96, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L81, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
-      var ForInOfStatement$1 = $S(For, __, InsertOpenParen, $C($S($EXPECT($L96, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L81, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
-      var ForInOfStatement$2 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L96, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
-      var ForInOfStatement$3 = $S(For, $E($S(__, $EXPECT($L8, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L96, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L97, fail, 'ForInOfStatement "of"'), AssignmentExpression, 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) {
         if (state.tokenize) {
           return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -2332,18 +2354,6 @@ var Civet = (() => {
           return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
         }
       }
-      var For$0 = $TS($S($EXPECT($L98, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-        return { $loc, token: $1 };
-      });
-      function For(state) {
-        if (state.verbose)
-          console.log("ENTER:", "For");
-        if (state.tokenize) {
-          return $TOKEN("For", state, For$0(state));
-        } else {
-          return For$0(state);
-        }
-      }
       var ForDeclaration$0 = $S(LetOrConst, NonIdContinue, __, ForBinding);
       function ForDeclaration(state) {
         if (state.verbose)
@@ -2354,7 +2364,7 @@ var Civet = (() => {
           return ForDeclaration$0(state);
         }
       }
-      var LetOrConst$0 = $TV($C($EXPECT($L99, fail, 'LetOrConst "let"'), $EXPECT($L100, fail, 'LetOrConst "const"')), function($skip, $loc, $0, $1) {
+      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) {
@@ -2375,7 +2385,7 @@ var Civet = (() => {
           return ForBinding$0(state) || ForBinding$1(state);
         }
       }
-      var SwitchStatement$0 = $S($EXPECT($L101, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
+      var SwitchStatement$0 = $S(Switch, NonIdContinue, Condition, CaseBlock);
       function SwitchStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "SwitchStatement");
@@ -2385,7 +2395,7 @@ var Civet = (() => {
           return SwitchStatement$0(state);
         }
       }
-      var CaseBlock$0 = $S(__, $EXPECT($L12, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L13, fail, 'CaseBlock "}"'));
+      var CaseBlock$0 = $S(__, OpenBrace, $Y(EOS), NestedCaseClauses, __, CloseBrace);
       var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
       function CaseBlock(state) {
         if (state.tokenize) {
@@ -2419,9 +2429,9 @@ var Civet = (() => {
           return NestedCaseClause$0(state);
         }
       }
-      var CaseClause$0 = $S($EXPECT($L102, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
+      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($L103, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
+      var CaseClause$2 = $S($EXPECT($L80, 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));
@@ -2429,21 +2439,9 @@ var Civet = (() => {
           return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
         }
       }
-      var When$0 = $T($S($EXPECT($L104, fail, 'When "when"'), NonIdContinue), function(value) {
-        return "case";
-      });
-      function When(state) {
-        if (state.verbose)
-          console.log("ENTER:", "When");
-        if (state.tokenize) {
-          return $TOKEN("When", state, When$0(state));
-        } else {
-          return When$0(state);
-        }
-      }
-      var ImpliedColon$0 = $S(__, $EXPECT($L14, fail, 'ImpliedColon ":"'));
-      var ImpliedColon$1 = $T($EXPECT($L33, fail, 'ImpliedColon ""'), function(value) {
-        return ":";
+      var ImpliedColon$0 = $S(__, Colon);
+      var ImpliedColon$1 = $TV($EXPECT($L16, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: ":" };
       });
       function ImpliedColon(state) {
         if (state.tokenize) {
@@ -2452,7 +2450,7 @@ var Civet = (() => {
           return ImpliedColon$0(state) || ImpliedColon$1(state);
         }
       }
-      var TryStatement$0 = $TS($S($EXPECT($L105, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var TryStatement$0 = $TS($S(Try, BracedBlock, $E(CatchClause), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
         var c = $3;
         var f = $4;
         if (!c && !f) {
@@ -2469,17 +2467,17 @@ var Civet = (() => {
           return TryStatement$0(state);
         }
       }
-      var Catch$0 = $S(__, $EXPECT($L106, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
-      function Catch(state) {
+      var CatchClause$0 = $S(__, Catch, $E(CatchBind), BracedBlock);
+      function CatchClause(state) {
         if (state.verbose)
-          console.log("ENTER:", "Catch");
+          console.log("ENTER:", "CatchClause");
         if (state.tokenize) {
-          return $TOKEN("Catch", state, Catch$0(state));
+          return $TOKEN("CatchClause", state, CatchClause$0(state));
         } else {
-          return Catch$0(state);
+          return CatchClause$0(state);
         }
       }
-      var CatchBind$0 = $S(__, $EXPECT($L1, fail, 'CatchBind "("'), __, CatchParameter, __, $EXPECT($L2, fail, 'CatchBind ")"'));
+      var CatchBind$0 = $S(__, OpenParen, __, CatchParameter, __, CloseParen);
       var CatchBind$1 = $S(__, InsertOpenParen, CatchParameter, InsertCloseParen);
       function CatchBind(state) {
         if (state.tokenize) {
@@ -2488,7 +2486,7 @@ var Civet = (() => {
           return CatchBind$0(state) || CatchBind$1(state);
         }
       }
-      var Finally$0 = $S(__, $EXPECT($L107, fail, 'Finally "finally"'), BracedBlock);
+      var Finally$0 = $S(__, $EXPECT($L81, fail, 'Finally "finally"'), BracedBlock);
       function Finally(state) {
         if (state.verbose)
           console.log("ENTER:", "Finally");
@@ -2507,7 +2505,7 @@ var Civet = (() => {
           return CatchParameter$0(state) || CatchParameter$1(state);
         }
       }
-      var Condition$0 = $S(__, $EXPECT($L1, fail, 'Condition "("'), __, Expression, __, $EXPECT($L2, fail, 'Condition ")"'));
+      var Condition$0 = $S(__, OpenParen, __, Expression, __, CloseParen);
       var Condition$1 = $S($N(EOS), __, InsertOpenParen, Expression, InsertCloseParen);
       function Condition(state) {
         if (state.tokenize) {
@@ -2526,11 +2524,11 @@ var Civet = (() => {
           return ExpressionStatement$0(state);
         }
       }
-      var KeywordStatement$0 = $S($EXPECT($L108, fail, 'KeywordStatement "break"'), NonIdContinue);
-      var KeywordStatement$1 = $S($EXPECT($L109, fail, 'KeywordStatement "continue"'), NonIdContinue);
-      var KeywordStatement$2 = $S($EXPECT($L110, fail, 'KeywordStatement "debugger"'), NonIdContinue);
+      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$3 = $S(Return, $E(MaybeNestedExpression));
-      var KeywordStatement$4 = $S($EXPECT($L111, fail, 'KeywordStatement "throw"'), NonIdContinue, Expression);
+      var KeywordStatement$4 = $S($EXPECT($L85, 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));
@@ -2547,24 +2545,22 @@ var Civet = (() => {
           return MaybeNestedExpression$0(state) || MaybeNestedExpression$1(state);
         }
       }
-      var Return$0 = $TS($S($EXPECT($L112, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-        return { $loc, token: $1 };
-      });
-      function Return(state) {
-        if (state.verbose)
-          console.log("ENTER:", "Return");
-        if (state.tokenize) {
-          return $TOKEN("Return", state, Return$0(state));
-        } else {
-          return Return$0(state);
-        }
-      }
-      var ImportDeclaration$0 = $T($S($EXPECT($L113, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
+      var ImportDeclaration$0 = $T($S($EXPECT($L86, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
         return { "ts": true, "children": value };
       });
       var ImportDeclaration$1 = $S(Import, __, ImportClause, __, FromClause);
       var ImportDeclaration$2 = $S(Import, __, ModuleSpecifier);
-      var ImportDeclaration$3 = $S(ImpliedImport, ImportClause, __, FromClause);
+      var ImportDeclaration$3 = $TS($S(ImpliedImport, ImportClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var i = $1;
+        var c = $2;
+        var w = $3;
+        var f = $4;
+        i.$loc = {
+          pos: f[0].$loc.pos - 1,
+          length: f[0].$loc.length + 1
+        };
+        return [i, c, w, f];
+      });
       function ImportDeclaration(state) {
         if (state.tokenize) {
           return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state));
@@ -2572,8 +2568,8 @@ var Civet = (() => {
           return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state) || ImportDeclaration$3(state);
         }
       }
-      var ImpliedImport$0 = $T($EXPECT($L33, fail, 'ImpliedImport ""'), function(value) {
-        return "import ";
+      var ImpliedImport$0 = $TV($EXPECT($L16, fail, 'ImpliedImport ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "import " };
       });
       function ImpliedImport(state) {
         if (state.verbose)
@@ -2584,19 +2580,7 @@ var Civet = (() => {
           return ImpliedImport$0(state);
         }
       }
-      var Import$0 = $TS($S($EXPECT($L24, fail, 'Import "import"'), $Y($EXPECT($R3, fail, "Import /\\s/"))), function($skip, $loc, $0, $1, $2) {
-        return { $loc, token: $1 };
-      });
-      function Import(state) {
-        if (state.verbose)
-          console.log("ENTER:", "Import");
-        if (state.tokenize) {
-          return $TOKEN("Import", state, Import$0(state));
-        } else {
-          return Import$0(state);
-        }
-      }
-      var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
+      var ImportClause$0 = $S(ImportedBinding, $E($S(__, Comma, __, $C(NameSpaceImport, NamedImports))));
       var ImportClause$1 = NameSpaceImport;
       var ImportClause$2 = NamedImports;
       function ImportClause(state) {
@@ -2606,7 +2590,7 @@ var Civet = (() => {
           return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
         }
       }
-      var NameSpaceImport$0 = $S($EXPECT($L10, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
+      var NameSpaceImport$0 = $S($EXPECT($L3, fail, 'NameSpaceImport "*"'), __, As, NonIdContinue, __, ImportedBinding);
       function NameSpaceImport(state) {
         if (state.verbose)
           console.log("ENTER:", "NameSpaceImport");
@@ -2616,7 +2600,7 @@ var Civet = (() => {
           return NameSpaceImport$0(state);
         }
       }
-      var NamedImports$0 = $S($EXPECT($L12, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L13, fail, 'NamedImports "}"'));
+      var NamedImports$0 = $S(OpenBrace, $Q(ImportSpecifier), $E($S(__, Comma)), __, CloseBrace);
       function NamedImports(state) {
         if (state.verbose)
           console.log("ENTER:", "NamedImports");
@@ -2636,19 +2620,7 @@ var Civet = (() => {
           return FromClause$0(state);
         }
       }
-      var From$0 = $TS($S($EXPECT($L114, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-        return { $loc, token: $1 };
-      });
-      function From(state) {
-        if (state.verbose)
-          console.log("ENTER:", "From");
-        if (state.tokenize) {
-          return $TOKEN("From", state, From$0(state));
-        } else {
-          return From$0(state);
-        }
-      }
-      var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
+      var ImportSpecifier$0 = $S(__, ModuleExportName, __, As, NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
       var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
       function ImportSpecifier(state) {
         if (state.tokenize) {
@@ -2688,7 +2660,7 @@ var Civet = (() => {
           return UnprocessedModuleSpecifier$0(state) || UnprocessedModuleSpecifier$1(state);
         }
       }
-      var UnquotedSpecifier$0 = $TV($EXPECT($R4, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
+      var UnquotedSpecifier$0 = $TV($EXPECT($R3, fail, 'UnquotedSpecifier /[^;"\\s]+/'), function($skip, $loc, $0, $1) {
         var spec = $0;
         return { $loc, token: `"${spec}"` };
       });
@@ -2711,7 +2683,7 @@ var Civet = (() => {
           return ImportedBinding$0(state);
         }
       }
-      var ExportDeclaration$0 = $S(Export, __, $EXPECT($L103, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
+      var ExportDeclaration$0 = $S(Export, __, $EXPECT($L80, 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) {
@@ -2721,27 +2693,7 @@ var Civet = (() => {
           return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
         }
       }
-      var As$0 = $S($EXPECT($L4, fail, 'As "as"'), NonIdContinue);
-      function As(state) {
-        if (state.verbose)
-          console.log("ENTER:", "As");
-        if (state.tokenize) {
-          return $TOKEN("As", state, As$0(state));
-        } else {
-          return As$0(state);
-        }
-      }
-      var Export$0 = $S($EXPECT($L115, fail, 'Export "export"'), NonIdContinue);
-      function Export(state) {
-        if (state.verbose)
-          console.log("ENTER:", "Export");
-        if (state.tokenize) {
-          return $TOKEN("Export", state, Export$0(state));
-        } else {
-          return Export$0(state);
-        }
-      }
-      var ExportFromClause$0 = $S($EXPECT($L10, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
+      var ExportFromClause$0 = $S($EXPECT($L3, fail, 'ExportFromClause "*"'), $E($S(__, As, NonIdContinue, __, ModuleExportName)));
       var ExportFromClause$1 = NamedExports;
       function ExportFromClause(state) {
         if (state.tokenize) {
@@ -2750,7 +2702,7 @@ var Civet = (() => {
           return ExportFromClause$0(state) || ExportFromClause$1(state);
         }
       }
-      var NamedExports$0 = $S($EXPECT($L12, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L13, fail, 'NamedExports "}"'));
+      var NamedExports$0 = $S(OpenBrace, $Q(ExportSpecifier), $E($S(__, Comma)), __, CloseBrace);
       function NamedExports(state) {
         if (state.verbose)
           console.log("ENTER:", "NamedExports");
@@ -2760,7 +2712,7 @@ var Civet = (() => {
           return NamedExports$0(state);
         }
       }
-      var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L4, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
+      var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, As, __, ModuleExportName)), ObjectPropertyDelimiter);
       function ExportSpecifier(state) {
         if (state.verbose)
           console.log("ENTER:", "ExportSpecifier");
@@ -2791,21 +2743,15 @@ var Civet = (() => {
           return HoistableDeclaration$0(state);
         }
       }
-      var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
-      var LexicalDeclaration$1 = $TS($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-        var bind = $1;
-        var suffix = $2;
-        var ws = $3;
-        var ca = $4;
-        var exp = $5;
-        return [
-          "const ",
-          bind,
-          suffix,
-          ws,
-          { $loc: ca.$loc, token: "=" },
-          exp
-        ];
+      var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, Comma, __, LexicalBinding)));
+      var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+        var c = $1;
+        var ca = $5;
+        c.$loc = {
+          pos: ca.$loc.pos - 1,
+          length: ca.$loc.length + 1
+        };
+        return $0;
       });
       function LexicalDeclaration(state) {
         if (state.tokenize) {
@@ -2814,8 +2760,8 @@ var Civet = (() => {
           return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
         }
       }
-      var ConstAssignment$0 = $TV($EXPECT($L116, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
-        return { $loc, token: $1 };
+      var ConstAssignment$0 = $TV($EXPECT($L87, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "=" };
       });
       function ConstAssignment(state) {
         if (state.verbose)
@@ -2835,7 +2781,7 @@ var Civet = (() => {
           return LexicalBinding$0(state) || LexicalBinding$1(state);
         }
       }
-      var Initializer$0 = $S(__, $EXPECT($L58, fail, 'Initializer "="'), AssignmentExpression);
+      var Initializer$0 = $S(__, Equals, AssignmentExpression);
       function Initializer(state) {
         if (state.verbose)
           console.log("ENTER:", "Initializer");
@@ -2845,7 +2791,7 @@ var Civet = (() => {
           return Initializer$0(state);
         }
       }
-      var VariableStatement$0 = $S($EXPECT($L96, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
+      var VariableStatement$0 = $S(Var, __, VariableDeclarationList);
       function VariableStatement(state) {
         if (state.verbose)
           console.log("ENTER:", "VariableStatement");
@@ -2855,7 +2801,7 @@ var Civet = (() => {
           return VariableStatement$0(state);
         }
       }
-      var VariableDeclarationList$0 = $S(VariableDeclaration, $Q($S(__, $EXPECT($L0, fail, 'VariableDeclarationList ","'), __, VariableDeclaration)));
+      var VariableDeclarationList$0 = $S(VariableDeclaration, $Q($S(__, Comma, __, VariableDeclaration)));
       function VariableDeclarationList(state) {
         if (state.verbose)
           console.log("ENTER:", "VariableDeclarationList");
@@ -2898,7 +2844,7 @@ var Civet = (() => {
           return NumericLiteralKind$0(state) || NumericLiteralKind$1(state) || NumericLiteralKind$2(state) || NumericLiteralKind$3(state) || NumericLiteralKind$4(state);
         }
       }
-      var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
+      var DecimalBigIntegerLiteral$0 = $R$0($EXPECT($R4, fail, "DecimalBigIntegerLiteral /(?:0|[1-9](?:_[0-9]|[0-9])*)n/"));
       function DecimalBigIntegerLiteral(state) {
         if (state.verbose)
           console.log("ENTER:", "DecimalBigIntegerLiteral");
@@ -2908,7 +2854,7 @@ var Civet = (() => {
           return DecimalBigIntegerLiteral$0(state);
         }
       }
-      var DecimalLiteral$0 = $R$0($EXPECT($R6, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
+      var DecimalLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
       function DecimalLiteral(state) {
         if (state.verbose)
           console.log("ENTER:", "DecimalLiteral");
@@ -2918,7 +2864,7 @@ var Civet = (() => {
           return DecimalLiteral$0(state);
         }
       }
-      var BinaryIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
+      var BinaryIntegerLiteral$0 = $R$0($EXPECT($R6, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
       function BinaryIntegerLiteral(state) {
         if (state.verbose)
           console.log("ENTER:", "BinaryIntegerLiteral");
@@ -2928,7 +2874,7 @@ var Civet = (() => {
           return BinaryIntegerLiteral$0(state);
         }
       }
-      var OctalIntegerLiteral$0 = $R$0($EXPECT($R8, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
+      var OctalIntegerLiteral$0 = $R$0($EXPECT($R7, fail, "OctalIntegerLiteral /0[oO][0-7](?:[0-7]|_[0-7])*/"));
       function OctalIntegerLiteral(state) {
         if (state.verbose)
           console.log("ENTER:", "OctalIntegerLiteral");
@@ -2938,7 +2884,7 @@ var Civet = (() => {
           return OctalIntegerLiteral$0(state);
         }
       }
-      var HexLiteral$0 = $R$0($EXPECT($R9, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
+      var HexLiteral$0 = $R$0($EXPECT($R8, fail, "HexLiteral /0[xX][0-9a-fA-F](?:[0-9a-fA-F]|_[0-9a-fA-F])*/"));
       function HexLiteral(state) {
         if (state.verbose)
           console.log("ENTER:", "HexLiteral");
@@ -2948,18 +2894,22 @@ var Civet = (() => {
           return HexLiteral$0(state);
         }
       }
-      var StringLiteral$0 = $TS($S($EXPECT($L117, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L117, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function($skip, $loc, $0, $1, $2, $3) {
+      var StringLiteral$0 = $TS($S(TripleDoubleQuote, TripleDoubleStringCharacters, TripleDoubleQuote), function($skip, $loc, $0, $1, $2, $3) {
+        var s = $1;
         var str = $2;
-        return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
+        var e = $3;
+        return [s, module.dedentBlockString(str), e];
       });
-      var StringLiteral$1 = $TS($S($EXPECT($L118, fail, `StringLiteral "'''"`), $TEXT($Q(TripleSingleStringCharacter)), $EXPECT($L118, fail, `StringLiteral "'''"`)), function($skip, $loc, $0, $1, $2, $3) {
+      var StringLiteral$1 = $TS($S(TripleSingleQuote, TripleSingleStringCharacters, TripleSingleQuote), function($skip, $loc, $0, $1, $2, $3) {
+        var s = $1;
         var str = $2;
-        return { $loc, token: "`" + module.dedentBlockString(str) + "`" };
+        var e = $3;
+        return [s, module.dedentBlockString(str), e];
       });
-      var StringLiteral$2 = $TV($TEXT($S($EXPECT($L119, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L119, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
+      var StringLiteral$2 = $TV($TEXT($S($EXPECT($L88, fail, 'StringLiteral "\\\\\\""'), $Q(DoubleStringCharacter), $EXPECT($L88, fail, 'StringLiteral "\\\\\\""'))), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
-      var StringLiteral$3 = $TV($TEXT($S($EXPECT($L120, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L120, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
+      var StringLiteral$3 = $TV($TEXT($S($EXPECT($L89, fail, `StringLiteral "'"`), $Q(SingleStringCharacter), $EXPECT($L89, fail, `StringLiteral "'"`))), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function StringLiteral(state) {
@@ -2969,7 +2919,7 @@ var Civet = (() => {
           return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state) || StringLiteral$3(state);
         }
       }
-      var DoubleStringCharacter$0 = $R$0($EXPECT($R10, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
+      var DoubleStringCharacter$0 = $R$0($EXPECT($R9, fail, 'DoubleStringCharacter /(?:\\\\.|[^"])+/'));
       function DoubleStringCharacter(state) {
         if (state.verbose)
           console.log("ENTER:", "DoubleStringCharacter");
@@ -2979,7 +2929,7 @@ var Civet = (() => {
           return DoubleStringCharacter$0(state);
         }
       }
-      var SingleStringCharacter$0 = $R$0($EXPECT($R11, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
+      var SingleStringCharacter$0 = $R$0($EXPECT($R10, fail, "SingleStringCharacter /(?:\\\\.|[^'])+/"));
       function SingleStringCharacter(state) {
         if (state.verbose)
           console.log("ENTER:", "SingleStringCharacter");
@@ -2989,27 +2939,31 @@ var Civet = (() => {
           return SingleStringCharacter$0(state);
         }
       }
-      var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R12, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
-      function TripleDoubleStringCharacter(state) {
+      var TripleDoubleStringCharacters$0 = $TR($EXPECT($R11, fail, 'TripleDoubleStringCharacters /(?:"(?!"")|\\\\.|[^"])*/'), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+        return { $loc, token: $0 };
+      });
+      function TripleDoubleStringCharacters(state) {
         if (state.verbose)
-          console.log("ENTER:", "TripleDoubleStringCharacter");
+          console.log("ENTER:", "TripleDoubleStringCharacters");
         if (state.tokenize) {
-          return $TOKEN("TripleDoubleStringCharacter", state, TripleDoubleStringCharacter$0(state));
+          return $TOKEN("TripleDoubleStringCharacters", state, TripleDoubleStringCharacters$0(state));
         } else {
-          return TripleDoubleStringCharacter$0(state);
+          return TripleDoubleStringCharacters$0(state);
         }
       }
-      var TripleSingleStringCharacter$0 = $R$0($EXPECT($R13, fail, "TripleSingleStringCharacter /(?:'(?!'')|\\\\.|[^'])+/"));
-      function TripleSingleStringCharacter(state) {
+      var TripleSingleStringCharacters$0 = $TR($EXPECT($R12, fail, "TripleSingleStringCharacters /(?:'(?!'')|\\\\.|[^'])*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+        return { $loc, token: $0 };
+      });
+      function TripleSingleStringCharacters(state) {
         if (state.verbose)
-          console.log("ENTER:", "TripleSingleStringCharacter");
+          console.log("ENTER:", "TripleSingleStringCharacters");
         if (state.tokenize) {
-          return $TOKEN("TripleSingleStringCharacter", state, TripleSingleStringCharacter$0(state));
+          return $TOKEN("TripleSingleStringCharacters", state, TripleSingleStringCharacters$0(state));
         } else {
-          return TripleSingleStringCharacter$0(state);
+          return TripleSingleStringCharacters$0(state);
         }
       }
-      var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L60, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L60, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
+      var RegularExpressionLiteral$0 = $TV($TEXT($S($EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionBody, $EXPECT($L45, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags)), function($skip, $loc, $0, $1) {
         return { $loc, token: $1 };
       });
       function RegularExpressionLiteral(state) {
@@ -3021,7 +2975,7 @@ var Civet = (() => {
           return RegularExpressionLiteral$0(state);
         }
       }
-      var RegularExpressionBody$0 = $S($R$0($EXPECT($R14, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
+      var RegularExpressionBody$0 = $S($N($R$0($EXPECT($R13, fail, "RegularExpressionBody /[*\\/\\r\\n]/"))), $Q(RegExpCharacter));
       function RegularExpressionBody(state) {
         if (state.verbose)
           console.log("ENTER:", "RegularExpressionBody");
@@ -3031,7 +2985,7 @@ var Civet = (() => {
           return RegularExpressionBody$0(state);
         }
       }
-      var RegExpCharacter$0 = $R$0($EXPECT($R15, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
+      var RegExpCharacter$0 = $R$0($EXPECT($R14, fail, "RegExpCharacter /(?:\\\\.|[^\\/\\r\\n])+/"));
       function RegExpCharacter(state) {
         if (state.verbose)
           console.log("ENTER:", "RegExpCharacter");
@@ -3041,7 +2995,7 @@ var Civet = (() => {
           return RegExpCharacter$0(state);
         }
       }
-      var RegularExpressionFlags$0 = $R$0($EXPECT($R16, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
+      var RegularExpressionFlags$0 = $R$0($EXPECT($R15, fail, "RegularExpressionFlags /(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
       function RegularExpressionFlags(state) {
         if (state.verbose)
           console.log("ENTER:", "RegularExpressionFlags");
@@ -3051,7 +3005,7 @@ var Civet = (() => {
           return RegularExpressionFlags$0(state);
         }
       }
-      var TemplateLiteral$0 = $S($EXPECT($L121, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L121, fail, 'TemplateLiteral "`"'));
+      var TemplateLiteral$0 = $S($EXPECT($L90, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L90, fail, 'TemplateLiteral "`"'));
       function TemplateLiteral(state) {
         if (state.verbose)
           console.log("ENTER:", "TemplateLiteral");
@@ -3061,7 +3015,7 @@ var Civet = (() => {
           return TemplateLiteral$0(state);
         }
       }
-      var TemplateSubstitution$0 = $S($EXPECT($L122, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L13, fail, 'TemplateSubstitution "}"'));
+      var TemplateSubstitution$0 = $S($EXPECT($L91, fail, 'TemplateSubstitution "${"'), __, Expression, __, CloseBrace);
       function TemplateSubstitution(state) {
         if (state.verbose)
           console.log("ENTER:", "TemplateSubstitution");
@@ -3071,7 +3025,7 @@ var Civet = (() => {
           return TemplateSubstitution$0(state);
         }
       }
-      var TemplateCharacters$0 = $R$0($EXPECT($R17, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
+      var TemplateCharacters$0 = $R$0($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
       function TemplateCharacters(state) {
         if (state.verbose)
           console.log("ENTER:", "TemplateCharacters");
@@ -3081,7 +3035,7 @@ var Civet = (() => {
           return TemplateCharacters$0(state);
         }
       }
-      var ReservedWord$0 = $R$0($EXPECT($R18, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
+      var ReservedWord$0 = $R$0($EXPECT($R17, fail, "ReservedWord /(?:and|as|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|import|in|instanceof|interface|is|new|null|or|return|static|super|switch|this|throw|true|try|typeof|unless|var|void|while|with|yield)(?!\\p{ID_Continue})/"));
       function ReservedWord(state) {
         if (state.verbose)
           console.log("ENTER:", "ReservedWord");
@@ -3100,7 +3054,9 @@ var Civet = (() => {
           return Comment$0(state) || Comment$1(state);
         }
       }
-      var SingleLineComment$0 = $R$0($EXPECT($R19, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
+      var SingleLineComment$0 = $TR($EXPECT($R18, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+        return { $loc, token: $0 };
+      });
       var SingleLineComment$1 = CoffeeSingleLineComment;
       function SingleLineComment(state) {
         if (state.tokenize) {
@@ -3118,7 +3074,9 @@ var Civet = (() => {
           return MultiLineComment$0(state) || MultiLineComment$1(state);
         }
       }
-      var JSMultiLineComment$0 = $S($EXPECT($L123, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'JSMultiLineComment "*/"')), $EXPECT($R20, fail, "JSMultiLineComment /./")))), $EXPECT($L124, fail, 'JSMultiLineComment "*/"'));
+      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) {
+        return { $loc, token: $1 };
+      });
       function JSMultiLineComment(state) {
         if (state.verbose)
           console.log("ENTER:", "JSMultiLineComment");
@@ -3128,10 +3086,10 @@ var Civet = (() => {
           return JSMultiLineComment$0(state);
         }
       }
-      var CoffeeSingleLineComment$0 = $TR($EXPECT($R21, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var CoffeeSingleLineComment$0 = $TR($EXPECT($R20, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         if (!module.coffeeCompat)
           return $skip;
-        return ["//", $1];
+        return { $loc, token: `//${$1}` };
       });
       function CoffeeSingleLineComment(state) {
         if (state.verbose)
@@ -3142,8 +3100,8 @@ var Civet = (() => {
           return CoffeeSingleLineComment$0(state);
         }
       }
-      var CoffeeMultiLineComment$0 = $T($S($EXPECT($L125, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L125, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R20, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L125, fail, 'CoffeeMultiLineComment "###"')), function(value) {
-        return ["/*", value[1], "*/"];
+      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) {
+        return { $loc, token: `/*${$2}*/` };
       });
       function CoffeeMultiLineComment(state) {
         if (state.verbose)
@@ -3154,7 +3112,9 @@ var Civet = (() => {
           return CoffeeMultiLineComment$0(state);
         }
       }
-      var InlineComment$0 = $S($EXPECT($L123, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L124, fail, 'InlineComment "*/"')), $EXPECT($R22, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L124, fail, 'InlineComment "*/"'));
+      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) {
+        return { $loc, token: $1 };
+      });
       function InlineComment(state) {
         if (state.verbose)
           console.log("ENTER:", "InlineComment");
@@ -3164,7 +3124,7 @@ var Civet = (() => {
           return InlineComment$0(state);
         }
       }
-      var RestOfLine$0 = $S($Q($C($R$0($EXPECT($R23, fail, "RestOfLine /[ \\t]+/")), SingleLineComment, MultiLineComment)), EOL);
+      var RestOfLine$0 = $S($Q($C($R$0($EXPECT($R22, fail, "RestOfLine /[ \\t]+/")), SingleLineComment, MultiLineComment)), EOL);
       function RestOfLine(state) {
         if (state.verbose)
           console.log("ENTER:", "RestOfLine");
@@ -3174,7 +3134,7 @@ var Civet = (() => {
           return RestOfLine$0(state);
         }
       }
-      var TrailingComment$0 = $R$0($EXPECT($R24, fail, "TrailingComment /[\\t ]+/"));
+      var TrailingComment$0 = $R$0($EXPECT($R23, fail, "TrailingComment /[\\t ]+/"));
       var TrailingComment$1 = InlineComment;
       var TrailingComment$2 = SingleLineComment;
       function TrailingComment(state) {
@@ -3184,7 +3144,7 @@ var Civet = (() => {
           return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
         }
       }
-      var _$0 = $P($C($R$0($EXPECT($R24, fail, "_ /[\\t ]+/")), Comment));
+      var _$0 = $P($C(NonNewlineWhitespace, Comment));
       function _(state) {
         if (state.verbose)
           console.log("ENTER:", "_");
@@ -3194,7 +3154,19 @@ var Civet = (() => {
           return _$0(state);
         }
       }
-      var __$0 = $Q($C($R$0($EXPECT($R25, fail, "__ /[\\s]+/")), Comment));
+      var NonNewlineWhitespace$0 = $TR($EXPECT($R22, fail, "NonNewlineWhitespace /[ \\t]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+        return { $loc, token: $0 };
+      });
+      function NonNewlineWhitespace(state) {
+        if (state.verbose)
+          console.log("ENTER:", "NonNewlineWhitespace");
+        if (state.tokenize) {
+          return $TOKEN("NonNewlineWhitespace", state, NonNewlineWhitespace$0(state));
+        } else {
+          return NonNewlineWhitespace$0(state);
+        }
+      }
+      var __$0 = $Q($C(Whitespace, Comment));
       function __(state) {
         if (state.verbose)
           console.log("ENTER:", "__");
@@ -3204,9 +3176,21 @@ var Civet = (() => {
           return __$0(state);
         }
       }
-      var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L90, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
-      var StatementDelimiter$1 = $T($Y(EOS), function(value) {
-        return [";", value];
+      var Whitespace$0 = $TR($EXPECT($R24, fail, "Whitespace /[\\s]+/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+        return { $loc, token: $0 };
+      });
+      function Whitespace(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Whitespace");
+        if (state.tokenize) {
+          return $TOKEN("Whitespace", state, Whitespace$0(state));
+        } else {
+          return Whitespace$0(state);
+        }
+      }
+      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) {
+        return { $loc, token: ";" };
       });
       function StatementDelimiter(state) {
         if (state.tokenize) {
@@ -3215,7 +3199,7 @@ var Civet = (() => {
           return StatementDelimiter$0(state) || StatementDelimiter$1(state);
         }
       }
-      var NonIdContinue$0 = $R$0($EXPECT($R26, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
+      var NonIdContinue$0 = $R$0($EXPECT($R25, fail, "NonIdContinue /(?!\\p{ID_Continue})/"));
       function NonIdContinue(state) {
         if (state.verbose)
           console.log("ENTER:", "NonIdContinue");
@@ -3225,122 +3209,578 @@ var Civet = (() => {
           return NonIdContinue$0(state);
         }
       }
-      var JSXElement$0 = JSXSelfClosingElement;
-      var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
-        if ($1[1] !== $4[2]) {
-          throw new Error(`mismatched closing tags at ${JSON.stringify($loc)}`);
+      var Loc$0 = $TV($EXPECT($L16, fail, 'Loc ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "" };
+      });
+      function Loc(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Loc");
+        if (state.tokenize) {
+          return $TOKEN("Loc", state, Loc$0(state));
+        } else {
+          return Loc$0(state);
         }
-        return $0;
+      }
+      var As$0 = $TS($S($EXPECT($L95, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1 };
       });
-      function JSXElement(state) {
+      function As(state) {
+        if (state.verbose)
+          console.log("ENTER:", "As");
         if (state.tokenize) {
-          return $TOKEN("JSXElement", state, JSXElement$0(state) || JSXElement$1(state));
+          return $TOKEN("As", state, As$0(state));
         } else {
-          return JSXElement$0(state) || JSXElement$1(state);
+          return As$0(state);
         }
       }
-      var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L126, fail, 'JSXSelfClosingElement "/>"'));
-      function JSXSelfClosingElement(state) {
+      var Async$0 = $TV($EXPECT($L96, fail, 'Async "async"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Async(state) {
         if (state.verbose)
-          console.log("ENTER:", "JSXSelfClosingElement");
+          console.log("ENTER:", "Async");
         if (state.tokenize) {
-          return $TOKEN("JSXSelfClosingElement", state, JSXSelfClosingElement$0(state));
+          return $TOKEN("Async", state, Async$0(state));
         } else {
-          return JSXSelfClosingElement$0(state);
+          return Async$0(state);
         }
       }
-      var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L69, fail, 'JSXOpeningElement ">"'));
-      function JSXOpeningElement(state) {
+      var Await$0 = $TS($S($EXPECT($L97, fail, 'Await "await"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1 };
+      });
+      function Await(state) {
         if (state.verbose)
-          console.log("ENTER:", "JSXOpeningElement");
+          console.log("ENTER:", "Await");
         if (state.tokenize) {
-          return $TOKEN("JSXOpeningElement", state, JSXOpeningElement$0(state));
+          return $TOKEN("Await", state, Await$0(state));
         } else {
-          return JSXOpeningElement$0(state);
+          return Await$0(state);
         }
       }
-      var JSXClosingElement$0 = $S($EXPECT($L127, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L69, fail, 'JSXClosingElement ">"'));
-      function JSXClosingElement(state) {
+      var Catch$0 = $TV($EXPECT($L98, fail, 'Catch "catch"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Catch(state) {
         if (state.verbose)
-          console.log("ENTER:", "JSXClosingElement");
+          console.log("ENTER:", "Catch");
         if (state.tokenize) {
-          return $TOKEN("JSXClosingElement", state, JSXClosingElement$0(state));
+          return $TOKEN("Catch", state, Catch$0(state));
         } else {
-          return JSXClosingElement$0(state);
+          return Catch$0(state);
         }
       }
-      var JSXFragment$0 = $S($EXPECT($L128, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L129, fail, 'JSXFragment "</>"'));
-      function JSXFragment(state) {
+      var Class$0 = $TV($EXPECT($L99, fail, 'Class "class"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Class(state) {
         if (state.verbose)
-          console.log("ENTER:", "JSXFragment");
+          console.log("ENTER:", "Class");
         if (state.tokenize) {
-          return $TOKEN("JSXFragment", state, JSXFragment$0(state));
+          return $TOKEN("Class", state, Class$0(state));
         } else {
-          return JSXFragment$0(state);
+          return Class$0(state);
         }
       }
-      var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L14, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
-      function JSXElementName(state) {
+      var CloseBrace$0 = $TV($EXPECT($L100, fail, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function CloseBrace(state) {
         if (state.verbose)
-          console.log("ENTER:", "JSXElementName");
+          console.log("ENTER:", "CloseBrace");
         if (state.tokenize) {
-          return $TOKEN("JSXElementName", state, JSXElementName$0(state));
+          return $TOKEN("CloseBrace", state, CloseBrace$0(state));
         } else {
-          return JSXElementName$0(state);
+          return CloseBrace$0(state);
         }
       }
-      var JSXIdentifierName$0 = $R$0($EXPECT($R27, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
-      function JSXIdentifierName(state) {
+      var CloseBracket$0 = $TV($EXPECT($L24, fail, 'CloseBracket "]"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function CloseBracket(state) {
         if (state.verbose)
-          console.log("ENTER:", "JSXIdentifierName");
+          console.log("ENTER:", "CloseBracket");
         if (state.tokenize) {
-          return $TOKEN("JSXIdentifierName", state, JSXIdentifierName$0(state));
+          return $TOKEN("CloseBracket", state, CloseBracket$0(state));
         } else {
-          return JSXIdentifierName$0(state);
+          return CloseBracket$0(state);
         }
       }
-      var JSXAttributes$0 = $Q($S(__, JSXAttribute));
-      function JSXAttributes(state) {
+      var CloseParen$0 = $TV($EXPECT($L17, fail, 'CloseParen ")"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function CloseParen(state) {
         if (state.verbose)
-          console.log("ENTER:", "JSXAttributes");
+          console.log("ENTER:", "CloseParen");
         if (state.tokenize) {
-          return $TOKEN("JSXAttributes", state, JSXAttributes$0(state));
+          return $TOKEN("CloseParen", state, CloseParen$0(state));
         } else {
-          return JSXAttributes$0(state);
+          return CloseParen$0(state);
         }
       }
-      var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L34, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
-      var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
-      function JSXAttribute(state) {
+      var Colon$0 = $TV($EXPECT($L101, fail, 'Colon ":"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Colon(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Colon");
         if (state.tokenize) {
-          return $TOKEN("JSXAttribute", state, JSXAttribute$0(state) || JSXAttribute$1(state));
+          return $TOKEN("Colon", state, Colon$0(state));
         } else {
-          return JSXAttribute$0(state) || JSXAttribute$1(state);
+          return Colon$0(state);
         }
       }
-      var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L14, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
-      function JSXAttributeName(state) {
+      var Dot$0 = $TV($EXPECT($L102, fail, 'Dot "."'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Dot(state) {
         if (state.verbose)
-          console.log("ENTER:", "JSXAttributeName");
+          console.log("ENTER:", "Dot");
         if (state.tokenize) {
-          return $TOKEN("JSXAttributeName", state, JSXAttributeName$0(state));
+          return $TOKEN("Dot", state, Dot$0(state));
         } else {
-          return JSXAttributeName$0(state);
+          return Dot$0(state);
         }
       }
-      var JSXAttributeInitializer$0 = $S(__, $EXPECT($L58, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
-      function JSXAttributeInitializer(state) {
+      var Else$0 = $TV($EXPECT($L103, fail, 'Else "else"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Else(state) {
         if (state.verbose)
-          console.log("ENTER:", "JSXAttributeInitializer");
+          console.log("ENTER:", "Else");
         if (state.tokenize) {
-          return $TOKEN("JSXAttributeInitializer", state, JSXAttributeInitializer$0(state));
+          return $TOKEN("Else", state, Else$0(state));
         } else {
-          return JSXAttributeInitializer$0(state);
+          return Else$0(state);
         }
       }
-      var JSXAttributeValue$0 = $R$0($EXPECT($R28, fail, 'JSXAttributeValue /"[^"]*"/'));
-      var JSXAttributeValue$1 = $R$0($EXPECT($R29, fail, "JSXAttributeValue /'[^']*'/"));
-      var JSXAttributeValue$2 = $S($EXPECT($L12, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttributeValue "}"'));
+      var Equals$0 = $TV($EXPECT($L43, fail, 'Equals "="'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Equals(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Equals");
+        if (state.tokenize) {
+          return $TOKEN("Equals", state, Equals$0(state));
+        } else {
+          return Equals$0(state);
+        }
+      }
+      var Export$0 = $TS($S($EXPECT($L104, fail, 'Export "export"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1 };
+      });
+      function Export(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Export");
+        if (state.tokenize) {
+          return $TOKEN("Export", state, Export$0(state));
+        } else {
+          return Export$0(state);
+        }
+      }
+      var For$0 = $TS($S($EXPECT($L105, fail, 'For "for"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1 };
+      });
+      function For(state) {
+        if (state.verbose)
+          console.log("ENTER:", "For");
+        if (state.tokenize) {
+          return $TOKEN("For", state, For$0(state));
+        } else {
+          return For$0(state);
+        }
+      }
+      var From$0 = $TS($S($EXPECT($L106, fail, 'From "from"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1 };
+      });
+      function From(state) {
+        if (state.verbose)
+          console.log("ENTER:", "From");
+        if (state.tokenize) {
+          return $TOKEN("From", state, From$0(state));
+        } else {
+          return From$0(state);
+        }
+      }
+      var Function$0 = $TV($EXPECT($L107, fail, 'Function "function"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Function(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Function");
+        if (state.tokenize) {
+          return $TOKEN("Function", state, Function$0(state));
+        } else {
+          return Function$0(state);
+        }
+      }
+      var If$0 = $TV($EXPECT($L108, fail, 'If "if"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function If(state) {
+        if (state.verbose)
+          console.log("ENTER:", "If");
+        if (state.tokenize) {
+          return $TOKEN("If", state, If$0(state));
+        } else {
+          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) {
+        return { $loc, token: $1 };
+      });
+      function Import(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Import");
+        if (state.tokenize) {
+          return $TOKEN("Import", state, Import$0(state));
+        } else {
+          return Import$0(state);
+        }
+      }
+      var In$0 = $TV($EXPECT($L66, fail, 'In "in"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function In(state) {
+        if (state.verbose)
+          console.log("ENTER:", "In");
+        if (state.tokenize) {
+          return $TOKEN("In", state, In$0(state));
+        } else {
+          return In$0(state);
+        }
+      }
+      var Loop$0 = $TS($S($EXPECT($L109, fail, 'Loop "loop"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: "while(true)" };
+      });
+      function Loop(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Loop");
+        if (state.tokenize) {
+          return $TOKEN("Loop", state, Loop$0(state));
+        } else {
+          return Loop$0(state);
+        }
+      }
+      var New$0 = $TV($EXPECT($L110, fail, 'New "new"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function New(state) {
+        if (state.verbose)
+          console.log("ENTER:", "New");
+        if (state.tokenize) {
+          return $TOKEN("New", state, New$0(state));
+        } else {
+          return New$0(state);
+        }
+      }
+      var Of$0 = $TV($EXPECT($L111, fail, 'Of "of"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Of(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Of");
+        if (state.tokenize) {
+          return $TOKEN("Of", state, Of$0(state));
+        } else {
+          return Of$0(state);
+        }
+      }
+      var OpenBrace$0 = $TV($EXPECT($L112, fail, 'OpenBrace "{"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function OpenBrace(state) {
+        if (state.verbose)
+          console.log("ENTER:", "OpenBrace");
+        if (state.tokenize) {
+          return $TOKEN("OpenBrace", state, OpenBrace$0(state));
+        } else {
+          return OpenBrace$0(state);
+        }
+      }
+      var OpenBracket$0 = $TV($EXPECT($L113, fail, 'OpenBracket "["'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function OpenBracket(state) {
+        if (state.verbose)
+          console.log("ENTER:", "OpenBracket");
+        if (state.tokenize) {
+          return $TOKEN("OpenBracket", state, OpenBracket$0(state));
+        } else {
+          return OpenBracket$0(state);
+        }
+      }
+      var OpenParen$0 = $TV($EXPECT($L114, fail, 'OpenParen "("'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function OpenParen(state) {
+        if (state.verbose)
+          console.log("ENTER:", "OpenParen");
+        if (state.tokenize) {
+          return $TOKEN("OpenParen", state, OpenParen$0(state));
+        } else {
+          return OpenParen$0(state);
+        }
+      }
+      var QuestionMark$0 = $TV($EXPECT($L115, fail, 'QuestionMark "?"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function QuestionMark(state) {
+        if (state.verbose)
+          console.log("ENTER:", "QuestionMark");
+        if (state.tokenize) {
+          return $TOKEN("QuestionMark", state, QuestionMark$0(state));
+        } else {
+          return QuestionMark$0(state);
+        }
+      }
+      var Return$0 = $TS($S($EXPECT($L116, fail, 'Return "return"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: $1 };
+      });
+      function Return(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Return");
+        if (state.tokenize) {
+          return $TOKEN("Return", state, Return$0(state));
+        } else {
+          return Return$0(state);
+        }
+      }
+      var Semicolon$0 = $TV($EXPECT($L73, fail, 'Semicolon ";"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Semicolon(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Semicolon");
+        if (state.tokenize) {
+          return $TOKEN("Semicolon", state, Semicolon$0(state));
+        } else {
+          return Semicolon$0(state);
+        }
+      }
+      var Static$0 = $TV($EXPECT($L117, fail, 'Static "static"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Static(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Static");
+        if (state.tokenize) {
+          return $TOKEN("Static", state, Static$0(state));
+        } else {
+          return Static$0(state);
+        }
+      }
+      var Switch$0 = $TV($EXPECT($L118, fail, 'Switch "switch"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Switch(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Switch");
+        if (state.tokenize) {
+          return $TOKEN("Switch", state, Switch$0(state));
+        } else {
+          return Switch$0(state);
+        }
+      }
+      var Target$0 = $TV($EXPECT($L119, fail, 'Target "target"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Target(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Target");
+        if (state.tokenize) {
+          return $TOKEN("Target", state, Target$0(state));
+        } else {
+          return Target$0(state);
+        }
+      }
+      var TripleDoubleQuote$0 = $TV($EXPECT($L120, fail, 'TripleDoubleQuote "\\\\\\"\\\\\\"\\\\\\""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "`" };
+      });
+      function TripleDoubleQuote(state) {
+        if (state.verbose)
+          console.log("ENTER:", "TripleDoubleQuote");
+        if (state.tokenize) {
+          return $TOKEN("TripleDoubleQuote", state, TripleDoubleQuote$0(state));
+        } else {
+          return TripleDoubleQuote$0(state);
+        }
+      }
+      var TripleSingleQuote$0 = $TV($EXPECT($L121, fail, `TripleSingleQuote "'''"`), function($skip, $loc, $0, $1) {
+        return { $loc, token: "`" };
+      });
+      function TripleSingleQuote(state) {
+        if (state.verbose)
+          console.log("ENTER:", "TripleSingleQuote");
+        if (state.tokenize) {
+          return $TOKEN("TripleSingleQuote", state, TripleSingleQuote$0(state));
+        } else {
+          return TripleSingleQuote$0(state);
+        }
+      }
+      var Try$0 = $TV($EXPECT($L122, fail, 'Try "try"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Try(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Try");
+        if (state.tokenize) {
+          return $TOKEN("Try", state, Try$0(state));
+        } else {
+          return Try$0(state);
+        }
+      }
+      var Unless$0 = $TV($EXPECT($L123, fail, 'Unless "unless"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Unless(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Unless");
+        if (state.tokenize) {
+          return $TOKEN("Unless", state, Unless$0(state));
+        } else {
+          return Unless$0(state);
+        }
+      }
+      var Var$0 = $TV($EXPECT($L124, fail, 'Var "var"'), function($skip, $loc, $0, $1) {
+        return { $loc, token: $1 };
+      });
+      function Var(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Var");
+        if (state.tokenize) {
+          return $TOKEN("Var", state, Var$0(state));
+        } else {
+          return Var$0(state);
+        }
+      }
+      var When$0 = $TS($S($EXPECT($L125, fail, 'When "when"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+        return { $loc, token: "case" };
+      });
+      function When(state) {
+        if (state.verbose)
+          console.log("ENTER:", "When");
+        if (state.tokenize) {
+          return $TOKEN("When", state, When$0(state));
+        } else {
+          return When$0(state);
+        }
+      }
+      var JSXElement$0 = JSXSelfClosingElement;
+      var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
+        if ($1[1] !== $4[2]) {
+          throw new Error(`mismatched closing tags at ${JSON.stringify($loc)}`);
+        }
+        return $0;
+      });
+      function JSXElement(state) {
+        if (state.tokenize) {
+          return $TOKEN("JSXElement", state, JSXElement$0(state) || JSXElement$1(state));
+        } else {
+          return JSXElement$0(state) || JSXElement$1(state);
+        }
+      }
+      var JSXSelfClosingElement$0 = $S($EXPECT($L5, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L126, fail, 'JSXSelfClosingElement "/>"'));
+      function JSXSelfClosingElement(state) {
+        if (state.verbose)
+          console.log("ENTER:", "JSXSelfClosingElement");
+        if (state.tokenize) {
+          return $TOKEN("JSXSelfClosingElement", state, JSXSelfClosingElement$0(state));
+        } else {
+          return JSXSelfClosingElement$0(state);
+        }
+      }
+      var JSXOpeningElement$0 = $S($EXPECT($L5, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L54, fail, 'JSXOpeningElement ">"'));
+      function JSXOpeningElement(state) {
+        if (state.verbose)
+          console.log("ENTER:", "JSXOpeningElement");
+        if (state.tokenize) {
+          return $TOKEN("JSXOpeningElement", state, JSXOpeningElement$0(state));
+        } else {
+          return JSXOpeningElement$0(state);
+        }
+      }
+      var JSXClosingElement$0 = $S($EXPECT($L127, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L54, fail, 'JSXClosingElement ">"'));
+      function JSXClosingElement(state) {
+        if (state.verbose)
+          console.log("ENTER:", "JSXClosingElement");
+        if (state.tokenize) {
+          return $TOKEN("JSXClosingElement", state, JSXClosingElement$0(state));
+        } else {
+          return JSXClosingElement$0(state);
+        }
+      }
+      var JSXFragment$0 = $S($EXPECT($L128, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L129, fail, 'JSXFragment "</>"'));
+      function JSXFragment(state) {
+        if (state.verbose)
+          console.log("ENTER:", "JSXFragment");
+        if (state.tokenize) {
+          return $TOKEN("JSXFragment", state, JSXFragment$0(state));
+        } else {
+          return JSXFragment$0(state);
+        }
+      }
+      var JSXElementName$0 = $S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName))));
+      function JSXElementName(state) {
+        if (state.verbose)
+          console.log("ENTER:", "JSXElementName");
+        if (state.tokenize) {
+          return $TOKEN("JSXElementName", state, JSXElementName$0(state));
+        } else {
+          return JSXElementName$0(state);
+        }
+      }
+      var JSXIdentifierName$0 = $R$0($EXPECT($R27, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
+      function JSXIdentifierName(state) {
+        if (state.verbose)
+          console.log("ENTER:", "JSXIdentifierName");
+        if (state.tokenize) {
+          return $TOKEN("JSXIdentifierName", state, JSXIdentifierName$0(state));
+        } else {
+          return JSXIdentifierName$0(state);
+        }
+      }
+      var JSXAttributes$0 = $Q($S(__, JSXAttribute));
+      function JSXAttributes(state) {
+        if (state.verbose)
+          console.log("ENTER:", "JSXAttributes");
+        if (state.tokenize) {
+          return $TOKEN("JSXAttributes", state, JSXAttributes$0(state));
+        } else {
+          return JSXAttributes$0(state);
+        }
+      }
+      var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L18, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
+      var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
+      function JSXAttribute(state) {
+        if (state.tokenize) {
+          return $TOKEN("JSXAttribute", state, JSXAttribute$0(state) || JSXAttribute$1(state));
+        } else {
+          return JSXAttribute$0(state) || JSXAttribute$1(state);
+        }
+      }
+      var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S(Colon, JSXIdentifierName)));
+      function JSXAttributeName(state) {
+        if (state.verbose)
+          console.log("ENTER:", "JSXAttributeName");
+        if (state.tokenize) {
+          return $TOKEN("JSXAttributeName", state, JSXAttributeName$0(state));
+        } else {
+          return JSXAttributeName$0(state);
+        }
+      }
+      var JSXAttributeInitializer$0 = $S(__, Equals, __, JSXAttributeValue);
+      function JSXAttributeInitializer(state) {
+        if (state.verbose)
+          console.log("ENTER:", "JSXAttributeInitializer");
+        if (state.tokenize) {
+          return $TOKEN("JSXAttributeInitializer", state, JSXAttributeInitializer$0(state));
+        } else {
+          return JSXAttributeInitializer$0(state);
+        }
+      }
+      var JSXAttributeValue$0 = $R$0($EXPECT($R28, fail, 'JSXAttributeValue /"[^"]*"/'));
+      var JSXAttributeValue$1 = $R$0($EXPECT($R29, fail, "JSXAttributeValue /'[^']*'/"));
+      var JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
       var JSXAttributeValue$3 = JSXElement;
       var JSXAttributeValue$4 = JSXFragment;
       function JSXAttributeValue(state) {
@@ -3363,7 +3803,7 @@ var Civet = (() => {
       var JSXChild$0 = JSXText;
       var JSXChild$1 = JSXElement;
       var JSXChild$2 = JSXFragment;
-      var JSXChild$3 = $S($EXPECT($L12, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L13, fail, 'JSXChild "}"'));
+      var JSXChild$3 = $S(OpenBrace, $E(JSXChildExpression), __, CloseBrace);
       function JSXChild(state) {
         if (state.tokenize) {
           return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
@@ -3381,7 +3821,7 @@ var Civet = (() => {
           return JSXText$0(state);
         }
       }
-      var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L34, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
+      var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L18, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
       function JSXChildExpression(state) {
         if (state.verbose)
           console.log("ENTER:", "JSXChildExpression");
@@ -3404,7 +3844,7 @@ var Civet = (() => {
         }
       }
       var TypeDeclarationModifier$0 = $S($EXPECT($L130, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
-      var TypeDeclarationModifier$1 = $S($EXPECT($L115, fail, 'TypeDeclarationModifier "export"'), NonIdContinue);
+      var TypeDeclarationModifier$1 = Export;
       function TypeDeclarationModifier(state) {
         if (state.tokenize) {
           return $TOKEN("TypeDeclarationModifier", state, TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state));
@@ -3412,7 +3852,7 @@ var Civet = (() => {
           return TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state);
         }
       }
-      var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L58, fail, 'TypeDeclarationRest "="'), __, Type);
+      var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, __, Type);
       var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
       var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
       function TypeDeclarationRest(state) {
@@ -3452,8 +3892,8 @@ var Civet = (() => {
           return Namespace$0(state);
         }
       }
-      var InterfaceBlock$0 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L13, fail, 'InterfaceBlock "}"'));
-      var InterfaceBlock$1 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), $Q($S(__, InterfaceProperty)), __, $EXPECT($L13, fail, 'InterfaceBlock "}"'));
+      var InterfaceBlock$0 = $S(__, OpenBrace, EOS, NestedInterfaceProperties, __, CloseBrace);
+      var InterfaceBlock$1 = $S(__, OpenBrace, $Q($S(__, InterfaceProperty)), __, CloseBrace);
       var InterfaceBlock$2 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
       function InterfaceBlock(state) {
         if (state.tokenize) {
@@ -3496,13 +3936,13 @@ var Civet = (() => {
           return InterfaceProperty$0(state) || InterfaceProperty$1(state);
         }
       }
-      var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L90, fail, 'InterfacePropertyDelimiter ";"'));
-      var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"')));
-      var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L13, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
-        return ";";
+      var InterfacePropertyDelimiter$0 = $S($Q(_), Semicolon);
+      var InterfacePropertyDelimiter$1 = $Y($S($Q(_), CloseBrace));
+      var InterfacePropertyDelimiter$2 = $TV($Y($S(__, CloseBrace)), function($skip, $loc, $0, $1) {
+        return { $loc, token: ";" };
       });
-      var InterfacePropertyDelimiter$3 = $T($Y(EOS), function(value) {
-        return ";";
+      var InterfacePropertyDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
+        return { $loc, token: ";" };
       });
       function InterfacePropertyDelimiter(state) {
         if (state.tokenize) {
@@ -3511,8 +3951,8 @@ var Civet = (() => {
           return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
         }
       }
-      var NamespaceBlock$0 = $S(__, $EXPECT($L12, fail, 'NamespaceBlock "{"'), EOS, NestedTypeDeclarations, __, $EXPECT($L13, fail, 'NamespaceBlock "}"'));
-      var NamespaceBlock$1 = $S(__, $EXPECT($L12, fail, 'NamespaceBlock "{"'), $Q($S(__, TypeDeclaration, InterfacePropertyDelimiter)), __, $EXPECT($L13, fail, 'NamespaceBlock "}"'));
+      var NamespaceBlock$0 = $S(__, OpenBrace, EOS, NestedTypeDeclarations, __, CloseBrace);
+      var NamespaceBlock$1 = $S(__, OpenBrace, $Q($S(__, TypeDeclaration, InterfacePropertyDelimiter)), __, CloseBrace);
       var NamespaceBlock$2 = $S(InsertOpenBrace, EOS, NestedTypeDeclarations, InsertNewline, InsertIndent, InsertCloseBrace);
       function NamespaceBlock(state) {
         if (state.tokenize) {
@@ -3546,7 +3986,7 @@ var Civet = (() => {
           return NestedTypeDeclaration$0(state);
         }
       }
-      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L134, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L27, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L28, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
+      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L134, fail, 'TypeIndexSignature "readonly"'), __)), OpenBracket, TypeIndex, CloseBracket, $E($S(__, $R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]/")), QuestionMark)));
       function TypeIndexSignature(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeIndexSignature");
@@ -3557,7 +3997,7 @@ var Civet = (() => {
         }
       }
       var TypeIndex$0 = $S(__, Identifier, TypeSuffix);
-      var TypeIndex$1 = $S(__, PropertyName, __, $EXPECT($L81, fail, 'TypeIndex "in"'), Type, $E($S(__, $EXPECT($L4, fail, 'TypeIndex "as"'), Type)));
+      var TypeIndex$1 = $S(__, PropertyName, __, In, Type, $E($S(__, As, Type)));
       function TypeIndex(state) {
         if (state.tokenize) {
           return $TOKEN("TypeIndex", state, TypeIndex$0(state) || TypeIndex$1(state));
@@ -3565,7 +4005,7 @@ var Civet = (() => {
           return TypeIndex$0(state) || TypeIndex$1(state);
         }
       }
-      var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L14, fail, 'TypeSuffix ":"'), Type), function(value) {
+      var TypeSuffix$0 = $T($S($E(QuestionMark), __, Colon, Type), function(value) {
         return { "ts": true, "children": value };
       });
       function TypeSuffix(state) {
@@ -3577,7 +4017,7 @@ var Civet = (() => {
           return TypeSuffix$0(state);
         }
       }
-      var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L135, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
+      var ReturnTypeSuffix$0 = $T($S(__, Colon, $E($S(__, $EXPECT($L135, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
         return { "ts": true, "children": value };
       });
       function ReturnTypeSuffix(state) {
@@ -3589,7 +4029,7 @@ var Civet = (() => {
           return ReturnTypeSuffix$0(state);
         }
       }
-      var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L72, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
+      var TypePredicate$0 = $S(Type, $E($S(__, $EXPECT($L57, fail, 'TypePredicate "is"'), NonIdContinue, Type)));
       function TypePredicate(state) {
         if (state.verbose)
           console.log("ENTER:", "TypePredicate");
@@ -3609,7 +4049,7 @@ var Civet = (() => {
           return Type$0(state);
         }
       }
-      var TypeBinary$0 = $S(TypeUnary, $Q($S(__, TypeBinaryOp, TypeUnary)));
+      var TypeBinary$0 = $S(TypeUnary, $Q($S(__, TypeBinaryOp, __, TypeUnary)));
       function TypeBinary(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeBinary");
@@ -3640,7 +4080,7 @@ var Civet = (() => {
         }
       }
       var TypeUnaryOp$0 = $EXPECT($L136, fail, 'TypeUnaryOp "keyof"');
-      var TypeUnaryOp$1 = $EXPECT($L87, fail, 'TypeUnaryOp "typeof"');
+      var TypeUnaryOp$1 = $EXPECT($L72, fail, 'TypeUnaryOp "typeof"');
       var TypeUnaryOp$2 = $EXPECT($L137, fail, 'TypeUnaryOp "infer"');
       function TypeUnaryOp(state) {
         if (state.tokenize) {
@@ -3649,7 +4089,7 @@ var Civet = (() => {
           return TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state);
         }
       }
-      var TypeIndexedAccess$0 = $S(__, $EXPECT($L27, fail, 'TypeIndexedAccess "["'), $E(Type), __, $EXPECT($L28, fail, 'TypeIndexedAccess "]"'));
+      var TypeIndexedAccess$0 = $S(__, OpenBracket, $E(Type), __, CloseBracket);
       function TypeIndexedAccess(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeIndexedAccess");
@@ -3660,9 +4100,9 @@ var Civet = (() => {
         }
       }
       var TypePrimary$0 = InterfaceBlock;
-      var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
+      var TypePrimary$1 = $S(__, OpenParen, Type, __, CloseParen);
       var TypePrimary$2 = $S($Q(_), FunctionType);
-      var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments));
+      var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S(Dot, IdentifierName)), $E(TypeArguments));
       var TypePrimary$4 = $S($Q(_), TypeLiteral);
       function TypePrimary(state) {
         if (state.tokenize) {
@@ -3671,7 +4111,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($L17, fail, 'TypeConditional "extends"'), Type, $E($S(__, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L14, fail, 'TypeConditional ":"'), Type)))));
+      var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L6, fail, 'TypeConditional "extends"'), Type, $E($S(__, QuestionMark, Type, __, Colon, Type)))));
       function TypeConditional(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeConditional");
@@ -3682,7 +4122,7 @@ var Civet = (() => {
         }
       }
       var TypeLiteral$0 = Literal;
-      var TypeLiteral$1 = $EXPECT($L86, fail, 'TypeLiteral "void"');
+      var TypeLiteral$1 = $EXPECT($L71, fail, 'TypeLiteral "void"');
       var TypeLiteral$2 = $EXPECT($L138, fail, 'TypeLiteral "[]"');
       function TypeLiteral(state) {
         if (state.tokenize) {
@@ -3691,8 +4131,8 @@ var Civet = (() => {
           return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
         }
       }
-      var TypeBinaryOp$0 = $EXPECT($L84, fail, 'TypeBinaryOp "|"');
-      var TypeBinaryOp$1 = $EXPECT($L82, fail, 'TypeBinaryOp "&"');
+      var TypeBinaryOp$0 = $EXPECT($L69, fail, 'TypeBinaryOp "|"');
+      var TypeBinaryOp$1 = $EXPECT($L67, fail, 'TypeBinaryOp "&"');
       function TypeBinaryOp(state) {
         if (state.tokenize) {
           return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
@@ -3700,7 +4140,7 @@ var Civet = (() => {
           return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
         }
       }
-      var FunctionType$0 = $S(Parameters, __, $EXPECT($L11, fail, 'FunctionType "=>"'), Type);
+      var FunctionType$0 = $S(Parameters, __, $EXPECT($L4, fail, 'FunctionType "=>"'), Type);
       function FunctionType(state) {
         if (state.verbose)
           console.log("ENTER:", "FunctionType");
@@ -3710,7 +4150,7 @@ var Civet = (() => {
           return FunctionType$0(state);
         }
       }
-      var TypeArguments$0 = $S(__, $EXPECT($L16, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L69, fail, 'TypeArguments ">"'));
+      var TypeArguments$0 = $S(__, $EXPECT($L5, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, Comma, __, Type)), $E($S(__, Comma)), __, $EXPECT($L54, fail, 'TypeArguments ">"'));
       function TypeArguments(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeArguments");
@@ -3720,7 +4160,7 @@ var Civet = (() => {
           return TypeArguments$0(state);
         }
       }
-      var TypeParameters$0 = $TS($S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L69, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+      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) {
         return { ts: true, children: $0 };
       });
       function TypeParameters(state) {
@@ -3742,7 +4182,7 @@ var Civet = (() => {
           return TypeParameter$0(state);
         }
       }
-      var TypeConstraint$0 = $S(__, $EXPECT($L17, fail, 'TypeConstraint "extends"'), Type);
+      var TypeConstraint$0 = $S(__, $EXPECT($L6, fail, 'TypeConstraint "extends"'), Type);
       function TypeConstraint(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeConstraint");
@@ -3752,13 +4192,13 @@ var Civet = (() => {
           return TypeConstraint$0(state);
         }
       }
-      var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
-      var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L69, fail, 'TypeParameterDelimiter ">"')));
-      var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L69, fail, 'TypeParameterDelimiter ">"'))), function(value) {
-        return ",";
+      var TypeParameterDelimiter$0 = $S($Q(_), Comma);
+      var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L54, fail, 'TypeParameterDelimiter ">"')));
+      var TypeParameterDelimiter$2 = $TV($Y($S(__, $EXPECT($L54, fail, 'TypeParameterDelimiter ">"'))), function($skip, $loc, $0, $1) {
+        return { $loc, token: "," };
       });
-      var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
-        return ",";
+      var TypeParameterDelimiter$3 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
+        return { $loc, token: "," };
       });
       function TypeParameterDelimiter(state) {
         if (state.tokenize) {
@@ -3817,7 +4257,7 @@ var Civet = (() => {
           return EOF$0(state);
         }
       }
-      var Debugger$0 = $TV($EXPECT($L33, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
+      var Debugger$0 = $TV($EXPECT($L16, fail, 'Debugger ""'), function($skip, $loc, $0, $1) {
         debugger;
       });
       function Debugger(state) {
@@ -3829,8 +4269,8 @@ var Civet = (() => {
           return Debugger$0(state);
         }
       }
-      var InsertOpenParen$0 = $T($EXPECT($L33, fail, 'InsertOpenParen ""'), function(value) {
-        return "(";
+      var InsertOpenParen$0 = $TV($EXPECT($L16, fail, 'InsertOpenParen ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "(" };
       });
       function InsertOpenParen(state) {
         if (state.verbose)
@@ -3841,8 +4281,8 @@ var Civet = (() => {
           return InsertOpenParen$0(state);
         }
       }
-      var InsertCloseParen$0 = $T($EXPECT($L33, fail, 'InsertCloseParen ""'), function(value) {
-        return ")";
+      var InsertCloseParen$0 = $TV($EXPECT($L16, fail, 'InsertCloseParen ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: ")" };
       });
       function InsertCloseParen(state) {
         if (state.verbose)
@@ -3853,8 +4293,8 @@ var Civet = (() => {
           return InsertCloseParen$0(state);
         }
       }
-      var InsertOpenBrace$0 = $T($EXPECT($L33, fail, 'InsertOpenBrace ""'), function(value) {
-        return " {";
+      var InsertOpenBrace$0 = $TV($EXPECT($L16, fail, 'InsertOpenBrace ""'), function($skip, $loc, $0, $1) {
+        return [{ $loc, token: " " }, { $loc, token: "{" }];
       });
       function InsertOpenBrace(state) {
         if (state.verbose)
@@ -3865,8 +4305,8 @@ var Civet = (() => {
           return InsertOpenBrace$0(state);
         }
       }
-      var InsertCloseBrace$0 = $T($EXPECT($L33, fail, 'InsertCloseBrace ""'), function(value) {
-        return "}";
+      var InsertCloseBrace$0 = $TV($EXPECT($L16, fail, 'InsertCloseBrace ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "}" };
       });
       function InsertCloseBrace(state) {
         if (state.verbose)
@@ -3877,7 +4317,31 @@ var Civet = (() => {
           return InsertCloseBrace$0(state);
         }
       }
-      var InsertNewline$0 = $TV($EXPECT($L33, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
+      var InsertConst$0 = $TV($EXPECT($L16, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "const " };
+      });
+      function InsertConst(state) {
+        if (state.verbose)
+          console.log("ENTER:", "InsertConst");
+        if (state.tokenize) {
+          return $TOKEN("InsertConst", state, InsertConst$0(state));
+        } else {
+          return InsertConst$0(state);
+        }
+      }
+      var InsertReadonly$0 = $TV($EXPECT($L16, fail, 'InsertReadonly ""'), function($skip, $loc, $0, $1) {
+        return { ts: true, children: [{ $loc, token: "readonly " }] };
+      });
+      function InsertReadonly(state) {
+        if (state.verbose)
+          console.log("ENTER:", "InsertReadonly");
+        if (state.tokenize) {
+          return $TOKEN("InsertReadonly", state, InsertReadonly$0(state));
+        } else {
+          return InsertReadonly$0(state);
+        }
+      }
+      var InsertNewline$0 = $TV($EXPECT($L16, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
         return "\n";
       });
       function InsertNewline(state) {
@@ -3889,7 +4353,7 @@ var Civet = (() => {
           return InsertNewline$0(state);
         }
       }
-      var InsertIndent$0 = $TV($EXPECT($L33, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
+      var InsertIndent$0 = $TV($EXPECT($L16, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
         return "".padStart(global.currentIndent * 2);
       });
       function InsertIndent(state) {
@@ -3901,8 +4365,8 @@ var Civet = (() => {
           return InsertIndent$0(state);
         }
       }
-      var InsertSpace$0 = $T($EXPECT($L33, fail, 'InsertSpace ""'), function(value) {
-        return " ";
+      var InsertSpace$0 = $TV($EXPECT($L16, fail, 'InsertSpace ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: " " };
       });
       function InsertSpace(state) {
         if (state.verbose)
@@ -3913,8 +4377,8 @@ var Civet = (() => {
           return InsertSpace$0(state);
         }
       }
-      var InsertDot$0 = $T($EXPECT($L33, fail, 'InsertDot ""'), function(value) {
-        return ".";
+      var InsertDot$0 = $TV($EXPECT($L16, fail, 'InsertDot ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "." };
       });
       function InsertDot(state) {
         if (state.verbose)
@@ -3925,8 +4389,8 @@ var Civet = (() => {
           return InsertDot$0(state);
         }
       }
-      var InsertBreak$0 = $T($EXPECT($L33, fail, 'InsertBreak ""'), function(value) {
-        return "break;";
+      var InsertBreak$0 = $TV($EXPECT($L16, fail, 'InsertBreak ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: "break;" };
       });
       function InsertBreak(state) {
         if (state.verbose)
@@ -3937,7 +4401,7 @@ var Civet = (() => {
           return InsertBreak$0(state);
         }
       }
-      var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L33, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
+      var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L16, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
         var directives = $2;
         global.currentIndent = 0;
         global.indentLevels = [0];
@@ -3946,13 +4410,19 @@ var Civet = (() => {
           const compatRe = /use coffee-compat/;
           module.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
         }
-        module.dedentBlockString = function(str) {
+        module.dedentBlockString = function({ $loc: $loc2, token: str }) {
           const spacing = str.match(/^(\r?\n|\n)\s+/);
           if (spacing) {
             str = str.replaceAll(spacing[0], "\n");
+            const l = spacing.length;
+            $loc2.pos += l;
+            $loc2.length -= l;
           }
           str = str.replace(/^(\r?\n|\n)/, "").replace(/(\r?\n|\n)[ \t]*$/, "").replace(/(`|\$)/g, "\\$1");
-          return str;
+          return {
+            $loc: $loc2,
+            token: str
+          };
         };
         return $0;
       });
@@ -3977,7 +4447,7 @@ var Civet = (() => {
           return Indent$0(state);
         }
       }
-      var PushIndent$0 = $TV($EXPECT($L33, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
+      var PushIndent$0 = $TV($EXPECT($L16, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
         global.currentIndent++;
         if (global.verbose) {
           console.log("pushing indent", global.currentIndent);
@@ -3994,7 +4464,7 @@ var Civet = (() => {
           return PushIndent$0(state);
         }
       }
-      var PopIndent$0 = $TV($EXPECT($L33, fail, 'PopIndent ""'), function($skip, $loc, $0, $1) {
+      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]);
         }
@@ -4146,15 +4616,24 @@ var Civet = (() => {
   // source/util.coffee
   var require_util = __commonJS({
     "source/util.coffee"(exports, module) {
+      "use strict";
       var BASE64_CHARS;
       var SourceMap;
       var VLQ_CONTINUATION_BIT;
       var VLQ_SHIFT;
       var VLQ_VALUE_MASK;
+      var base64Encode;
+      var decodeError;
+      var decodeVLQ;
       var encodeBase64;
       var encodeVlq;
       var locationTable;
       var lookupLineColumn;
+      var prettySourceExcerpt;
+      var remapPosition;
+      var smRegexp;
+      var vlqChars;
+      var vlqTable;
       locationTable = function(input) {
         var line, lines, linesRe, pos, result;
         linesRe = /([^\r\n]*)(\r\n|\r|\n|$)/y;
@@ -4191,6 +4670,9 @@ var Civet = (() => {
         EOL = /\r?\n|\r/;
         return {
           data: sm,
+          source: function() {
+            return sourceString;
+          },
           renderMappings: function() {
             var lastSourceColumn, lastSourceLine;
             lastSourceLine = 0;
@@ -4222,20 +4704,23 @@ var Civet = (() => {
             };
           },
           updateSourceMap: function(outputStr, inputPos) {
-            var outLines;
+            var outLines, srcCol, srcLine;
             outLines = outputStr.split(EOL);
+            if (inputPos != null) {
+              [srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
+            }
             outLines.forEach(function(line, i) {
-              var l, srcCol, srcLine;
+              var l;
               if (i > 0) {
                 sm.lineNum++;
                 sm.colOffset = 0;
                 sm.lines[sm.lineNum] = [];
+                srcCol = 0;
               }
               l = sm.colOffset;
               sm.colOffset = line.length;
               if (inputPos != null) {
-                [srcLine, srcCol] = lookupLineColumn(srcTable, inputPos);
-                return sm.lines[sm.lineNum].push([l, 0, srcLine, srcCol]);
+                return sm.lines[sm.lineNum].push([l, 0, srcLine + i, srcCol]);
               } else if (l !== 0) {
                 return sm.lines[sm.lineNum].push([l]);
               }
@@ -4243,6 +4728,95 @@ var Civet = (() => {
           }
         };
       };
+      SourceMap.parseWithLines = function(base64encodedJSONstr) {
+        var json, lines, sourceColumn, sourceLine;
+        json = JSON.parse(Buffer.from(base64encodedJSONstr, "base64").toString("utf8"));
+        sourceLine = 0;
+        sourceColumn = 0;
+        lines = json.mappings.split(";").map(function(line) {
+          if (line.length === 0) {
+            return [];
+          }
+          return line.split(",").map(function(entry) {
+            var result;
+            result = decodeVLQ(entry);
+            switch (result.length) {
+              case 1:
+                return [result[0]];
+              case 4:
+                return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3]];
+              case 5:
+                return [result[0], result[1], sourceLine += result[2], sourceColumn += result[3], result[4]];
+              default:
+                throw new Error("Unknown source map entry", result);
+            }
+          });
+        });
+        json.lines = lines;
+        return json;
+      };
+      smRegexp = /\n\/\/# sourceMappingURL=data:application\/json;charset=utf-8;base64,([+a-zA-Z0-9\/]*=?=?)$/;
+      SourceMap.remap = function(codeWithSourceMap, upstreamMap, sourcePath, targetPath) {
+        var codeWithoutSourceMap, composedLines, newSourceMap, parsed, remappedCodeWithSourceMap, remappedSourceMapJSON, sourceMapText;
+        sourceMapText = codeWithSourceMap.match(smRegexp);
+        if (sourceMapText) {
+          parsed = SourceMap.parseWithLines(sourceMapText[1]);
+        } else {
+          console.warn("No source map found in code");
+          return codeWithSourceMap;
+        }
+        debugger;
+        composedLines = SourceMap.composeLines(upstreamMap.data.lines, parsed.lines);
+        upstreamMap.data.lines = composedLines;
+        remappedSourceMapJSON = upstreamMap.json(sourcePath, targetPath);
+        codeWithoutSourceMap = codeWithSourceMap.replace(smRegexp, "");
+        newSourceMap = `${"sourceMapping"}URL=data:application/json;charset=utf-8;base64,${base64Encode(JSON.stringify(remappedSourceMapJSON))}`;
+        remappedCodeWithSourceMap = `${codeWithoutSourceMap}
+//# ${newSourceMap}`;
+        return remappedCodeWithSourceMap;
+      };
+      SourceMap.composeLines = function(upstreamMapping, lines) {
+        return lines.map(function(line, l) {
+          return line.map(function(entry) {
+            var colDelta, sourceFileIndex, srcCol, srcLine, srcPos, upstreamCol, upstreamLine;
+            if (entry.length === 1) {
+              return entry;
+            }
+            [colDelta, sourceFileIndex, srcLine, srcCol] = entry;
+            srcPos = remapPosition([srcLine, srcCol], upstreamMapping);
+            if (!srcPos) {
+              return [entry[0]];
+            }
+            [upstreamLine, upstreamCol] = srcPos;
+            if (entry.length === 4) {
+              return [colDelta, sourceFileIndex, upstreamLine, upstreamCol];
+            }
+            return [colDelta, sourceFileIndex, upstreamLine, upstreamCol, entry[4]];
+          });
+        });
+      };
+      prettySourceExcerpt = function(source, location, length) {
+        var colNum, i, j, line, lineNum, lineNumStr, lines, ref, ref1;
+        lines = source.split(/\r?\n|\r/);
+        lineNum = location.line;
+        colNum = location.column;
+        for (i = j = ref = lineNum - 2, ref1 = lineNum + 2; ref <= ref1 ? j <= ref1 : j >= ref1; i = ref <= ref1 ? ++j : --j) {
+          if (i < 0 || i >= lines.length) {
+            continue;
+          }
+          line = lines[i];
+          lineNumStr = (i + 1).toString();
+          while (lineNumStr.length < 4) {
+            lineNumStr = " " + lineNumStr;
+          }
+          if (i === lineNum) {
+            console.log(`${lineNumStr}: ${line}`);
+            console.log(" ".repeat(lineNumStr.length + 2 + colNum) + "^".repeat(length));
+          } else {
+            console.log(`${lineNumStr}: ${line}`);
+          }
+        }
+      };
       VLQ_SHIFT = 5;
       VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT;
       VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1;
@@ -4267,7 +4841,101 @@ var Civet = (() => {
           throw new Error(`Cannot Base64 encode value: ${value}`);
         }();
       };
-      module.exports = { locationTable, lookupLineColumn, SourceMap };
+      base64Encode = function(src) {
+        return Buffer.from(src).toString("base64");
+      };
+      module.exports = { base64Encode, locationTable, lookupLineColumn, SourceMap };
+      vlqTable = new Uint8Array(128);
+      vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+      (function() {
+        var i, l, results;
+        i = 0;
+        l = vlqTable.length;
+        while (i < l) {
+          vlqTable[i] = 255;
+          i++;
+        }
+        i = 0;
+        l = vlqChars.length;
+        results = [];
+        while (i < l) {
+          vlqTable[vlqChars.charCodeAt(i)] = i;
+          results.push(i++);
+        }
+        return results;
+      })();
+      decodeError = function(message) {
+        throw new Error(message);
+      };
+      decodeVLQ = function(mapping) {
+        var c, i, index, l, result, shift, v, vlq;
+        i = 0;
+        l = mapping.length;
+        result = [];
+        while (i < l) {
+          shift = 0;
+          vlq = 0;
+          while (true) {
+            if (i >= l) {
+              decodeError("Unexpected early end of mapping data");
+            }
+            c = mapping.charCodeAt(i);
+            if ((c & 127) !== c) {
+              decodeError(`Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}`);
+            }
+            index = vlqTable[c & 127];
+            if (index === 255) {
+              decodeError(`Invalid mapping character: ${JSON.stringify(String.fromCharCode(c))}`);
+            }
+            i++;
+            vlq |= (index & 31) << shift;
+            shift += 5;
+            if ((index & 32) === 0) {
+              break;
+            }
+          }
+          if (vlq & 1) {
+            v = -(vlq >> 1);
+          } else {
+            v = vlq >> 1;
+          }
+          result.push(v);
+        }
+        return result;
+      };
+      remapPosition = function(position, sourcemapLines) {
+        var character, i, l, lastMapping, lastMappingPosition, line, mapping, p, textLine;
+        [line, character] = position;
+        textLine = sourcemapLines[line];
+        if (!(textLine != null ? textLine.length : void 0)) {
+          return void 0;
+        }
+        i = 0;
+        p = 0;
+        l = textLine.length;
+        lastMapping = void 0;
+        lastMappingPosition = 0;
+        while (i < l) {
+          mapping = textLine[i];
+          p += mapping[0];
+          if (mapping.length === 4) {
+            lastMapping = mapping;
+            lastMappingPosition = p;
+          }
+          if (p >= character) {
+            break;
+          }
+          i++;
+        }
+        if (character - lastMappingPosition !== 0) {
+          return void 0;
+        }
+        if (lastMapping) {
+          return [lastMapping[2], lastMapping[3]];
+        } else {
+          return void 0;
+        }
+      };
     }
   });
 
@@ -4275,6 +4943,7 @@ var Civet = (() => {
   var require_main = __commonJS({
     "source/main.coffee"(exports, module) {
       var SourceMap;
+      var base64Encode;
       var defaultOptions;
       var gen;
       var parse;
@@ -4282,23 +4951,34 @@ var Civet = (() => {
       var util;
       ({ parse } = require_parser());
       ({ prune } = gen = require_generate());
-      ({ SourceMap } = util = require_util());
+      ({ SourceMap, base64Encode } = util = require_util());
       defaultOptions = {};
       module.exports = {
         parse,
         compile: function(src, options = defaultOptions) {
-          var ast, code, sm;
+          var ast, code, filename, sm, srcMapJSON;
+          filename = options.filename || "unknown";
           ast = prune(parse(src, {
-            filename: options.filename
+            filename
           }));
-          if (options.sourceMap) {
+          if (options.ast) {
+            return ast;
+          }
+          if (options.sourceMap || options.inlineMap) {
             sm = SourceMap(src);
             options.updateSourceMap = sm.updateSourceMap;
             code = gen(ast, options);
-            return {
-              code,
-              sourceMap: sm
-            };
+            if (options.inlineMap) {
+              srcMapJSON = sm.json(filename, "");
+              return `${code}
+${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode(JSON.stringify(srcMapJSON))}
+`;
+            } else {
+              return {
+                code,
+                sourceMap: sm
+              };
+            }
           }
           return gen(ast, options);
         },