@danielx/civet 0.3.16 → 0.4.0

package/dist/main.js

@@ -429,14 +429,12 @@ var require_parser = __commonJS({
       PrimaryExpression,
       ClassDeclaration,
       ClassExpression,
-      Class,
       ClassHeritage,
       ExtendsToken,
       ClassBody,
       NestedClassElements,
       NestedClassElement,
       ClassElement,
-      Static,
       FieldDefinition,
       This,
       AtAccessor,
@@ -527,7 +525,6 @@ var require_parser = __commonJS({
       WhileClause,
       ForStatement,
       ForInOfStatement,
-      For,
       ForDeclaration,
       LetOrConst,
       ForBinding,
@@ -536,10 +533,9 @@ var require_parser = __commonJS({
       NestedCaseClauses,
       NestedCaseClause,
       CaseClause,
-      When,
       ImpliedColon,
       TryStatement,
-      Catch,
+      CatchClause,
       CatchBind,
       Finally,
       CatchParameter,
@@ -547,15 +543,12 @@ var require_parser = __commonJS({
       ExpressionStatement,
       KeywordStatement,
       MaybeNestedExpression,
-      Return,
       ImportDeclaration,
       ImpliedImport,
-      Import,
       ImportClause,
       NameSpaceImport,
       NamedImports,
       FromClause,
-      From,
       ImportSpecifier,
       ModuleExportName,
       ModuleSpecifier,
@@ -563,8 +556,6 @@ var require_parser = __commonJS({
       UnquotedSpecifier,
       ImportedBinding,
       ExportDeclaration,
-      As,
-      Export,
       ExportFromClause,
       NamedExports,
       ExportSpecifier,
@@ -587,8 +578,8 @@ var require_parser = __commonJS({
       StringLiteral,
       DoubleStringCharacter,
       SingleStringCharacter,
-      TripleDoubleStringCharacter,
-      TripleSingleStringCharacter,
+      TripleDoubleStringCharacters,
+      TripleSingleStringCharacters,
       RegularExpressionLiteral,
       RegularExpressionBody,
       RegExpCharacter,
@@ -607,9 +598,49 @@ var require_parser = __commonJS({
       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,
@@ -685,132 +716,132 @@ var require_parser = __commonJS({
       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("<>");
@@ -829,30 +860,30 @@ var require_parser = __commonJS({
     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"));
@@ -883,7 +914,7 @@ var require_parser = __commonJS({
         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");
@@ -893,7 +924,7 @@ var require_parser = __commonJS({
         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");
@@ -937,7 +968,7 @@ var require_parser = __commonJS({
         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");
@@ -961,7 +992,7 @@ var require_parser = __commonJS({
       var pre = $1;
       var exp = $2;
       var post = $3;
-      if (post === "?") {
+      if (post?.token === "?") {
         return ["(", pre, , "(", exp, ") != null)"];
       }
       return [pre, exp, post];
@@ -975,8 +1006,8 @@ var require_parser = __commonJS({
         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) {
@@ -995,7 +1026,7 @@ var require_parser = __commonJS({
         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) {
@@ -1018,7 +1049,7 @@ var require_parser = __commonJS({
     }
     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) {
@@ -1028,7 +1059,7 @@ var require_parser = __commonJS({
         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");
@@ -1038,7 +1069,7 @@ var require_parser = __commonJS({
         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");
@@ -1057,7 +1088,7 @@ var require_parser = __commonJS({
         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 " =>";
@@ -1072,7 +1103,7 @@ var require_parser = __commonJS({
         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;
@@ -1092,7 +1123,7 @@ var require_parser = __commonJS({
         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");
@@ -1121,7 +1152,7 @@ var require_parser = __commonJS({
     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) {
@@ -1151,18 +1182,6 @@ var require_parser = __commonJS({
         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)
@@ -1173,10 +1192,10 @@ var require_parser = __commonJS({
         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) {
@@ -1186,7 +1205,7 @@ var require_parser = __commonJS({
         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) {
@@ -1229,19 +1248,15 @@ var require_parser = __commonJS({
         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 };
+    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;
     });
-    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 = $S(InsertReadonly, ClassElementName, $E(TypeSuffix), __, ConstAssignment, AssignmentExpression);
     var FieldDefinition$1 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
     function FieldDefinition(state) {
       if (state.tokenize) {
@@ -1250,11 +1265,11 @@ var require_parser = __commonJS({
         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) {
@@ -1264,7 +1279,7 @@ var require_parser = __commonJS({
         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) {
@@ -1285,7 +1300,7 @@ var require_parser = __commonJS({
         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");
@@ -1295,8 +1310,8 @@ var require_parser = __commonJS({
         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) {
@@ -1316,7 +1331,7 @@ var require_parser = __commonJS({
         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");
@@ -1326,7 +1341,7 @@ var require_parser = __commonJS({
         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) {
@@ -1348,10 +1363,11 @@ var require_parser = __commonJS({
         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)
@@ -1382,9 +1398,9 @@ var require_parser = __commonJS({
         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];
@@ -1398,7 +1414,7 @@ var require_parser = __commonJS({
         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");
@@ -1408,7 +1424,7 @@ var require_parser = __commonJS({
         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");
@@ -1418,8 +1434,10 @@ var require_parser = __commonJS({
         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));
@@ -1427,9 +1445,9 @@ var require_parser = __commonJS({
         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) {
@@ -1448,13 +1466,13 @@ var require_parser = __commonJS({
         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) {
@@ -1482,7 +1500,7 @@ var require_parser = __commonJS({
         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");
@@ -1492,7 +1510,7 @@ var require_parser = __commonJS({
         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");
@@ -1502,7 +1520,7 @@ var require_parser = __commonJS({
         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) {
@@ -1511,7 +1529,7 @@ var require_parser = __commonJS({
         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");
@@ -1531,7 +1549,7 @@ var require_parser = __commonJS({
         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");
@@ -1552,7 +1570,7 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -1581,7 +1599,7 @@ var require_parser = __commonJS({
         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) {
@@ -1593,7 +1611,7 @@ var require_parser = __commonJS({
         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);
@@ -1613,7 +1631,7 @@ var require_parser = __commonJS({
         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) {
@@ -1674,7 +1692,7 @@ var require_parser = __commonJS({
         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) {
@@ -1686,7 +1704,7 @@ var require_parser = __commonJS({
         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) {
@@ -1698,7 +1716,9 @@ var require_parser = __commonJS({
         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");
@@ -1743,8 +1763,8 @@ var require_parser = __commonJS({
         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));
@@ -1777,10 +1797,10 @@ var require_parser = __commonJS({
         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) {
@@ -1789,7 +1809,7 @@ var require_parser = __commonJS({
         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");
@@ -1799,7 +1819,7 @@ var require_parser = __commonJS({
         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");
@@ -1809,7 +1829,7 @@ var require_parser = __commonJS({
         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");
@@ -1819,7 +1839,7 @@ var require_parser = __commonJS({
         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");
@@ -1829,9 +1849,9 @@ var require_parser = __commonJS({
         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) {
@@ -1865,13 +1885,13 @@ var require_parser = __commonJS({
         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) {
@@ -1880,7 +1900,7 @@ var require_parser = __commonJS({
         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");
@@ -1890,9 +1910,9 @@ var require_parser = __commonJS({
         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) {
@@ -1904,7 +1924,7 @@ var require_parser = __commonJS({
     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));
@@ -1912,8 +1932,8 @@ var require_parser = __commonJS({
         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;
@@ -1925,7 +1945,7 @@ var require_parser = __commonJS({
         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");
@@ -1954,7 +1974,7 @@ var require_parser = __commonJS({
         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");
@@ -1964,7 +1984,7 @@ var require_parser = __commonJS({
         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");
@@ -1984,7 +2004,7 @@ var require_parser = __commonJS({
         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");
@@ -2004,7 +2024,7 @@ var require_parser = __commonJS({
         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");
@@ -2036,25 +2056,25 @@ var require_parser = __commonJS({
         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));
@@ -2074,52 +2094,52 @@ var require_parser = __commonJS({
         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 (module2.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 (module2.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));
@@ -2128,7 +2148,7 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -2146,11 +2166,13 @@ var require_parser = __commonJS({
         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) {
@@ -2162,13 +2184,24 @@ var require_parser = __commonJS({
         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)
@@ -2195,7 +2228,7 @@ var require_parser = __commonJS({
         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");
@@ -2205,7 +2238,7 @@ var require_parser = __commonJS({
         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");
@@ -2215,17 +2248,21 @@ var require_parser = __commonJS({
         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) {
@@ -2246,10 +2283,7 @@ var require_parser = __commonJS({
         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");
@@ -2259,7 +2293,7 @@ var require_parser = __commonJS({
         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");
@@ -2279,7 +2313,7 @@ var require_parser = __commonJS({
         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") {
@@ -2298,7 +2332,7 @@ var require_parser = __commonJS({
         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");
@@ -2308,10 +2342,10 @@ var require_parser = __commonJS({
         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));
@@ -2319,18 +2353,6 @@ var require_parser = __commonJS({
         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)
@@ -2341,7 +2363,7 @@ var require_parser = __commonJS({
         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) {
@@ -2362,7 +2384,7 @@ var require_parser = __commonJS({
         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");
@@ -2372,7 +2394,7 @@ var require_parser = __commonJS({
         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) {
@@ -2406,9 +2428,9 @@ var require_parser = __commonJS({
         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));
@@ -2416,21 +2438,9 @@ var require_parser = __commonJS({
         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) {
@@ -2439,7 +2449,7 @@ var require_parser = __commonJS({
         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) {
@@ -2456,17 +2466,17 @@ var require_parser = __commonJS({
         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) {
@@ -2475,7 +2485,7 @@ var require_parser = __commonJS({
         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");
@@ -2494,7 +2504,7 @@ var require_parser = __commonJS({
         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) {
@@ -2513,11 +2523,11 @@ var require_parser = __commonJS({
         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));
@@ -2534,24 +2544,22 @@ var require_parser = __commonJS({
         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));
@@ -2559,8 +2567,8 @@ var require_parser = __commonJS({
         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)
@@ -2571,19 +2579,7 @@ var require_parser = __commonJS({
         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) {
@@ -2593,7 +2589,7 @@ var require_parser = __commonJS({
         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");
@@ -2603,7 +2599,7 @@ var require_parser = __commonJS({
         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");
@@ -2623,19 +2619,7 @@ var require_parser = __commonJS({
         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) {
@@ -2675,7 +2659,7 @@ var require_parser = __commonJS({
         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}"` };
     });
@@ -2698,7 +2682,7 @@ var require_parser = __commonJS({
         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) {
@@ -2708,27 +2692,7 @@ var require_parser = __commonJS({
         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) {
@@ -2737,7 +2701,7 @@ var require_parser = __commonJS({
         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");
@@ -2747,7 +2711,7 @@ var require_parser = __commonJS({
         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");
@@ -2778,8 +2742,16 @@ var require_parser = __commonJS({
         return HoistableDeclaration$0(state);
       }
     }
-    var LexicalDeclaration$0 = $S(LetOrConst, __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
-    var LexicalDeclaration$1 = $S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, AssignmentExpression);
+    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) {
         return $TOKEN("LexicalDeclaration", state, LexicalDeclaration$0(state) || LexicalDeclaration$1(state));
@@ -2787,7 +2759,7 @@ var require_parser = __commonJS({
         return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
       }
     }
-    var ConstAssignment$0 = $TV($EXPECT($L116, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
+    var ConstAssignment$0 = $TV($EXPECT($L87, fail, 'ConstAssignment ":="'), function($skip, $loc, $0, $1) {
       return { $loc, token: "=" };
     });
     function ConstAssignment(state) {
@@ -2808,7 +2780,7 @@ var require_parser = __commonJS({
         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");
@@ -2818,7 +2790,7 @@ var require_parser = __commonJS({
         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");
@@ -2828,7 +2800,7 @@ var require_parser = __commonJS({
         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");
@@ -2871,7 +2843,7 @@ var require_parser = __commonJS({
         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");
@@ -2881,7 +2853,7 @@ var require_parser = __commonJS({
         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");
@@ -2891,7 +2863,7 @@ var require_parser = __commonJS({
         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");
@@ -2901,7 +2873,7 @@ var require_parser = __commonJS({
         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");
@@ -2911,7 +2883,7 @@ var require_parser = __commonJS({
         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");
@@ -2921,18 +2893,22 @@ var require_parser = __commonJS({
         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: "`" + module2.dedentBlockString(str) + "`" };
+      var e = $3;
+      return [s, module2.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: "`" + module2.dedentBlockString(str) + "`" };
+      var e = $3;
+      return [s, module2.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) {
@@ -2942,7 +2918,7 @@ var require_parser = __commonJS({
         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");
@@ -2952,7 +2928,7 @@ var require_parser = __commonJS({
         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");
@@ -2962,27 +2938,31 @@ var require_parser = __commonJS({
         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) {
@@ -2994,7 +2974,7 @@ var require_parser = __commonJS({
         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");
@@ -3004,7 +2984,7 @@ var require_parser = __commonJS({
         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");
@@ -3014,7 +2994,7 @@ var require_parser = __commonJS({
         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");
@@ -3024,7 +3004,7 @@ var require_parser = __commonJS({
         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");
@@ -3034,7 +3014,7 @@ var require_parser = __commonJS({
         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");
@@ -3044,7 +3024,7 @@ var require_parser = __commonJS({
         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");
@@ -3054,7 +3034,7 @@ var require_parser = __commonJS({
         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");
@@ -3073,7 +3053,9 @@ var require_parser = __commonJS({
         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) {
@@ -3091,7 +3073,9 @@ var require_parser = __commonJS({
         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");
@@ -3101,10 +3085,10 @@ var require_parser = __commonJS({
         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 (!module2.coffeeCompat)
         return $skip;
-      return ["//", $1];
+      return { $loc, token: `//${$1}` };
     });
     function CoffeeSingleLineComment(state) {
       if (state.verbose)
@@ -3115,8 +3099,8 @@ var require_parser = __commonJS({
         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)
@@ -3127,7 +3111,9 @@ var require_parser = __commonJS({
         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");
@@ -3137,7 +3123,7 @@ var require_parser = __commonJS({
         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");
@@ -3147,7 +3133,7 @@ var require_parser = __commonJS({
         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) {
@@ -3157,7 +3143,7 @@ var require_parser = __commonJS({
         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:", "_");
@@ -3167,7 +3153,19 @@ var require_parser = __commonJS({
         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:", "__");
@@ -3177,9 +3175,21 @@ var require_parser = __commonJS({
         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) {
@@ -3188,7 +3198,7 @@ var require_parser = __commonJS({
         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");
@@ -3198,6 +3208,462 @@ var require_parser = __commonJS({
         return NonIdContinue$0(state);
       }
     }
+    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);
+      }
+    }
+    var As$0 = $TS($S($EXPECT($L95, fail, 'As "as"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
+      return { $loc, token: $1 };
+    });
+    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 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:", "Async");
+      if (state.tokenize) {
+        return $TOKEN("Async", state, Async$0(state));
+      } else {
+        return Async$0(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:", "Await");
+      if (state.tokenize) {
+        return $TOKEN("Await", state, Await$0(state));
+      } else {
+        return Await$0(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:", "Catch");
+      if (state.tokenize) {
+        return $TOKEN("Catch", state, Catch$0(state));
+      } else {
+        return Catch$0(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:", "Class");
+      if (state.tokenize) {
+        return $TOKEN("Class", state, Class$0(state));
+      } else {
+        return Class$0(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:", "CloseBrace");
+      if (state.tokenize) {
+        return $TOKEN("CloseBrace", state, CloseBrace$0(state));
+      } else {
+        return CloseBrace$0(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:", "CloseBracket");
+      if (state.tokenize) {
+        return $TOKEN("CloseBracket", state, CloseBracket$0(state));
+      } else {
+        return CloseBracket$0(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:", "CloseParen");
+      if (state.tokenize) {
+        return $TOKEN("CloseParen", state, CloseParen$0(state));
+      } else {
+        return CloseParen$0(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("Colon", state, Colon$0(state));
+      } else {
+        return Colon$0(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:", "Dot");
+      if (state.tokenize) {
+        return $TOKEN("Dot", state, Dot$0(state));
+      } else {
+        return Dot$0(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:", "Else");
+      if (state.tokenize) {
+        return $TOKEN("Else", state, Else$0(state));
+      } else {
+        return Else$0(state);
+      }
+    }
+    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]) {
@@ -3212,7 +3678,7 @@ var require_parser = __commonJS({
         return JSXElement$0(state) || JSXElement$1(state);
       }
     }
-    var JSXSelfClosingElement$0 = $S($EXPECT($L16, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L126, fail, 'JSXSelfClosingElement "/>"'));
+    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");
@@ -3222,7 +3688,7 @@ var require_parser = __commonJS({
         return JSXSelfClosingElement$0(state);
       }
     }
-    var JSXOpeningElement$0 = $S($EXPECT($L16, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L69, fail, 'JSXOpeningElement ">"'));
+    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");
@@ -3232,7 +3698,7 @@ var require_parser = __commonJS({
         return JSXOpeningElement$0(state);
       }
     }
-    var JSXClosingElement$0 = $S($EXPECT($L127, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L69, fail, 'JSXClosingElement ">"'));
+    var JSXClosingElement$0 = $S($EXPECT($L127, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L54, fail, 'JSXClosingElement ">"'));
     function JSXClosingElement(state) {
       if (state.verbose)
         console.log("ENTER:", "JSXClosingElement");
@@ -3252,7 +3718,7 @@ var require_parser = __commonJS({
         return JSXFragment$0(state);
       }
     }
-    var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L14, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
+    var JSXElementName$0 = $S(JSXIdentifierName, $C($S(Colon, JSXIdentifierName), $Q($S(Dot, JSXIdentifierName))));
     function JSXElementName(state) {
       if (state.verbose)
         console.log("ENTER:", "JSXElementName");
@@ -3282,7 +3748,7 @@ var require_parser = __commonJS({
         return JSXAttributes$0(state);
       }
     }
-    var JSXAttribute$0 = $S($EXPECT($L12, fail, 'JSXAttribute "{"'), __, $EXPECT($L34, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L13, fail, 'JSXAttribute "}"'));
+    var JSXAttribute$0 = $S(OpenBrace, __, $EXPECT($L18, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, CloseBrace);
     var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
     function JSXAttribute(state) {
       if (state.tokenize) {
@@ -3291,7 +3757,7 @@ var require_parser = __commonJS({
         return JSXAttribute$0(state) || JSXAttribute$1(state);
       }
     }
-    var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L14, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
+    var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S(Colon, JSXIdentifierName)));
     function JSXAttributeName(state) {
       if (state.verbose)
         console.log("ENTER:", "JSXAttributeName");
@@ -3301,7 +3767,7 @@ var require_parser = __commonJS({
         return JSXAttributeName$0(state);
       }
     }
-    var JSXAttributeInitializer$0 = $S(__, $EXPECT($L58, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
+    var JSXAttributeInitializer$0 = $S(__, Equals, __, JSXAttributeValue);
     function JSXAttributeInitializer(state) {
       if (state.verbose)
         console.log("ENTER:", "JSXAttributeInitializer");
@@ -3313,7 +3779,7 @@ var require_parser = __commonJS({
     }
     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 JSXAttributeValue$2 = $S(OpenBrace, __, AssignmentExpression, __, CloseBrace);
     var JSXAttributeValue$3 = JSXElement;
     var JSXAttributeValue$4 = JSXFragment;
     function JSXAttributeValue(state) {
@@ -3336,7 +3802,7 @@ var require_parser = __commonJS({
     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));
@@ -3354,7 +3820,7 @@ var require_parser = __commonJS({
         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");
@@ -3377,7 +3843,7 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -3385,7 +3851,7 @@ var require_parser = __commonJS({
         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) {
@@ -3425,8 +3891,8 @@ var require_parser = __commonJS({
         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) {
@@ -3469,13 +3935,13 @@ var require_parser = __commonJS({
         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) {
@@ -3484,8 +3950,8 @@ var require_parser = __commonJS({
         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) {
@@ -3519,7 +3985,7 @@ var require_parser = __commonJS({
         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");
@@ -3530,7 +3996,7 @@ var require_parser = __commonJS({
       }
     }
     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));
@@ -3538,7 +4004,7 @@ var require_parser = __commonJS({
         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) {
@@ -3550,7 +4016,7 @@ var require_parser = __commonJS({
         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) {
@@ -3562,7 +4028,7 @@ var require_parser = __commonJS({
         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");
@@ -3613,7 +4079,7 @@ var require_parser = __commonJS({
       }
     }
     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) {
@@ -3622,7 +4088,7 @@ var require_parser = __commonJS({
         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");
@@ -3633,9 +4099,9 @@ var require_parser = __commonJS({
       }
     }
     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) {
@@ -3644,7 +4110,7 @@ var require_parser = __commonJS({
         return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
       }
     }
-    var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($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");
@@ -3655,7 +4121,7 @@ var require_parser = __commonJS({
       }
     }
     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) {
@@ -3664,8 +4130,8 @@ var require_parser = __commonJS({
         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));
@@ -3673,7 +4139,7 @@ var require_parser = __commonJS({
         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");
@@ -3683,7 +4149,7 @@ var require_parser = __commonJS({
         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");
@@ -3693,7 +4159,7 @@ var require_parser = __commonJS({
         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) {
@@ -3715,7 +4181,7 @@ var require_parser = __commonJS({
         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");
@@ -3725,13 +4191,13 @@ var require_parser = __commonJS({
         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) {
@@ -3790,7 +4256,7 @@ var require_parser = __commonJS({
         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) {
@@ -3802,8 +4268,8 @@ var require_parser = __commonJS({
         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)
@@ -3814,8 +4280,8 @@ var require_parser = __commonJS({
         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)
@@ -3826,8 +4292,8 @@ var require_parser = __commonJS({
         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)
@@ -3838,8 +4304,8 @@ var require_parser = __commonJS({
         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)
@@ -3850,8 +4316,8 @@ var require_parser = __commonJS({
         return InsertCloseBrace$0(state);
       }
     }
-    var InsertConst$0 = $T($EXPECT($L33, fail, 'InsertConst ""'), function(value) {
-      return "const ";
+    var InsertConst$0 = $TV($EXPECT($L16, fail, 'InsertConst ""'), function($skip, $loc, $0, $1) {
+      return { $loc, token: "const " };
     });
     function InsertConst(state) {
       if (state.verbose)
@@ -3862,8 +4328,8 @@ var require_parser = __commonJS({
         return InsertConst$0(state);
       }
     }
-    var InsertReadonly$0 = $T($EXPECT($L33, fail, 'InsertReadonly ""'), function(value) {
-      return { "ts": true, "children": ["readonly "] };
+    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)
@@ -3874,7 +4340,7 @@ var require_parser = __commonJS({
         return InsertReadonly$0(state);
       }
     }
-    var InsertNewline$0 = $TV($EXPECT($L33, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
+    var InsertNewline$0 = $TV($EXPECT($L16, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
       return "\n";
     });
     function InsertNewline(state) {
@@ -3886,7 +4352,7 @@ var require_parser = __commonJS({
         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) {
@@ -3898,8 +4364,8 @@ var require_parser = __commonJS({
         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)
@@ -3910,8 +4376,8 @@ var require_parser = __commonJS({
         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)
@@ -3922,8 +4388,8 @@ var require_parser = __commonJS({
         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)
@@ -3934,7 +4400,7 @@ var require_parser = __commonJS({
         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];
@@ -3943,13 +4409,19 @@ var require_parser = __commonJS({
         const compatRe = /use coffee-compat/;
         module2.coffeeCompat = directives.some((d) => d[1].token?.match(compatRe));
       }
-      module2.dedentBlockString = function(str) {
+      module2.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;
     });
@@ -3974,7 +4446,7 @@ var require_parser = __commonJS({
         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);
@@ -3991,7 +4463,7 @@ var require_parser = __commonJS({
         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]);
       }
@@ -4143,15 +4615,24 @@ var require_generate = __commonJS({
 // source/util.coffee
 var require_util = __commonJS({
   "source/util.coffee"(exports2, module2) {
+    "use strict";
     var BASE64_CHARS;
     var SourceMap2;
     var VLQ_CONTINUATION_BIT;
     var VLQ_SHIFT;
     var VLQ_VALUE_MASK;
+    var base64Encode2;
+    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;
@@ -4188,6 +4669,9 @@ var require_util = __commonJS({
       EOL = /\r?\n|\r/;
       return {
         data: sm,
+        source: function() {
+          return sourceString;
+        },
         renderMappings: function() {
           var lastSourceColumn, lastSourceLine;
           lastSourceLine = 0;
@@ -4219,20 +4703,23 @@ var require_util = __commonJS({
           };
         },
         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]);
             }
@@ -4240,6 +4727,95 @@ var require_util = __commonJS({
         }
       };
     };
+    SourceMap2.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\/]*=?=?)$/;
+    SourceMap2.remap = function(codeWithSourceMap, upstreamMap, sourcePath, targetPath) {
+      var codeWithoutSourceMap, composedLines, newSourceMap, parsed, remappedCodeWithSourceMap, remappedSourceMapJSON, sourceMapText;
+      sourceMapText = codeWithSourceMap.match(smRegexp);
+      if (sourceMapText) {
+        parsed = SourceMap2.parseWithLines(sourceMapText[1]);
+      } else {
+        console.warn("No source map found in code");
+        return codeWithSourceMap;
+      }
+      debugger;
+      composedLines = SourceMap2.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,${base64Encode2(JSON.stringify(remappedSourceMapJSON))}`;
+      remappedCodeWithSourceMap = `${codeWithoutSourceMap}
+//# ${newSourceMap}`;
+      return remappedCodeWithSourceMap;
+    };
+    SourceMap2.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;
@@ -4264,7 +4840,101 @@ var require_util = __commonJS({
         throw new Error(`Cannot Base64 encode value: ${value}`);
       }();
     };
-    module2.exports = { locationTable, lookupLineColumn, SourceMap: SourceMap2 };
+    base64Encode2 = function(src) {
+      return Buffer.from(src).toString("base64");
+    };
+    module2.exports = { base64Encode: base64Encode2, locationTable, lookupLineColumn, SourceMap: SourceMap2 };
+    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;
+      }
+    };
   }
 });
 
@@ -4278,7 +4948,7 @@ var prune;
 var util;
 ({ parse } = require_parser());
 ({ prune } = gen = require_generate());
-({ SourceMap } = util = require_util());
+({ SourceMap, base64Encode } = util = require_util());
 defaultOptions = {};
 module.exports = {
   parse,
@@ -4296,9 +4966,9 @@ module.exports = {
       options.updateSourceMap = sm.updateSourceMap;
       code = gen(ast, options);
       if (options.inlineMap) {
-        srcMapJSON = sm.json(filename, filename.replace(/(?:\.civet$)?/, ".ts"));
+        srcMapJSON = sm.json(filename, "");
         return `${code}
-//# sourceMappingURL=data:application/json;base64,${base64Encode(JSON.stringify(srcMapJSON))}
+${"//#"} sourceMappingURL=data:application/json;base64,${base64Encode(JSON.stringify(srcMapJSON))}
 `;
       } else {
         return {
@@ -4312,6 +4982,3 @@ module.exports = {
   generate: gen,
   util
 };
-base64Encode = function(src) {
-  return Buffer.from(src).toString("base64");
-};