@danielx/civet 0.1.0

package/dist/main.js

@@ -0,0 +1,3066 @@
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// source/parser.hera
+var require_parser = __commonJS({
+  "source/parser.hera"(exports2, module2) {
+    "use strict";
+    var __spreadArray = exports2 && exports2.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    exports2.__esModule = true;
+    exports2.parserState = exports2.$R$0 = exports2.$TV = exports2.$TS = exports2.$TR = exports2.$T = exports2.$Y = exports2.$N = exports2.$TOKEN = exports2.$TEXT = exports2.$P = exports2.$Q = exports2.$E = exports2.$S = exports2.$C = exports2.$R = exports2.$L = exports2.$EXPECT = void 0;
+    function $EXPECT(parser, fail2, expectation) {
+      return function(state) {
+        var result = parser(state);
+        if (result)
+          return result;
+        var pos = state.pos;
+        fail2(pos, expectation);
+        return;
+      };
+    }
+    exports2.$EXPECT = $EXPECT;
+    function $L(str) {
+      return function(state) {
+        var input = state.input, pos = state.pos;
+        var length = str.length;
+        if (input.substr(pos, length) === str) {
+          return {
+            loc: {
+              pos,
+              length
+            },
+            pos: pos + length,
+            value: str
+          };
+        }
+        return;
+      };
+    }
+    exports2.$L = $L;
+    function $R(regExp) {
+      return function(state) {
+        var input = state.input, pos = state.pos;
+        regExp.lastIndex = state.pos;
+        var l, m, v;
+        if (m = input.match(regExp)) {
+          v = m[0];
+          l = v.length;
+          return {
+            loc: {
+              pos,
+              length: l
+            },
+            pos: pos + l,
+            value: m
+          };
+        }
+        return;
+      };
+    }
+    exports2.$R = $R;
+    function $C() {
+      var terms = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        terms[_i] = arguments[_i];
+      }
+      return function(state) {
+        var i = 0;
+        var l = terms.length;
+        while (i < l) {
+          var r = terms[i++](state);
+          if (r)
+            return r;
+        }
+        return;
+      };
+    }
+    exports2.$C = $C;
+    function $S() {
+      var terms = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        terms[_i] = arguments[_i];
+      }
+      return function(state) {
+        var input = state.input, pos = state.pos, tokenize = state.tokenize, verbose = state.verbose, i = 0, value;
+        var results = [], s = pos, l = terms.length;
+        while (i < l) {
+          var r = terms[i++]({ input, pos, tokenize, verbose });
+          if (r) {
+            pos = r.pos, value = r.value;
+            results.push(value);
+          } else
+            return;
+        }
+        return {
+          loc: {
+            pos: s,
+            length: pos - s
+          },
+          pos,
+          value: results
+        };
+      };
+    }
+    exports2.$S = $S;
+    function $E(fn) {
+      return function(state) {
+        var r = fn(state);
+        if (r)
+          return r;
+        var pos = state.pos;
+        return {
+          loc: {
+            pos,
+            length: 0
+          },
+          pos,
+          value: void 0
+        };
+      };
+    }
+    exports2.$E = $E;
+    function $Q(fn) {
+      return function(state) {
+        var input = state.input, pos = state.pos, tokenize = state.tokenize, verbose = state.verbose;
+        var value;
+        var s = pos;
+        var results = [];
+        while (true) {
+          var prevPos = pos;
+          var r = fn({ input, pos, tokenize, verbose });
+          if (r == void 0)
+            break;
+          pos = r.pos, value = r.value;
+          if (pos === prevPos)
+            break;
+          else
+            results.push(value);
+        }
+        return {
+          loc: {
+            pos: s,
+            length: pos - s
+          },
+          pos,
+          value: results
+        };
+      };
+    }
+    exports2.$Q = $Q;
+    function $P(fn) {
+      return function(state) {
+        var input = state.input, s = state.pos, tokenize = state.tokenize, verbose = state.verbose;
+        var value;
+        var first = fn(state);
+        if (!first)
+          return;
+        var pos = first.pos;
+        var results = [first.value];
+        while (true) {
+          var prevPos = pos;
+          var r = fn({ input, pos, tokenize, verbose });
+          if (!r)
+            break;
+          pos = r.pos, value = r.value;
+          if (pos === prevPos)
+            break;
+          results.push(value);
+        }
+        return {
+          loc: {
+            pos: s,
+            length: pos - s
+          },
+          value: results,
+          pos
+        };
+      };
+    }
+    exports2.$P = $P;
+    function $TEXT(fn) {
+      return function(state) {
+        var newState = fn(state);
+        if (!newState)
+          return;
+        newState.value = state.input.substring(state.pos, newState.pos);
+        return newState;
+      };
+    }
+    exports2.$TEXT = $TEXT;
+    function $TOKEN(name, state, newState) {
+      if (!newState)
+        return;
+      newState.value = {
+        type: name,
+        children: [].concat(newState.value),
+        token: state.input.substring(state.pos, newState.pos),
+        loc: newState.loc
+      };
+      return newState;
+    }
+    exports2.$TOKEN = $TOKEN;
+    function $N(fn) {
+      return function(state) {
+        var newState = fn(state);
+        if (newState)
+          return;
+        return {
+          loc: {
+            pos: state.pos,
+            length: 0
+          },
+          value: void 0,
+          pos: state.pos
+        };
+      };
+    }
+    exports2.$N = $N;
+    function $Y(fn) {
+      return function(state) {
+        var newState = fn(state);
+        if (!newState)
+          return;
+        return {
+          loc: {
+            pos: state.pos,
+            length: 0
+          },
+          value: void 0,
+          pos: state.pos
+        };
+      };
+    }
+    exports2.$Y = $Y;
+    function $T(parser, fn) {
+      return function(state) {
+        var result = parser(state);
+        if (!result)
+          return;
+        if (state.tokenize)
+          return result;
+        var value = result.value;
+        var mappedValue = fn(value);
+        result.value = mappedValue;
+        return result;
+      };
+    }
+    exports2.$T = $T;
+    function $TR(parser, fn) {
+      return function(state) {
+        var result = parser(state);
+        if (!result)
+          return;
+        if (state.tokenize)
+          return result;
+        var loc = result.loc, value = result.value;
+        var mappedValue = fn.apply(void 0, __spreadArray([SKIP, loc], value, false));
+        if (mappedValue === SKIP) {
+          return;
+        }
+        result.value = mappedValue;
+        return result;
+      };
+    }
+    exports2.$TR = $TR;
+    function $TS(parser, fn) {
+      return function(state) {
+        var result = parser(state);
+        if (!result)
+          return;
+        if (state.tokenize)
+          return result;
+        var loc = result.loc, value = result.value;
+        var mappedValue = fn.apply(void 0, __spreadArray([SKIP, loc, value], value, false));
+        if (mappedValue === SKIP) {
+          return;
+        }
+        result.value = mappedValue;
+        return result;
+      };
+    }
+    exports2.$TS = $TS;
+    function $TV(parser, fn) {
+      return function(state) {
+        var result = parser(state);
+        if (!result)
+          return;
+        if (state.tokenize)
+          return result;
+        var loc = result.loc, value = result.value;
+        var mappedValue = fn(SKIP, loc, value, value);
+        if (mappedValue === SKIP) {
+          return;
+        }
+        result.value = mappedValue;
+        return result;
+      };
+    }
+    exports2.$TV = $TV;
+    function $R$0(parser) {
+      return function(state) {
+        var result = parser(state);
+        if (!result)
+          return;
+        var value = result.value[0];
+        result.value = value;
+        return result;
+      };
+    }
+    exports2.$R$0 = $R$0;
+    var SKIP = {};
+    var failHintRegex = /\S+|\s+|$/y;
+    var failExpected = Array(16);
+    var failIndex = 0;
+    var maxFailPos = 0;
+    function fail(pos, expected) {
+      if (pos < maxFailPos)
+        return;
+      if (pos > maxFailPos) {
+        maxFailPos = pos;
+        failExpected.length = failIndex = 0;
+      }
+      failExpected[failIndex++] = expected;
+      return;
+    }
+    function parserState(grammar) {
+      function location(input, pos) {
+        var _a = input.split(/\n|\r\n|\r/).reduce(function(_a2, line2) {
+          var row = _a2[0], col = _a2[1];
+          var l = line2.length + 1;
+          if (pos > l) {
+            pos -= l;
+            return [row + 1, 1];
+          } else if (pos >= 0) {
+            col += pos;
+            pos = -1;
+            return [row, col];
+          } else {
+            return [row, col];
+          }
+        }, [1, 1]), line = _a[0], column = _a[1];
+        return "".concat(line, ":").concat(column);
+      }
+      function validate(input, result, _a) {
+        var filename = _a.filename;
+        if (result && result.pos === input.length)
+          return result.value;
+        var expectations = Array.from(new Set(failExpected.slice(0, failIndex)));
+        var l = location(input, maxFailPos);
+        if (result && result.pos > maxFailPos) {
+          l = location(input, result.pos);
+          throw new Error("\n".concat(filename, ":").concat(l, " Unconsumed input at #{l}\n\n").concat(input.slice(result.pos), "\n    "));
+        }
+        if (expectations.length) {
+          failHintRegex.lastIndex = maxFailPos;
+          var hint = input.match(failHintRegex)[0];
+          if (hint.length)
+            hint = JSON.stringify(hint);
+          else
+            hint = "EOF";
+          throw new Error("\n".concat(filename, ":").concat(l, " Failed to parse\nExpected:\n	").concat(expectations.join("\n	"), "\nFound: ").concat(hint, "\n"));
+        }
+        if (result) {
+          throw new Error("\nUnconsumed input at ".concat(l, "\n\n").concat(input.slice(result.pos), "\n"));
+        }
+        throw new Error("No result");
+      }
+      return {
+        parse: function(input, options) {
+          if (options === void 0) {
+            options = {};
+          }
+          if (typeof input !== "string")
+            throw new Error("Input must be a string");
+          var parser = options.startRule != null ? grammar[options.startRule] : Object.values(grammar)[0];
+          if (!parser)
+            throw new Error("Could not find rule with name '#{opts.startRule}'");
+          var filename = options.filename || "<anonymous>";
+          failIndex = 0;
+          maxFailPos = 0;
+          failExpected.length = 0;
+          return validate(input, parser({
+            input,
+            pos: 0,
+            tokenize: options.tokenize || false,
+            verbose: options.verbose || false
+          }), {
+            filename
+          });
+        }
+      };
+    }
+    exports2.parserState = parserState;
+    var { parse: parse2 } = parserState({
+      Program,
+      TopLevelStatement,
+      Expression,
+      Arguments,
+      ArgumentList,
+      CommaExpression,
+      BinaryOpExpression,
+      UnaryExpression,
+      UnaryPostfix,
+      UpdateExpression,
+      AssignmentExpression,
+      AssignmentExpressionRest,
+      YieldExpression,
+      ArrowFunction,
+      ConciseBody,
+      ConditionalExpression,
+      ShortCircuitExpression,
+      PrimaryExpression,
+      ClassDeclaration,
+      ClassExpression,
+      ClassHeritage,
+      ExtendsToken,
+      ClassBody,
+      NestedClassElements,
+      NestedClassElement,
+      ClassElement,
+      FieldDefinition,
+      This,
+      LeftHandSideExpression,
+      NewExpression,
+      CallExpression,
+      CallExpressionRest,
+      OptionalShorthand,
+      SpacedApplication,
+      ApplicationStart,
+      AdditionalReservedWords,
+      MemberExpression,
+      SuperProperty,
+      MetaProperty,
+      Parameters,
+      ParameterElement,
+      ParameterElementDelimiter,
+      BindingIdentifier,
+      BindingPattern,
+      ObjectBindingPattern,
+      ArrayBindingPattern,
+      BindingProperty,
+      BindingRestProperty,
+      BindingElement,
+      BindingRestElement,
+      FunctionDeclaration,
+      FunctionExpression,
+      ThinArrowFunction,
+      Block,
+      BracedBlock,
+      SingleNestedBlockExpression,
+      NestedBlockExpressions,
+      BlockExpression,
+      Literal,
+      Comma,
+      Identifier,
+      IdentifierName,
+      IdentifierReference,
+      ArrayLiteral,
+      NestedElementList,
+      NestedElement,
+      ArrayElementDelimiter,
+      ElementList,
+      ArrayElementExpression,
+      Elision,
+      ObjectLiteral,
+      NestedPropertyDefinitions,
+      NestedPropertyDefinition,
+      ObjectPropertyDelimiter,
+      PropertyDefinitionList,
+      PropertyDefinition,
+      PropertyName,
+      MethodDefinition,
+      ClassElementName,
+      PrivateIdentifier,
+      GeneratorDeclaration,
+      GeneratorExpression,
+      GeneratorMethod,
+      GeneratorBody,
+      AsyncFunctionDeclaration,
+      AsyncFunctionExpression,
+      AsyncMethod,
+      AsyncFunctionBody,
+      AsyncGeneratorDeclaration,
+      AsyncGeneratorExpression,
+      AsyncGeneratorMethod,
+      AsyncGeneratorBody,
+      AssignmentOp,
+      BinaryOp,
+      UnaryOp,
+      ModuleItem,
+      Statement,
+      EmptyStatement,
+      BlockStatement,
+      IfStatement,
+      IterationStatement,
+      LoopStatement,
+      DoWhileStatement,
+      WhileStatement,
+      ForStatement,
+      ForInOfStatement,
+      ForDeclaration,
+      ForBinding,
+      SwitchStatement,
+      CaseBlock,
+      NestedCaseClauses,
+      NestedCaseClause,
+      CaseClause,
+      When,
+      ImpliedColon,
+      TryStatement,
+      Catch,
+      CatchBind,
+      Finally,
+      CatchParameter,
+      Condition,
+      ExpressionStatement,
+      KeywordStatement,
+      ImportDeclaration,
+      ImportClause,
+      NameSpaceImport,
+      NamedImports,
+      FromClause,
+      ImportSpecifier,
+      ModuleExportName,
+      ModuleSpecifier,
+      ImportedBinding,
+      ExportDeclaration,
+      ExportFromClause,
+      NamedExports,
+      ExportSpecifier,
+      Declaration,
+      HoistableDeclaration,
+      LexicalDeclaration,
+      LexicalBinding,
+      Initializer,
+      VariableStatement,
+      VariableDeclarationList,
+      VariableDeclaration,
+      NumericLiteral,
+      DecimalBigIntegerLiteral,
+      DecimalLiteral,
+      BinaryIntegerLiteral,
+      OctalIntegerLiteral,
+      HexLiteral,
+      StringLiteral,
+      DoubleStringCharacter,
+      SingleStringCharacter,
+      TripleDoubleStringCharacter,
+      EscapeSequence,
+      RegularExpressionLiteral,
+      RegularExpressionBody,
+      RegExpCharacter,
+      RegularExpressionFlags,
+      TemplateLiteral,
+      TemplateSubstitution,
+      TemplateCharacters,
+      ReservedWord,
+      Comment,
+      SingleLineComment,
+      MultiLineComment,
+      JSMultiLineComment,
+      CoffeeSingleLineComment,
+      CoffeeMultiLineComment,
+      InlineComment,
+      RestOfLine,
+      TrailingComment,
+      _,
+      __,
+      StatementDelimiter,
+      TypeDeclaration,
+      InterfaceBlock,
+      NestedInterfaceProperties,
+      NestedInterfaceProperty,
+      TypeSuffix,
+      Type,
+      FunctionType,
+      TypeArguments,
+      Shebang,
+      DirectivePrologue,
+      EOS,
+      EOL,
+      EOF,
+      InsertOpenParen,
+      InsertCloseParen,
+      InsertOpenBrace,
+      InsertCloseBrace,
+      InsertNewline,
+      InsertIndent,
+      InsertSpace,
+      InsertDot,
+      InsertBreak,
+      Init,
+      Indent,
+      PushIndent,
+      PopIndent,
+      Nested
+    });
+    var $L0 = $L(",");
+    var $L1 = $L("(");
+    var $L2 = $L(")");
+    var $L3 = $L("?");
+    var $L4 = $L("++");
+    var $L5 = $L("--");
+    var $L6 = $L("async");
+    var $L7 = $L("yield");
+    var $L8 = $L("*");
+    var $L9 = $L("=>");
+    var $L10 = $L("{");
+    var $L11 = $L(":");
+    var $L12 = $L("class");
+    var $L13 = $L("<");
+    var $L14 = $L("extends");
+    var $L15 = $L("}");
+    var $L16 = $L("static");
+    var $L17 = $L("this");
+    var $L18 = $L("@");
+    var $L19 = $L("#");
+    var $L20 = $L("new");
+    var $L21 = $L("super");
+    var $L22 = $L("import");
+    var $L23 = $L("[");
+    var $L24 = $L("]");
+    var $L25 = $L(".");
+    var $L26 = $L("super[");
+    var $L27 = $L("new.target");
+    var $L28 = $L("import.meta");
+    var $L29 = $L("");
+    var $L30 = $L("...");
+    var $L31 = $L("function");
+    var $L32 = $L("->");
+    var $L33 = $L("true");
+    var $L34 = $L("false");
+    var $L35 = $L("null");
+    var $L36 = $L("undefined");
+    var $L37 = $L("get");
+    var $L38 = $L("set");
+    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("%");
+    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("is");
+    var $L69 = $L("===");
+    var $L70 = $L("==");
+    var $L71 = $L("and");
+    var $L72 = $L("&&");
+    var $L73 = $L("or");
+    var $L74 = $L("||");
+    var $L75 = $L("??");
+    var $L76 = $L("instanceof");
+    var $L77 = $L("in");
+    var $L78 = $L("&");
+    var $L79 = $L("^");
+    var $L80 = $L("|");
+    var $L81 = $L("delete");
+    var $L82 = $L("void");
+    var $L83 = $L("typeof");
+    var $L84 = $L(";");
+    var $L85 = $L("if");
+    var $L86 = $L("else");
+    var $L87 = $L("unless");
+    var $L88 = $L("loop");
+    var $L89 = $L("do");
+    var $L90 = $L("while");
+    var $L91 = $L("for");
+    var $L92 = $L("var");
+    var $L93 = $L("await");
+    var $L94 = $L("of");
+    var $L95 = $L("let");
+    var $L96 = $L("const");
+    var $L97 = $L("switch");
+    var $L98 = $L("case");
+    var $L99 = $L("default");
+    var $L100 = $L("when");
+    var $L101 = $L("try");
+    var $L102 = $L("catch");
+    var $L103 = $L("finally");
+    var $L104 = $L("break");
+    var $L105 = $L("continue");
+    var $L106 = $L("debugger");
+    var $L107 = $L("return");
+    var $L108 = $L("throw");
+    var $L109 = $L("import type");
+    var $L110 = $L("as");
+    var $L111 = $L("from");
+    var $L112 = $L("export");
+    var $L113 = $L('"""');
+    var $L114 = $L('"');
+    var $L115 = $L("'");
+    var $L116 = $L("\\");
+    var $L117 = $L("`");
+    var $L118 = $L("${");
+    var $L119 = $L("/*");
+    var $L120 = $L("*/");
+    var $L121 = $L("###");
+    var $L122 = $L("interface");
+    var $L123 = $L("[]");
+    var $L124 = $L("  ");
+    var $L125 = $L("	");
+    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("\\p{ID_Continue}", "suy"));
+    var $R3 = $R(new RegExp("[!~+-]", "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|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|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("#([^\\r\\n]*)", "suy"));
+    var $R20 = $R(new RegExp("[^\\r\\n]", "suy"));
+    var $R21 = $R(new RegExp("[\\t ]+", "suy"));
+    var $R22 = $R(new RegExp("[\\s]+", "suy"));
+    var $R23 = $R(new RegExp("#![^\\r\\n]*", "suy"));
+    var $R24 = $R(new RegExp("[\\t ]*", "suy"));
+    var $R25 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
+    var $R26 = $R(new RegExp("$", "suy"));
+    var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
+    function Program(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Program");
+      if (state.tokenize) {
+        return $TOKEN("Program", state, Program$0(state));
+      } else {
+        return Program$0(state);
+      }
+    }
+    var TopLevelStatement$0 = $S($E(EOS), $E(_), ModuleItem, StatementDelimiter);
+    function TopLevelStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TopLevelStatement");
+      if (state.tokenize) {
+        return $TOKEN("TopLevelStatement", state, TopLevelStatement$0(state));
+      } else {
+        return TopLevelStatement$0(state);
+      }
+    }
+    var Expression$0 = $S(AssignmentExpression, $Q($S(__, $EXPECT($L0, fail, 'Expression ","'), AssignmentExpression)));
+    function Expression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Expression");
+      if (state.tokenize) {
+        return $TOKEN("Expression", state, Expression$0(state));
+      } else {
+        return Expression$0(state);
+      }
+    }
+    var Arguments$0 = $S($EXPECT($L1, fail, 'Arguments "("'), $C(ArgumentList, __), $E($S($EXPECT($L0, fail, 'Arguments ","'), __)), $EXPECT($L2, fail, 'Arguments ")"'));
+    function Arguments(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Arguments");
+      if (state.tokenize) {
+        return $TOKEN("Arguments", state, Arguments$0(state));
+      } else {
+        return Arguments$0(state);
+      }
+    }
+    var ArgumentList$0 = $S(Expression, $Q(CommaExpression));
+    function ArgumentList(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ArgumentList");
+      if (state.tokenize) {
+        return $TOKEN("ArgumentList", state, ArgumentList$0(state));
+      } else {
+        return ArgumentList$0(state);
+      }
+    }
+    var CommaExpression$0 = $S(__, $EXPECT($L0, fail, 'CommaExpression ","'), __, Expression);
+    function CommaExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "CommaExpression");
+      if (state.tokenize) {
+        return $TOKEN("CommaExpression", state, CommaExpression$0(state));
+      } else {
+        return CommaExpression$0(state);
+      }
+    }
+    var BinaryOpExpression$0 = $S(UnaryExpression, $Q($S(__, BinaryOp, __, UnaryExpression)));
+    function BinaryOpExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "BinaryOpExpression");
+      if (state.tokenize) {
+        return $TOKEN("BinaryOpExpression", state, BinaryOpExpression$0(state));
+      } else {
+        return BinaryOpExpression$0(state);
+      }
+    }
+    var UnaryExpression$0 = $TS($S($Q(UnaryOp), UpdateExpression, $E(UnaryPostfix)), function($skip, $loc, $0, $1, $2, $3) {
+      var pre = $1;
+      var exp = $2;
+      var post = $3;
+      if (post) {
+        return ["(", pre, , "(", exp, ") != null)"];
+      }
+      return [pre, exp];
+    });
+    function UnaryExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "UnaryExpression");
+      if (state.tokenize) {
+        return $TOKEN("UnaryExpression", state, UnaryExpression$0(state));
+      } else {
+        return UnaryExpression$0(state);
+      }
+    }
+    var UnaryPostfix$0 = $EXPECT($L3, fail, 'UnaryPostfix "?"');
+    function UnaryPostfix(state) {
+      if (state.verbose)
+        console.log("ENTER:", "UnaryPostfix");
+      if (state.tokenize) {
+        return $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state));
+      } else {
+        return UnaryPostfix$0(state);
+      }
+    }
+    var UpdateExpression$0 = $S($C($EXPECT($L4, fail, 'UpdateExpression "++"'), $EXPECT($L5, fail, 'UpdateExpression "--"')), UnaryExpression);
+    var UpdateExpression$1 = $S(LeftHandSideExpression, $E($C($EXPECT($L4, fail, 'UpdateExpression "++"'), $EXPECT($L5, fail, 'UpdateExpression "--"'))));
+    function UpdateExpression(state) {
+      if (state.tokenize) {
+        return $TOKEN("UpdateExpression", state, UpdateExpression$0(state) || UpdateExpression$1(state));
+      } else {
+        return UpdateExpression$0(state) || UpdateExpression$1(state);
+      }
+    }
+    var AssignmentExpression$0 = $S($Q(TrailingComment), AssignmentExpressionRest);
+    var AssignmentExpression$1 = $S(__, AssignmentExpressionRest);
+    function AssignmentExpression(state) {
+      if (state.tokenize) {
+        return $TOKEN("AssignmentExpression", state, AssignmentExpression$0(state) || AssignmentExpression$1(state));
+      } else {
+        return AssignmentExpression$0(state) || AssignmentExpression$1(state);
+      }
+    }
+    var AssignmentExpressionRest$0 = YieldExpression;
+    var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L6, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
+    var AssignmentExpressionRest$2 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), $C($S($Q(_), Expression), $S(__, Expression)));
+    var AssignmentExpressionRest$3 = ConditionalExpression;
+    function AssignmentExpressionRest(state) {
+      if (state.tokenize) {
+        return $TOKEN("AssignmentExpressionRest", state, AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state));
+      } else {
+        return AssignmentExpressionRest$0(state) || AssignmentExpressionRest$1(state) || AssignmentExpressionRest$2(state) || AssignmentExpressionRest$3(state);
+      }
+    }
+    var YieldExpression$0 = $S($EXPECT($L7, fail, 'YieldExpression "yield"'), $E($S($Q(TrailingComment), $EXPECT($L8, fail, 'YieldExpression "*"'))), AssignmentExpression);
+    function YieldExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "YieldExpression");
+      if (state.tokenize) {
+        return $TOKEN("YieldExpression", state, YieldExpression$0(state));
+      } else {
+        return YieldExpression$0(state);
+      }
+    }
+    var ArrowFunction$0 = ThinArrowFunction;
+    var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), __, $EXPECT($L9, fail, 'ArrowFunction "=>"'), ConciseBody);
+    function ArrowFunction(state) {
+      if (state.tokenize) {
+        return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
+      } else {
+        return ArrowFunction$0(state) || ArrowFunction$1(state);
+      }
+    }
+    var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($L10, fail, 'ConciseBody "{"'))), AssignmentExpression);
+    var ConciseBody$1 = $S(EOS, SingleNestedBlockExpression);
+    var ConciseBody$2 = BracedBlock;
+    function ConciseBody(state) {
+      if (state.tokenize) {
+        return $TOKEN("ConciseBody", state, ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state));
+      } else {
+        return ConciseBody$0(state) || ConciseBody$1(state) || ConciseBody$2(state);
+      }
+    }
+    var ConditionalExpression$0 = $S(ShortCircuitExpression, $E($S(__, $EXPECT($L3, fail, 'ConditionalExpression "?"'), AssignmentExpression, __, $EXPECT($L11, fail, 'ConditionalExpression ":"'), AssignmentExpression)));
+    function ConditionalExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ConditionalExpression");
+      if (state.tokenize) {
+        return $TOKEN("ConditionalExpression", state, ConditionalExpression$0(state));
+      } else {
+        return ConditionalExpression$0(state);
+      }
+    }
+    var ShortCircuitExpression$0 = BinaryOpExpression;
+    function ShortCircuitExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ShortCircuitExpression");
+      if (state.tokenize) {
+        return $TOKEN("ShortCircuitExpression", state, ShortCircuitExpression$0(state));
+      } else {
+        return ShortCircuitExpression$0(state);
+      }
+    }
+    var PrimaryExpression$0 = This;
+    var PrimaryExpression$1 = IdentifierReference;
+    var PrimaryExpression$2 = Literal;
+    var PrimaryExpression$3 = ArrayLiteral;
+    var PrimaryExpression$4 = ObjectLiteral;
+    var PrimaryExpression$5 = FunctionExpression;
+    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 ")"'));
+    function PrimaryExpression(state) {
+      if (state.tokenize) {
+        return $TOKEN("PrimaryExpression", state, PrimaryExpression$0(state) || PrimaryExpression$1(state) || PrimaryExpression$2(state) || PrimaryExpression$3(state) || PrimaryExpression$4(state) || PrimaryExpression$5(state) || PrimaryExpression$6(state) || PrimaryExpression$7(state) || PrimaryExpression$8(state) || PrimaryExpression$9(state));
+      } else {
+        return PrimaryExpression$0(state) || PrimaryExpression$1(state) || PrimaryExpression$2(state) || PrimaryExpression$3(state) || PrimaryExpression$4(state) || PrimaryExpression$5(state) || PrimaryExpression$6(state) || PrimaryExpression$7(state) || PrimaryExpression$8(state) || PrimaryExpression$9(state);
+      }
+    }
+    var ClassDeclaration$0 = ClassExpression;
+    function ClassDeclaration(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ClassDeclaration");
+      if (state.tokenize) {
+        return $TOKEN("ClassDeclaration", state, ClassDeclaration$0(state));
+      } else {
+        return ClassDeclaration$0(state);
+      }
+    }
+    var ClassExpression$0 = $S($EXPECT($L12, fail, 'ClassExpression "class"'), $E($S(__, BindingIdentifier)), $E($S(__, ClassHeritage)), ClassBody);
+    function ClassExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ClassExpression");
+      if (state.tokenize) {
+        return $TOKEN("ClassExpression", state, ClassExpression$0(state));
+      } else {
+        return ClassExpression$0(state);
+      }
+    }
+    var ClassHeritage$0 = $S(ExtendsToken, __, $S(MemberExpression, $Q(CallExpressionRest)));
+    function ClassHeritage(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ClassHeritage");
+      if (state.tokenize) {
+        return $TOKEN("ClassHeritage", state, ClassHeritage$0(state));
+      } else {
+        return ClassHeritage$0(state);
+      }
+    }
+    var ExtendsToken$0 = $T($EXPECT($L13, fail, 'ExtendsToken "<"'), function(value) {
+      return "extends";
+    });
+    var ExtendsToken$1 = $EXPECT($L14, fail, 'ExtendsToken "extends"');
+    function ExtendsToken(state) {
+      if (state.tokenize) {
+        return $TOKEN("ExtendsToken", state, ExtendsToken$0(state) || ExtendsToken$1(state));
+      } else {
+        return ExtendsToken$0(state) || ExtendsToken$1(state);
+      }
+    }
+    var ClassBody$0 = $S(__, $EXPECT($L10, fail, 'ClassBody "{"'), $E($S(EOS, NestedClassElements)), __, $EXPECT($L15, fail, 'ClassBody "}"'));
+    var ClassBody$1 = $S(InsertOpenBrace, EOS, NestedClassElements, InsertNewline, InsertIndent, InsertCloseBrace);
+    function ClassBody(state) {
+      if (state.tokenize) {
+        return $TOKEN("ClassBody", state, ClassBody$0(state) || ClassBody$1(state));
+      } else {
+        return ClassBody$0(state) || ClassBody$1(state);
+      }
+    }
+    var NestedClassElements$0 = $TS($S(PushIndent, $Q(NestedClassElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var elements = $2;
+      if (!elements.length)
+        return $skip;
+      return elements;
+    });
+    function NestedClassElements(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedClassElements");
+      if (state.tokenize) {
+        return $TOKEN("NestedClassElements", state, NestedClassElements$0(state));
+      } else {
+        return NestedClassElements$0(state);
+      }
+    }
+    var NestedClassElement$0 = $S(Nested, ClassElement, StatementDelimiter);
+    function NestedClassElement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedClassElement");
+      if (state.tokenize) {
+        return $TOKEN("NestedClassElement", state, NestedClassElement$0(state));
+      } else {
+        return NestedClassElement$0(state);
+      }
+    }
+    var ClassElement$0 = $S($EXPECT($L16, fail, 'ClassElement "static"'), BracedBlock);
+    var ClassElement$1 = $S($E($S($EXPECT($L16, fail, 'ClassElement "static"'), __)), $C(MethodDefinition, FieldDefinition));
+    function ClassElement(state) {
+      if (state.tokenize) {
+        return $TOKEN("ClassElement", state, ClassElement$0(state) || ClassElement$1(state));
+      } else {
+        return ClassElement$0(state) || ClassElement$1(state);
+      }
+    }
+    var FieldDefinition$0 = $S(ClassElementName, $E(TypeSuffix), $E(Initializer));
+    function FieldDefinition(state) {
+      if (state.verbose)
+        console.log("ENTER:", "FieldDefinition");
+      if (state.tokenize) {
+        return $TOKEN("FieldDefinition", state, FieldDefinition$0(state));
+      } else {
+        return FieldDefinition$0(state);
+      }
+    }
+    var This$0 = $EXPECT($L17, fail, 'This "this"');
+    var This$1 = $T($S($EXPECT($L18, fail, 'This "@"'), $S($E($EXPECT($L19, fail, 'This "#"')), IdentifierName)), function(value) {
+      var ref = value[1];
+      return ["this.", ref];
+    });
+    var This$2 = $T($EXPECT($L18, fail, 'This "@"'), function(value) {
+      return "this";
+    });
+    function This(state) {
+      if (state.tokenize) {
+        return $TOKEN("This", state, This$0(state) || This$1(state) || This$2(state));
+      } else {
+        return This$0(state) || This$1(state) || This$2(state);
+      }
+    }
+    var LeftHandSideExpression$0 = NewExpression;
+    var LeftHandSideExpression$1 = CallExpression;
+    function LeftHandSideExpression(state) {
+      if (state.tokenize) {
+        return $TOKEN("LeftHandSideExpression", state, LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state));
+      } else {
+        return LeftHandSideExpression$0(state) || LeftHandSideExpression$1(state);
+      }
+    }
+    var NewExpression$0 = $S($P($S($EXPECT($L20, fail, 'NewExpression "new"'), __)), MemberExpression);
+    function NewExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NewExpression");
+      if (state.tokenize) {
+        return $TOKEN("NewExpression", state, NewExpression$0(state));
+      } else {
+        return NewExpression$0(state);
+      }
+    }
+    var CallExpression$0 = $S($EXPECT($L21, fail, 'CallExpression "super"'), __, Arguments);
+    var CallExpression$1 = $S($EXPECT($L22, fail, 'CallExpression "import"'), __, $EXPECT($L1, fail, 'CallExpression "("'), AssignmentExpression, __, $EXPECT($L2, fail, 'CallExpression ")"'));
+    var CallExpression$2 = $S(MemberExpression, $Q(CallExpressionRest), $E(SpacedApplication));
+    function CallExpression(state) {
+      if (state.tokenize) {
+        return $TOKEN("CallExpression", state, CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state));
+      } else {
+        return CallExpression$0(state) || CallExpression$1(state) || CallExpression$2(state);
+      }
+    }
+    var CallExpressionRest$0 = $S($E(OptionalShorthand), Arguments);
+    var CallExpressionRest$1 = $S($E(OptionalShorthand), $EXPECT($L23, fail, 'CallExpressionRest "["'), __, Expression, __, $EXPECT($L24, fail, 'CallExpressionRest "]"'));
+    var CallExpressionRest$2 = $S($E($EXPECT($L3, fail, 'CallExpressionRest "?"')), $EXPECT($L25, fail, 'CallExpressionRest "."'), $C(IdentifierName, PrivateIdentifier));
+    var CallExpressionRest$3 = TemplateLiteral;
+    function CallExpressionRest(state) {
+      if (state.tokenize) {
+        return $TOKEN("CallExpressionRest", state, CallExpressionRest$0(state) || CallExpressionRest$1(state) || CallExpressionRest$2(state) || CallExpressionRest$3(state));
+      } else {
+        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));
+    function OptionalShorthand(state) {
+      if (state.verbose)
+        console.log("ENTER:", "OptionalShorthand");
+      if (state.tokenize) {
+        return $TOKEN("OptionalShorthand", state, OptionalShorthand$0(state));
+      } else {
+        return OptionalShorthand$0(state);
+      }
+    }
+    var SpacedApplication$0 = $S(ApplicationStart, ArgumentList, InsertCloseParen);
+    function SpacedApplication(state) {
+      if (state.verbose)
+        console.log("ENTER:", "SpacedApplication");
+      if (state.tokenize) {
+        return $TOKEN("SpacedApplication", state, SpacedApplication$0(state));
+      } else {
+        return SpacedApplication$0(state);
+      }
+    }
+    var ApplicationStart$0 = $TS($S($E(OptionalShorthand), $TEXT($P(_)), $N(AdditionalReservedWords)), function($skip, $loc, $0, $1, $2, $3) {
+      var opt = $1;
+      var spacing = $2;
+      return [opt, "(", spacing.replace(/^ /, "")];
+    });
+    function ApplicationStart(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ApplicationStart");
+      if (state.tokenize) {
+        return $TOKEN("ApplicationStart", state, ApplicationStart$0(state));
+      } else {
+        return ApplicationStart$0(state);
+      }
+    }
+    var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of)(?!\\p{ID_Continue})/"));
+    function AdditionalReservedWords(state) {
+      if (state.verbose)
+        console.log("ENTER:", "AdditionalReservedWords");
+      if (state.tokenize) {
+        return $TOKEN("AdditionalReservedWords", state, AdditionalReservedWords$0(state));
+      } else {
+        return AdditionalReservedWords$0(state);
+      }
+    }
+    var MemberExpression$0 = $S(PrimaryExpression, $Q(CallExpressionRest));
+    var MemberExpression$1 = $S($Q(TrailingComment), SuperProperty);
+    var MemberExpression$2 = $S($Q(TrailingComment), MetaProperty);
+    function MemberExpression(state) {
+      if (state.tokenize) {
+        return $TOKEN("MemberExpression", state, MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state));
+      } else {
+        return MemberExpression$0(state) || MemberExpression$1(state) || MemberExpression$2(state);
+      }
+    }
+    var SuperProperty$0 = $S($EXPECT($L26, fail, 'SuperProperty "super["'), __, Expression, __, $EXPECT($L24, fail, 'SuperProperty "]"'));
+    function SuperProperty(state) {
+      if (state.verbose)
+        console.log("ENTER:", "SuperProperty");
+      if (state.tokenize) {
+        return $TOKEN("SuperProperty", state, SuperProperty$0(state));
+      } else {
+        return SuperProperty$0(state);
+      }
+    }
+    var MetaProperty$0 = $EXPECT($L27, fail, 'MetaProperty "new.target"');
+    var MetaProperty$1 = $EXPECT($L28, fail, 'MetaProperty "import.meta"');
+    function MetaProperty(state) {
+      if (state.tokenize) {
+        return $TOKEN("MetaProperty", state, MetaProperty$0(state) || MetaProperty$1(state));
+      } else {
+        return MetaProperty$0(state) || MetaProperty$1(state);
+      }
+    }
+    var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
+    var Parameters$1 = $T($EXPECT($L29, fail, 'Parameters ""'), function(value) {
+      return "()";
+    });
+    function Parameters(state) {
+      if (state.tokenize) {
+        return $TOKEN("Parameters", state, Parameters$0(state) || Parameters$1(state));
+      } else {
+        return Parameters$0(state) || Parameters$1(state);
+      }
+    }
+    var ParameterElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter);
+    function ParameterElement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ParameterElement");
+      if (state.tokenize) {
+        return $TOKEN("ParameterElement", state, ParameterElement$0(state));
+      } else {
+        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$3 = $T($Y(EOS), function(value) {
+      return ",";
+    });
+    function ParameterElementDelimiter(state) {
+      if (state.tokenize) {
+        return $TOKEN("ParameterElementDelimiter", state, ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state) || ParameterElementDelimiter$3(state));
+      } else {
+        return ParameterElementDelimiter$0(state) || ParameterElementDelimiter$1(state) || ParameterElementDelimiter$2(state) || ParameterElementDelimiter$3(state);
+      }
+    }
+    var BindingIdentifier$0 = Identifier;
+    function BindingIdentifier(state) {
+      if (state.verbose)
+        console.log("ENTER:", "BindingIdentifier");
+      if (state.tokenize) {
+        return $TOKEN("BindingIdentifier", state, BindingIdentifier$0(state));
+      } else {
+        return BindingIdentifier$0(state);
+      }
+    }
+    var BindingPattern$0 = ObjectBindingPattern;
+    var BindingPattern$1 = ArrayBindingPattern;
+    function BindingPattern(state) {
+      if (state.tokenize) {
+        return $TOKEN("BindingPattern", state, BindingPattern$0(state) || BindingPattern$1(state));
+      } else {
+        return BindingPattern$0(state) || BindingPattern$1(state);
+      }
+    }
+    var ObjectBindingPattern$0 = $S($EXPECT($L10, fail, 'ObjectBindingPattern "{"'), $Q(BindingProperty), $E($S(__, BindingRestProperty)), __, $EXPECT($L15, fail, 'ObjectBindingPattern "}"'));
+    function ObjectBindingPattern(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ObjectBindingPattern");
+      if (state.tokenize) {
+        return $TOKEN("ObjectBindingPattern", state, ObjectBindingPattern$0(state));
+      } else {
+        return ObjectBindingPattern$0(state);
+      }
+    }
+    var ArrayBindingPattern$0 = $S($EXPECT($L23, fail, 'ArrayBindingPattern "["'), $Q($C(BindingElement, Elision)), $E($S(__, BindingRestElement)), __, $EXPECT($L24, fail, 'ArrayBindingPattern "]"'));
+    function ArrayBindingPattern(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ArrayBindingPattern");
+      if (state.tokenize) {
+        return $TOKEN("ArrayBindingPattern", state, ArrayBindingPattern$0(state));
+      } else {
+        return ArrayBindingPattern$0(state);
+      }
+    }
+    var BindingProperty$0 = $S(__, PropertyName, __, $EXPECT($L11, fail, 'BindingProperty ":"'), __, $C(BindingIdentifier, BindingPattern), $E(Initializer), ObjectPropertyDelimiter);
+    var BindingProperty$1 = $S(__, BindingIdentifier, $E(Initializer), ObjectPropertyDelimiter);
+    function BindingProperty(state) {
+      if (state.tokenize) {
+        return $TOKEN("BindingProperty", state, BindingProperty$0(state) || BindingProperty$1(state));
+      } else {
+        return BindingProperty$0(state) || BindingProperty$1(state);
+      }
+    }
+    var BindingRestProperty$0 = $S($EXPECT($L30, fail, 'BindingRestProperty "..."'), __, BindingIdentifier);
+    function BindingRestProperty(state) {
+      if (state.verbose)
+        console.log("ENTER:", "BindingRestProperty");
+      if (state.tokenize) {
+        return $TOKEN("BindingRestProperty", state, BindingRestProperty$0(state));
+      } else {
+        return BindingRestProperty$0(state);
+      }
+    }
+    var BindingElement$0 = $S(__, $C(BindingIdentifier, BindingPattern), $E(Initializer), ArrayElementDelimiter);
+    function BindingElement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "BindingElement");
+      if (state.tokenize) {
+        return $TOKEN("BindingElement", state, BindingElement$0(state));
+      } else {
+        return BindingElement$0(state);
+      }
+    }
+    var BindingRestElement$0 = $S($EXPECT($L30, fail, 'BindingRestElement "..."'), __, $C(BindingIdentifier, BindingPattern));
+    function BindingRestElement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "BindingRestElement");
+      if (state.tokenize) {
+        return $TOKEN("BindingRestElement", state, BindingRestElement$0(state));
+      } else {
+        return BindingRestElement$0(state);
+      }
+    }
+    var FunctionDeclaration$0 = FunctionExpression;
+    function FunctionDeclaration(state) {
+      if (state.verbose)
+        console.log("ENTER:", "FunctionDeclaration");
+      if (state.tokenize) {
+        return $TOKEN("FunctionDeclaration", state, FunctionDeclaration$0(state));
+      } else {
+        return FunctionDeclaration$0(state);
+      }
+    }
+    var FunctionExpression$0 = ThinArrowFunction;
+    var FunctionExpression$1 = $S($EXPECT($L31, fail, 'FunctionExpression "function"'), __, Parameters, BracedBlock);
+    function FunctionExpression(state) {
+      if (state.tokenize) {
+        return $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
+      } else {
+        return FunctionExpression$0(state) || FunctionExpression$1(state);
+      }
+    }
+    var ThinArrowFunction$0 = $T($S(Parameters, $E(TypeSuffix), __, $EXPECT($L32, fail, 'ThinArrowFunction "->"'), BracedBlock), function(value) {
+      var params = value[0];
+      var suffix = value[1];
+      var block = value[4];
+      return ["function", params, suffix, block];
+    });
+    function ThinArrowFunction(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ThinArrowFunction");
+      if (state.tokenize) {
+        return $TOKEN("ThinArrowFunction", state, ThinArrowFunction$0(state));
+      } else {
+        return ThinArrowFunction$0(state);
+      }
+    }
+    var Block$0 = $S(__, $EXPECT($L10, fail, 'Block "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L15, fail, 'Block "}"'));
+    var Block$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
+    var Block$2 = Statement;
+    var Block$3 = $S(__, Statement);
+    function Block(state) {
+      if (state.tokenize) {
+        return $TOKEN("Block", state, Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state));
+      } else {
+        return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
+      }
+    }
+    var BracedBlock$0 = $S(__, $EXPECT($L10, fail, 'BracedBlock "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L15, fail, 'BracedBlock "}"'));
+    var BracedBlock$1 = $S(InsertOpenBrace, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseBrace);
+    var BracedBlock$2 = $S(InsertOpenBrace, $N(EOS), __, Statement, InsertSpace, InsertCloseBrace);
+    function BracedBlock(state) {
+      if (state.tokenize) {
+        return $TOKEN("BracedBlock", state, BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state));
+      } else {
+        return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
+      }
+    }
+    var SingleNestedBlockExpression$0 = $TS($S(PushIndent, $E($S(Nested, $C(Declaration, Statement))), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var exp = $2;
+      if (exp)
+        return exp;
+      return $skip;
+    });
+    function SingleNestedBlockExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "SingleNestedBlockExpression");
+      if (state.tokenize) {
+        return $TOKEN("SingleNestedBlockExpression", state, SingleNestedBlockExpression$0(state));
+      } else {
+        return SingleNestedBlockExpression$0(state);
+      }
+    }
+    var NestedBlockExpressions$0 = $TS($S(PushIndent, $Q(BlockExpression), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var exps = $2;
+      if (!exps.length)
+        return $skip;
+      return exps;
+    });
+    function NestedBlockExpressions(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedBlockExpressions");
+      if (state.tokenize) {
+        return $TOKEN("NestedBlockExpressions", state, NestedBlockExpressions$0(state));
+      } else {
+        return NestedBlockExpressions$0(state);
+      }
+    }
+    var BlockExpression$0 = $S(Nested, $C(Declaration, Statement), StatementDelimiter);
+    function BlockExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "BlockExpression");
+      if (state.tokenize) {
+        return $TOKEN("BlockExpression", state, BlockExpression$0(state));
+      } else {
+        return BlockExpression$0(state);
+      }
+    }
+    var Literal$0 = StringLiteral;
+    var Literal$1 = NumericLiteral;
+    var Literal$2 = $EXPECT($L33, fail, 'Literal "true"');
+    var Literal$3 = $EXPECT($L34, fail, 'Literal "false"');
+    var Literal$4 = $EXPECT($L35, fail, 'Literal "null"');
+    var Literal$5 = $EXPECT($L36, fail, 'Literal "undefined"');
+    function Literal(state) {
+      if (state.tokenize) {
+        return $TOKEN("Literal", state, Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state));
+      } else {
+        return Literal$0(state) || Literal$1(state) || Literal$2(state) || Literal$3(state) || Literal$4(state) || Literal$5(state);
+      }
+    }
+    var Comma$0 = $S($Q(_), $EXPECT($L0, fail, 'Comma ","'), $Q(_));
+    function Comma(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Comma");
+      if (state.tokenize) {
+        return $TOKEN("Comma", state, Comma$0(state));
+      } else {
+        return Comma$0(state);
+      }
+    }
+    var Identifier$0 = $S($N(ReservedWord), IdentifierName);
+    function Identifier(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Identifier");
+      if (state.tokenize) {
+        return $TOKEN("Identifier", state, Identifier$0(state));
+      } else {
+        return Identifier$0(state);
+      }
+    }
+    var IdentifierName$0 = $R$0($EXPECT($R1, fail, "IdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
+    function IdentifierName(state) {
+      if (state.verbose)
+        console.log("ENTER:", "IdentifierName");
+      if (state.tokenize) {
+        return $TOKEN("IdentifierName", state, IdentifierName$0(state));
+      } else {
+        return IdentifierName$0(state);
+      }
+    }
+    var IdentifierReference$0 = Identifier;
+    function IdentifierReference(state) {
+      if (state.verbose)
+        console.log("ENTER:", "IdentifierReference");
+      if (state.tokenize) {
+        return $TOKEN("IdentifierReference", state, IdentifierReference$0(state));
+      } else {
+        return IdentifierReference$0(state);
+      }
+    }
+    var ArrayLiteral$0 = $S($EXPECT($L23, fail, 'ArrayLiteral "["'), NestedElementList, __, $EXPECT($L24, fail, 'ArrayLiteral "]"'));
+    var ArrayLiteral$1 = $S($EXPECT($L23, fail, 'ArrayLiteral "["'), ElementList, __, $EXPECT($L24, fail, 'ArrayLiteral "]"'));
+    function ArrayLiteral(state) {
+      if (state.tokenize) {
+        return $TOKEN("ArrayLiteral", state, ArrayLiteral$0(state) || ArrayLiteral$1(state));
+      } else {
+        return ArrayLiteral$0(state) || ArrayLiteral$1(state);
+      }
+    }
+    var NestedElementList$0 = $TS($S(PushIndent, $Q(NestedElement), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var elements = $2;
+      if (elements.length)
+        return elements;
+      return $skip;
+    });
+    function NestedElementList(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedElementList");
+      if (state.tokenize) {
+        return $TOKEN("NestedElementList", state, NestedElementList$0(state));
+      } else {
+        return NestedElementList$0(state);
+      }
+    }
+    var NestedElement$0 = $S(Nested, ArrayElementExpression, ArrayElementDelimiter);
+    function NestedElement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedElement");
+      if (state.tokenize) {
+        return $TOKEN("NestedElement", state, NestedElement$0(state));
+      } else {
+        return NestedElement$0(state);
+      }
+    }
+    var ArrayElementDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ArrayElementDelimiter ","'));
+    var ArrayElementDelimiter$1 = $Y($S($Q(_), $EXPECT($L24, fail, 'ArrayElementDelimiter "]"')));
+    var ArrayElementDelimiter$2 = $T($Y($S(__, $EXPECT($L24, fail, 'ArrayElementDelimiter "]"'))), function(value) {
+      return ",";
+    });
+    var ArrayElementDelimiter$3 = $T($Y(EOS), function(value) {
+      return ",";
+    });
+    function ArrayElementDelimiter(state) {
+      if (state.tokenize) {
+        return $TOKEN("ArrayElementDelimiter", state, ArrayElementDelimiter$0(state) || ArrayElementDelimiter$1(state) || ArrayElementDelimiter$2(state) || ArrayElementDelimiter$3(state));
+      } else {
+        return ArrayElementDelimiter$0(state) || ArrayElementDelimiter$1(state) || ArrayElementDelimiter$2(state) || ArrayElementDelimiter$3(state);
+      }
+    }
+    var ElementList$0 = $S(ArrayElementExpression, $Q($S(__, $EXPECT($L0, fail, 'ElementList ","'), __, ArrayElementExpression)));
+    function ElementList(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ElementList");
+      if (state.tokenize) {
+        return $TOKEN("ElementList", state, ElementList$0(state));
+      } else {
+        return ElementList$0(state);
+      }
+    }
+    var ArrayElementExpression$0 = $E($S($E($S($EXPECT($L30, fail, 'ArrayElementExpression "..."'), __)), AssignmentExpression));
+    function ArrayElementExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ArrayElementExpression");
+      if (state.tokenize) {
+        return $TOKEN("ArrayElementExpression", state, ArrayElementExpression$0(state));
+      } else {
+        return ArrayElementExpression$0(state);
+      }
+    }
+    var Elision$0 = $S(__, $EXPECT($L0, fail, 'Elision ","'));
+    function Elision(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Elision");
+      if (state.tokenize) {
+        return $TOKEN("Elision", state, Elision$0(state));
+      } else {
+        return Elision$0(state);
+      }
+    }
+    var ObjectLiteral$0 = $S($EXPECT($L10, fail, 'ObjectLiteral "{"'), $Y(EOS), NestedPropertyDefinitions, __, $EXPECT($L15, fail, 'ObjectLiteral "}"'));
+    var ObjectLiteral$1 = $S($EXPECT($L10, fail, 'ObjectLiteral "{"'), __, PropertyDefinitionList, __, $E($S($EXPECT($L0, fail, 'ObjectLiteral ","'), __)), $EXPECT($L15, fail, 'ObjectLiteral "}"'));
+    var ObjectLiteral$2 = $S($EXPECT($L10, fail, 'ObjectLiteral "{"'), __, $EXPECT($L15, fail, 'ObjectLiteral "}"'));
+    var ObjectLiteral$3 = $S(InsertOpenBrace, $Y(EOS), NestedPropertyDefinitions, InsertNewline, InsertIndent, InsertCloseBrace);
+    function ObjectLiteral(state) {
+      if (state.tokenize) {
+        return $TOKEN("ObjectLiteral", state, ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state) || ObjectLiteral$3(state));
+      } else {
+        return ObjectLiteral$0(state) || ObjectLiteral$1(state) || ObjectLiteral$2(state) || ObjectLiteral$3(state);
+      }
+    }
+    var NestedPropertyDefinitions$0 = $TS($S(PushIndent, $Q(NestedPropertyDefinition), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var defs = $2;
+      if (!defs.length)
+        return $skip;
+      return defs;
+    });
+    function NestedPropertyDefinitions(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedPropertyDefinitions");
+      if (state.tokenize) {
+        return $TOKEN("NestedPropertyDefinitions", state, NestedPropertyDefinitions$0(state));
+      } else {
+        return NestedPropertyDefinitions$0(state);
+      }
+    }
+    var NestedPropertyDefinition$0 = $S(Nested, PropertyDefinition, ObjectPropertyDelimiter);
+    function NestedPropertyDefinition(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedPropertyDefinition");
+      if (state.tokenize) {
+        return $TOKEN("NestedPropertyDefinition", state, NestedPropertyDefinition$0(state));
+      } else {
+        return NestedPropertyDefinition$0(state);
+      }
+    }
+    var ObjectPropertyDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'ObjectPropertyDelimiter ","'));
+    var ObjectPropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L15, fail, 'ObjectPropertyDelimiter "}"')));
+    var ObjectPropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L15, fail, 'ObjectPropertyDelimiter "}"'))), function(value) {
+      return ",";
+    });
+    var ObjectPropertyDelimiter$3 = $T($Y(EOS), function(value) {
+      return ",";
+    });
+    function ObjectPropertyDelimiter(state) {
+      if (state.tokenize) {
+        return $TOKEN("ObjectPropertyDelimiter", state, ObjectPropertyDelimiter$0(state) || ObjectPropertyDelimiter$1(state) || ObjectPropertyDelimiter$2(state) || ObjectPropertyDelimiter$3(state));
+      } else {
+        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)));
+    function PropertyDefinitionList(state) {
+      if (state.verbose)
+        console.log("ENTER:", "PropertyDefinitionList");
+      if (state.tokenize) {
+        return $TOKEN("PropertyDefinitionList", state, PropertyDefinitionList$0(state));
+      } else {
+        return PropertyDefinitionList$0(state);
+      }
+    }
+    var PropertyDefinition$0 = $S(PropertyName, __, $EXPECT($L11, fail, 'PropertyDefinition ":"'), AssignmentExpression);
+    var PropertyDefinition$1 = MethodDefinition;
+    var PropertyDefinition$2 = $S($EXPECT($L30, fail, 'PropertyDefinition "..."'), AssignmentExpression);
+    var PropertyDefinition$3 = IdentifierReference;
+    function PropertyDefinition(state) {
+      if (state.tokenize) {
+        return $TOKEN("PropertyDefinition", state, PropertyDefinition$0(state) || PropertyDefinition$1(state) || PropertyDefinition$2(state) || PropertyDefinition$3(state));
+      } else {
+        return PropertyDefinition$0(state) || PropertyDefinition$1(state) || PropertyDefinition$2(state) || PropertyDefinition$3(state);
+      }
+    }
+    var PropertyName$0 = NumericLiteral;
+    var PropertyName$1 = StringLiteral;
+    var PropertyName$2 = IdentifierName;
+    var PropertyName$3 = $S($EXPECT($L23, fail, 'PropertyName "["'), 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));
+      } else {
+        return PropertyName$0(state) || PropertyName$1(state) || PropertyName$2(state) || PropertyName$3(state);
+      }
+    }
+    var MethodDefinition$0 = $S($EXPECT($L37, fail, 'MethodDefinition "get"'), $N($R$0($EXPECT($R2, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
+    var MethodDefinition$1 = $S($EXPECT($L38, fail, 'MethodDefinition "set"'), $N($R$0($EXPECT($R2, fail, "MethodDefinition /\\p{ID_Continue}/"))), $Q(TrailingComment), ClassElementName, __, Parameters, BracedBlock);
+    var MethodDefinition$2 = AsyncGeneratorMethod;
+    var MethodDefinition$3 = AsyncMethod;
+    var MethodDefinition$4 = GeneratorMethod;
+    var MethodDefinition$5 = $S(ClassElementName, $Q(_), Parameters, BracedBlock);
+    function MethodDefinition(state) {
+      if (state.tokenize) {
+        return $TOKEN("MethodDefinition", state, MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state));
+      } else {
+        return MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state);
+      }
+    }
+    var ClassElementName$0 = PropertyName;
+    var ClassElementName$1 = PrivateIdentifier;
+    function ClassElementName(state) {
+      if (state.tokenize) {
+        return $TOKEN("ClassElementName", state, ClassElementName$0(state) || ClassElementName$1(state));
+      } else {
+        return ClassElementName$0(state) || ClassElementName$1(state);
+      }
+    }
+    var PrivateIdentifier$0 = $S($EXPECT($L19, fail, 'PrivateIdentifier "#"'), IdentifierName);
+    function PrivateIdentifier(state) {
+      if (state.verbose)
+        console.log("ENTER:", "PrivateIdentifier");
+      if (state.tokenize) {
+        return $TOKEN("PrivateIdentifier", state, PrivateIdentifier$0(state));
+      } else {
+        return PrivateIdentifier$0(state);
+      }
+    }
+    var GeneratorDeclaration$0 = GeneratorExpression;
+    function GeneratorDeclaration(state) {
+      if (state.verbose)
+        console.log("ENTER:", "GeneratorDeclaration");
+      if (state.tokenize) {
+        return $TOKEN("GeneratorDeclaration", state, GeneratorDeclaration$0(state));
+      } else {
+        return GeneratorDeclaration$0(state);
+      }
+    }
+    var GeneratorExpression$0 = $S($EXPECT($L31, fail, 'GeneratorExpression "function"'), __, $EXPECT($L8, fail, 'GeneratorExpression "*"'), $E($S(__, BindingIdentifier)), Parameters, GeneratorBody);
+    function GeneratorExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "GeneratorExpression");
+      if (state.tokenize) {
+        return $TOKEN("GeneratorExpression", state, GeneratorExpression$0(state));
+      } else {
+        return GeneratorExpression$0(state);
+      }
+    }
+    var GeneratorMethod$0 = $S($EXPECT($L8, fail, 'GeneratorMethod "*"'), __, ClassElementName, __, Parameters, GeneratorBody);
+    function GeneratorMethod(state) {
+      if (state.verbose)
+        console.log("ENTER:", "GeneratorMethod");
+      if (state.tokenize) {
+        return $TOKEN("GeneratorMethod", state, GeneratorMethod$0(state));
+      } else {
+        return GeneratorMethod$0(state);
+      }
+    }
+    var GeneratorBody$0 = BracedBlock;
+    function GeneratorBody(state) {
+      if (state.verbose)
+        console.log("ENTER:", "GeneratorBody");
+      if (state.tokenize) {
+        return $TOKEN("GeneratorBody", state, GeneratorBody$0(state));
+      } else {
+        return GeneratorBody$0(state);
+      }
+    }
+    var AsyncFunctionDeclaration$0 = AsyncFunctionExpression;
+    function AsyncFunctionDeclaration(state) {
+      if (state.verbose)
+        console.log("ENTER:", "AsyncFunctionDeclaration");
+      if (state.tokenize) {
+        return $TOKEN("AsyncFunctionDeclaration", state, AsyncFunctionDeclaration$0(state));
+      } else {
+        return AsyncFunctionDeclaration$0(state);
+      }
+    }
+    var AsyncFunctionExpression$0 = $S($EXPECT($L6, fail, 'AsyncFunctionExpression "async"'), $N(EOS), __, $EXPECT($L31, fail, 'AsyncFunctionExpression "function"'), $E($S(__, BindingIdentifier)), __, Parameters, AsyncFunctionBody);
+    function AsyncFunctionExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "AsyncFunctionExpression");
+      if (state.tokenize) {
+        return $TOKEN("AsyncFunctionExpression", state, AsyncFunctionExpression$0(state));
+      } else {
+        return AsyncFunctionExpression$0(state);
+      }
+    }
+    var AsyncMethod$0 = $S($EXPECT($L6, fail, 'AsyncMethod "async"'), $N(EOS), __, ClassElementName, __, Parameters, AsyncFunctionBody);
+    function AsyncMethod(state) {
+      if (state.verbose)
+        console.log("ENTER:", "AsyncMethod");
+      if (state.tokenize) {
+        return $TOKEN("AsyncMethod", state, AsyncMethod$0(state));
+      } else {
+        return AsyncMethod$0(state);
+      }
+    }
+    var AsyncFunctionBody$0 = BracedBlock;
+    function AsyncFunctionBody(state) {
+      if (state.verbose)
+        console.log("ENTER:", "AsyncFunctionBody");
+      if (state.tokenize) {
+        return $TOKEN("AsyncFunctionBody", state, AsyncFunctionBody$0(state));
+      } else {
+        return AsyncFunctionBody$0(state);
+      }
+    }
+    var AsyncGeneratorDeclaration$0 = AsyncGeneratorExpression;
+    function AsyncGeneratorDeclaration(state) {
+      if (state.verbose)
+        console.log("ENTER:", "AsyncGeneratorDeclaration");
+      if (state.tokenize) {
+        return $TOKEN("AsyncGeneratorDeclaration", state, AsyncGeneratorDeclaration$0(state));
+      } else {
+        return AsyncGeneratorDeclaration$0(state);
+      }
+    }
+    var AsyncGeneratorExpression$0 = $S($EXPECT($L6, fail, 'AsyncGeneratorExpression "async"'), $N(EOS), __, $EXPECT($L31, fail, 'AsyncGeneratorExpression "function"'), __, $EXPECT($L8, fail, 'AsyncGeneratorExpression "*"'), $E($S(__, BindingIdentifier)), __, Parameters, AsyncGeneratorBody);
+    function AsyncGeneratorExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "AsyncGeneratorExpression");
+      if (state.tokenize) {
+        return $TOKEN("AsyncGeneratorExpression", state, AsyncGeneratorExpression$0(state));
+      } else {
+        return AsyncGeneratorExpression$0(state);
+      }
+    }
+    var AsyncGeneratorMethod$0 = $S($EXPECT($L6, fail, 'AsyncGeneratorMethod "async"'), $N(EOS), __, $EXPECT($L8, fail, 'AsyncGeneratorMethod "*"'), __, ClassElementName, __, Parameters, AsyncGeneratorBody);
+    function AsyncGeneratorMethod(state) {
+      if (state.verbose)
+        console.log("ENTER:", "AsyncGeneratorMethod");
+      if (state.tokenize) {
+        return $TOKEN("AsyncGeneratorMethod", state, AsyncGeneratorMethod$0(state));
+      } else {
+        return AsyncGeneratorMethod$0(state);
+      }
+    }
+    var AsyncGeneratorBody$0 = BracedBlock;
+    function AsyncGeneratorBody(state) {
+      if (state.verbose)
+        console.log("ENTER:", "AsyncGeneratorBody");
+      if (state.tokenize) {
+        return $TOKEN("AsyncGeneratorBody", state, AsyncGeneratorBody$0(state));
+      } else {
+        return AsyncGeneratorBody$0(state);
+      }
+    }
+    var AssignmentOp$0 = $EXPECT($L39, fail, 'AssignmentOp "**="');
+    var AssignmentOp$1 = $EXPECT($L40, fail, 'AssignmentOp "*="');
+    var AssignmentOp$2 = $EXPECT($L41, fail, 'AssignmentOp "/="');
+    var AssignmentOp$3 = $EXPECT($L42, fail, 'AssignmentOp "%="');
+    var AssignmentOp$4 = $EXPECT($L43, fail, 'AssignmentOp "+="');
+    var AssignmentOp$5 = $EXPECT($L44, fail, 'AssignmentOp "-="');
+    var AssignmentOp$6 = $EXPECT($L45, fail, 'AssignmentOp "<<="');
+    var AssignmentOp$7 = $EXPECT($L46, fail, 'AssignmentOp ">>>="');
+    var AssignmentOp$8 = $EXPECT($L47, fail, 'AssignmentOp ">>="');
+    var AssignmentOp$9 = $EXPECT($L48, fail, 'AssignmentOp "&&="');
+    var AssignmentOp$10 = $EXPECT($L49, fail, 'AssignmentOp "&="');
+    var AssignmentOp$11 = $EXPECT($L50, fail, 'AssignmentOp "^="');
+    var AssignmentOp$12 = $EXPECT($L51, fail, 'AssignmentOp "||="');
+    var AssignmentOp$13 = $EXPECT($L52, fail, 'AssignmentOp "|="');
+    var AssignmentOp$14 = $EXPECT($L53, fail, 'AssignmentOp "??="');
+    var AssignmentOp$15 = $EXPECT($L54, fail, 'AssignmentOp "="');
+    function AssignmentOp(state) {
+      if (state.tokenize) {
+        return $TOKEN("AssignmentOp", state, AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state));
+      } else {
+        return AssignmentOp$0(state) || AssignmentOp$1(state) || AssignmentOp$2(state) || AssignmentOp$3(state) || AssignmentOp$4(state) || AssignmentOp$5(state) || AssignmentOp$6(state) || AssignmentOp$7(state) || AssignmentOp$8(state) || AssignmentOp$9(state) || AssignmentOp$10(state) || AssignmentOp$11(state) || AssignmentOp$12(state) || AssignmentOp$13(state) || AssignmentOp$14(state) || AssignmentOp$15(state);
+      }
+    }
+    var BinaryOp$0 = $EXPECT($L55, fail, 'BinaryOp "**"');
+    var BinaryOp$1 = $EXPECT($L8, fail, 'BinaryOp "*"');
+    var BinaryOp$2 = $EXPECT($L56, fail, 'BinaryOp "/"');
+    var BinaryOp$3 = $EXPECT($L57, fail, 'BinaryOp "%"');
+    var BinaryOp$4 = $EXPECT($L58, fail, 'BinaryOp "+"');
+    var BinaryOp$5 = $EXPECT($L59, fail, 'BinaryOp "-"');
+    var BinaryOp$6 = $EXPECT($L60, fail, 'BinaryOp "<="');
+    var BinaryOp$7 = $EXPECT($L61, fail, 'BinaryOp ">="');
+    var BinaryOp$8 = $EXPECT($L62, fail, 'BinaryOp "<<"');
+    var BinaryOp$9 = $EXPECT($L13, fail, 'BinaryOp "<"');
+    var BinaryOp$10 = $EXPECT($L63, fail, 'BinaryOp ">>>"');
+    var BinaryOp$11 = $EXPECT($L64, fail, 'BinaryOp ">>"');
+    var BinaryOp$12 = $EXPECT($L65, fail, 'BinaryOp ">"');
+    var BinaryOp$13 = $EXPECT($L66, fail, 'BinaryOp "!=="');
+    var BinaryOp$14 = $TV($EXPECT($L67, fail, 'BinaryOp "!="'), function($skip, $loc, $0, $1) {
+      if (global.coffeeCompat)
+        return "!==";
+      return $1;
+    });
+    var BinaryOp$15 = $T($EXPECT($L68, fail, 'BinaryOp "is"'), function(value) {
+      return "===";
+    });
+    var BinaryOp$16 = $EXPECT($L69, fail, 'BinaryOp "==="');
+    var BinaryOp$17 = $TV($EXPECT($L70, fail, 'BinaryOp "=="'), function($skip, $loc, $0, $1) {
+      if (global.coffeeCompat)
+        return "===";
+      return $1;
+    });
+    var BinaryOp$18 = $T($EXPECT($L71, fail, 'BinaryOp "and"'), function(value) {
+      return "&&";
+    });
+    var BinaryOp$19 = $EXPECT($L72, fail, 'BinaryOp "&&"');
+    var BinaryOp$20 = $T($EXPECT($L73, fail, 'BinaryOp "or"'), function(value) {
+      return "||";
+    });
+    var BinaryOp$21 = $EXPECT($L74, fail, 'BinaryOp "||"');
+    var BinaryOp$22 = $EXPECT($L75, fail, 'BinaryOp "??"');
+    var BinaryOp$23 = $EXPECT($L76, fail, 'BinaryOp "instanceof"');
+    var BinaryOp$24 = $EXPECT($L77, fail, 'BinaryOp "in"');
+    var BinaryOp$25 = $EXPECT($L78, fail, 'BinaryOp "&"');
+    var BinaryOp$26 = $EXPECT($L79, fail, 'BinaryOp "^"');
+    var BinaryOp$27 = $EXPECT($L80, fail, 'BinaryOp "|"');
+    function BinaryOp(state) {
+      if (state.tokenize) {
+        return $TOKEN("BinaryOp", state, BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state));
+      } else {
+        return BinaryOp$0(state) || BinaryOp$1(state) || BinaryOp$2(state) || BinaryOp$3(state) || BinaryOp$4(state) || BinaryOp$5(state) || BinaryOp$6(state) || BinaryOp$7(state) || BinaryOp$8(state) || BinaryOp$9(state) || BinaryOp$10(state) || BinaryOp$11(state) || BinaryOp$12(state) || BinaryOp$13(state) || BinaryOp$14(state) || BinaryOp$15(state) || BinaryOp$16(state) || BinaryOp$17(state) || BinaryOp$18(state) || BinaryOp$19(state) || BinaryOp$20(state) || BinaryOp$21(state) || BinaryOp$22(state) || BinaryOp$23(state) || BinaryOp$24(state) || BinaryOp$25(state) || BinaryOp$26(state) || BinaryOp$27(state);
+      }
+    }
+    var UnaryOp$0 = $R$0($EXPECT($R3, fail, "UnaryOp /[!~+-]/"));
+    var UnaryOp$1 = $S($C($EXPECT($L81, fail, 'UnaryOp "delete"'), $EXPECT($L82, fail, 'UnaryOp "void"'), $EXPECT($L83, fail, 'UnaryOp "typeof"')), $P(_));
+    function UnaryOp(state) {
+      if (state.tokenize) {
+        return $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state));
+      } else {
+        return UnaryOp$0(state) || UnaryOp$1(state);
+      }
+    }
+    var ModuleItem$0 = ImportDeclaration;
+    var ModuleItem$1 = ExportDeclaration;
+    var ModuleItem$2 = Declaration;
+    var ModuleItem$3 = Statement;
+    function ModuleItem(state) {
+      if (state.tokenize) {
+        return $TOKEN("ModuleItem", state, ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state) || ModuleItem$3(state));
+      } else {
+        return ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state) || ModuleItem$3(state);
+      }
+    }
+    var Statement$0 = KeywordStatement;
+    var Statement$1 = BlockStatement;
+    var Statement$2 = VariableStatement;
+    var Statement$3 = IfStatement;
+    var Statement$4 = IterationStatement;
+    var Statement$5 = SwitchStatement;
+    var Statement$6 = TryStatement;
+    var Statement$7 = EmptyStatement;
+    var Statement$8 = ExpressionStatement;
+    function Statement(state) {
+      if (state.tokenize) {
+        return $TOKEN("Statement", state, 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));
+      } else {
+        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($L84, fail, 'EmptyStatement ";"')));
+    function EmptyStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "EmptyStatement");
+      if (state.tokenize) {
+        return $TOKEN("EmptyStatement", state, EmptyStatement$0(state));
+      } else {
+        return EmptyStatement$0(state);
+      }
+    }
+    var BlockStatement$0 = $S(__, $EXPECT($L10, fail, 'BlockStatement "{"'), EOS, NestedBlockExpressions, __, $EXPECT($L15, fail, 'BlockStatement "}"'));
+    function BlockStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "BlockStatement");
+      if (state.tokenize) {
+        return $TOKEN("BlockStatement", state, BlockStatement$0(state));
+      } else {
+        return BlockStatement$0(state);
+      }
+    }
+    var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L86, fail, 'IfStatement "else"'), Block)));
+    var IfStatement$1 = $TS($S($EXPECT($L87, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
+      var condition = $2;
+      var block = $3;
+      return ["if", condition.map((c) => {
+        if (c === "(")
+          return "(!(";
+        if (c === ")")
+          return "))";
+        return c;
+      }), block];
+    });
+    function IfStatement(state) {
+      if (state.tokenize) {
+        return $TOKEN("IfStatement", state, IfStatement$0(state) || IfStatement$1(state));
+      } else {
+        return IfStatement$0(state) || IfStatement$1(state);
+      }
+    }
+    var IterationStatement$0 = LoopStatement;
+    var IterationStatement$1 = DoWhileStatement;
+    var IterationStatement$2 = WhileStatement;
+    var IterationStatement$3 = ForStatement;
+    var IterationStatement$4 = ForInOfStatement;
+    function IterationStatement(state) {
+      if (state.tokenize) {
+        return $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state));
+      } else {
+        return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
+      }
+    }
+    var LoopStatement$0 = $TS($S($EXPECT($L88, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
+      var b = $2;
+      return ["while(true)", b];
+    });
+    function LoopStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "LoopStatement");
+      if (state.tokenize) {
+        return $TOKEN("LoopStatement", state, LoopStatement$0(state));
+      } else {
+        return LoopStatement$0(state);
+      }
+    }
+    var DoWhileStatement$0 = $S($EXPECT($L89, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L90, fail, 'DoWhileStatement "while"'), Condition);
+    function DoWhileStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "DoWhileStatement");
+      if (state.tokenize) {
+        return $TOKEN("DoWhileStatement", state, DoWhileStatement$0(state));
+      } else {
+        return DoWhileStatement$0(state);
+      }
+    }
+    var WhileStatement$0 = $S($EXPECT($L90, fail, 'WhileStatement "while"'), Condition, Block);
+    function WhileStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "WhileStatement");
+      if (state.tokenize) {
+        return $TOKEN("WhileStatement", state, WhileStatement$0(state));
+      } else {
+        return WhileStatement$0(state);
+      }
+    }
+    var ForStatement$0 = $S($EXPECT($L91, fail, 'ForStatement "for"'), __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L84, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L84, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
+    function ForStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ForStatement");
+      if (state.tokenize) {
+        return $TOKEN("ForStatement", state, ForStatement$0(state));
+      } else {
+        return ForStatement$0(state);
+      }
+    }
+    var ForInOfStatement$0 = $S($EXPECT($L91, fail, 'ForInOfStatement "for"'), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L92, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L77, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
+    var ForInOfStatement$1 = $S($EXPECT($L91, fail, 'ForInOfStatement "for"'), __, InsertOpenParen, $C($S($EXPECT($L92, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L77, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
+    var ForInOfStatement$2 = $S($EXPECT($L91, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L93, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L92, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L94, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
+    var ForInOfStatement$3 = $S($EXPECT($L91, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L93, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L92, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L94, fail, 'ForInOfStatement "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));
+      } else {
+        return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
+      }
+    }
+    var ForDeclaration$0 = $S($C($EXPECT($L95, fail, 'ForDeclaration "let"'), $EXPECT($L96, fail, 'ForDeclaration "const"')), __, ForBinding);
+    function ForDeclaration(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ForDeclaration");
+      if (state.tokenize) {
+        return $TOKEN("ForDeclaration", state, ForDeclaration$0(state));
+      } else {
+        return ForDeclaration$0(state);
+      }
+    }
+    var ForBinding$0 = BindingIdentifier;
+    var ForBinding$1 = BindingPattern;
+    function ForBinding(state) {
+      if (state.tokenize) {
+        return $TOKEN("ForBinding", state, ForBinding$0(state) || ForBinding$1(state));
+      } else {
+        return ForBinding$0(state) || ForBinding$1(state);
+      }
+    }
+    var SwitchStatement$0 = $S($EXPECT($L97, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
+    function SwitchStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "SwitchStatement");
+      if (state.tokenize) {
+        return $TOKEN("SwitchStatement", state, SwitchStatement$0(state));
+      } else {
+        return SwitchStatement$0(state);
+      }
+    }
+    var CaseBlock$0 = $S(__, $EXPECT($L10, fail, 'CaseBlock "{"'), $Y(EOS), NestedCaseClauses, __, $EXPECT($L15, fail, 'CaseBlock "}"'));
+    var CaseBlock$1 = $S($Y(EOS), InsertOpenBrace, NestedCaseClauses, InsertNewline, InsertCloseBrace);
+    function CaseBlock(state) {
+      if (state.tokenize) {
+        return $TOKEN("CaseBlock", state, CaseBlock$0(state) || CaseBlock$1(state));
+      } else {
+        return CaseBlock$0(state) || CaseBlock$1(state);
+      }
+    }
+    var NestedCaseClauses$0 = $TS($S(PushIndent, $Q(NestedCaseClause), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var clauses = $2;
+      if (clauses.length)
+        return clauses;
+      return $skip;
+    });
+    function NestedCaseClauses(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedCaseClauses");
+      if (state.tokenize) {
+        return $TOKEN("NestedCaseClauses", state, NestedCaseClauses$0(state));
+      } else {
+        return NestedCaseClauses$0(state);
+      }
+    }
+    var NestedCaseClause$0 = $S(Nested, CaseClause);
+    function NestedCaseClause(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedCaseClause");
+      if (state.tokenize) {
+        return $TOKEN("NestedCaseClause", state, NestedCaseClause$0(state));
+      } else {
+        return NestedCaseClause$0(state);
+      }
+    }
+    var CaseClause$0 = $S($EXPECT($L98, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
+    var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
+    var CaseClause$2 = $S($EXPECT($L99, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
+    function CaseClause(state) {
+      if (state.tokenize) {
+        return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
+      } else {
+        return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
+      }
+    }
+    var When$0 = $T($EXPECT($L100, fail, 'When "when"'), 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($L11, fail, 'ImpliedColon ":"'));
+    var ImpliedColon$1 = $T($EXPECT($L29, fail, 'ImpliedColon ""'), function(value) {
+      return ":";
+    });
+    function ImpliedColon(state) {
+      if (state.tokenize) {
+        return $TOKEN("ImpliedColon", state, ImpliedColon$0(state) || ImpliedColon$1(state));
+      } else {
+        return ImpliedColon$0(state) || ImpliedColon$1(state);
+      }
+    }
+    var TryStatement$0 = $TS($S($EXPECT($L101, fail, 'TryStatement "try"'), BracedBlock, $E(Catch), $E(Finally)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var c = $3;
+      var f = $4;
+      if (!c && !f) {
+        return [$1, $2, " catch {}"];
+      }
+      return [$1, $2, c, f];
+    });
+    function TryStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TryStatement");
+      if (state.tokenize) {
+        return $TOKEN("TryStatement", state, TryStatement$0(state));
+      } else {
+        return TryStatement$0(state);
+      }
+    }
+    var Catch$0 = $S(__, $EXPECT($L102, fail, 'Catch "catch"'), $E(CatchBind), BracedBlock);
+    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 CatchBind$0 = $S(__, $EXPECT($L1, fail, 'CatchBind "("'), __, CatchParameter, __, $EXPECT($L2, fail, 'CatchBind ")"'));
+    var CatchBind$1 = $S(__, InsertOpenParen, CatchParameter, InsertCloseParen);
+    function CatchBind(state) {
+      if (state.tokenize) {
+        return $TOKEN("CatchBind", state, CatchBind$0(state) || CatchBind$1(state));
+      } else {
+        return CatchBind$0(state) || CatchBind$1(state);
+      }
+    }
+    var Finally$0 = $S(__, $EXPECT($L103, fail, 'Finally "finally"'), BracedBlock);
+    function Finally(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Finally");
+      if (state.tokenize) {
+        return $TOKEN("Finally", state, Finally$0(state));
+      } else {
+        return Finally$0(state);
+      }
+    }
+    var CatchParameter$0 = BindingIdentifier;
+    var CatchParameter$1 = BindingPattern;
+    function CatchParameter(state) {
+      if (state.tokenize) {
+        return $TOKEN("CatchParameter", state, CatchParameter$0(state) || CatchParameter$1(state));
+      } else {
+        return CatchParameter$0(state) || CatchParameter$1(state);
+      }
+    }
+    var Condition$0 = $S(__, $EXPECT($L1, fail, 'Condition "("'), __, Expression, __, $EXPECT($L2, fail, 'Condition ")"'));
+    var Condition$1 = $S($N(EOS), __, InsertOpenParen, Expression, InsertCloseParen);
+    function Condition(state) {
+      if (state.tokenize) {
+        return $TOKEN("Condition", state, Condition$0(state) || Condition$1(state));
+      } else {
+        return Condition$0(state) || Condition$1(state);
+      }
+    }
+    var ExpressionStatement$0 = Expression;
+    function ExpressionStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ExpressionStatement");
+      if (state.tokenize) {
+        return $TOKEN("ExpressionStatement", state, ExpressionStatement$0(state));
+      } else {
+        return ExpressionStatement$0(state);
+      }
+    }
+    var KeywordStatement$0 = $EXPECT($L104, fail, 'KeywordStatement "break"');
+    var KeywordStatement$1 = $EXPECT($L105, fail, 'KeywordStatement "continue"');
+    var KeywordStatement$2 = $EXPECT($L106, fail, 'KeywordStatement "debugger"');
+    var KeywordStatement$3 = $S($EXPECT($L107, fail, 'KeywordStatement "return"'), $P(_), Expression);
+    var KeywordStatement$4 = $EXPECT($L107, fail, 'KeywordStatement "return"');
+    var KeywordStatement$5 = $S($EXPECT($L108, fail, 'KeywordStatement "throw"'), $P(_), 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) || KeywordStatement$5(state));
+      } else {
+        return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
+      }
+    }
+    var ImportDeclaration$0 = $T($S($EXPECT($L109, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
+      return { "ts": true, "children": value };
+    });
+    var ImportDeclaration$1 = $S($EXPECT($L22, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
+    var ImportDeclaration$2 = $S($EXPECT($L22, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
+    function ImportDeclaration(state) {
+      if (state.tokenize) {
+        return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
+      } else {
+        return ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state);
+      }
+    }
+    var ImportClause$0 = $S(ImportedBinding, $E($S(__, $EXPECT($L0, fail, 'ImportClause ","'), __, $C(NameSpaceImport, NamedImports))));
+    var ImportClause$1 = NameSpaceImport;
+    var ImportClause$2 = NamedImports;
+    function ImportClause(state) {
+      if (state.tokenize) {
+        return $TOKEN("ImportClause", state, ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state));
+      } else {
+        return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
+      }
+    }
+    var NameSpaceImport$0 = $S($EXPECT($L8, fail, 'NameSpaceImport "*"'), __, $EXPECT($L110, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
+    function NameSpaceImport(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NameSpaceImport");
+      if (state.tokenize) {
+        return $TOKEN("NameSpaceImport", state, NameSpaceImport$0(state));
+      } else {
+        return NameSpaceImport$0(state);
+      }
+    }
+    var NamedImports$0 = $S($EXPECT($L10, fail, 'NamedImports "{"'), $Q(ImportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedImports ","'))), __, $EXPECT($L15, fail, 'NamedImports "}"'));
+    function NamedImports(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NamedImports");
+      if (state.tokenize) {
+        return $TOKEN("NamedImports", state, NamedImports$0(state));
+      } else {
+        return NamedImports$0(state);
+      }
+    }
+    var FromClause$0 = $S($EXPECT($L111, fail, 'FromClause "from"'), __, ModuleSpecifier);
+    function FromClause(state) {
+      if (state.verbose)
+        console.log("ENTER:", "FromClause");
+      if (state.tokenize) {
+        return $TOKEN("FromClause", state, FromClause$0(state));
+      } else {
+        return FromClause$0(state);
+      }
+    }
+    var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L110, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
+    var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
+    function ImportSpecifier(state) {
+      if (state.tokenize) {
+        return $TOKEN("ImportSpecifier", state, ImportSpecifier$0(state) || ImportSpecifier$1(state));
+      } else {
+        return ImportSpecifier$0(state) || ImportSpecifier$1(state);
+      }
+    }
+    var ModuleExportName$0 = StringLiteral;
+    var ModuleExportName$1 = IdentifierName;
+    function ModuleExportName(state) {
+      if (state.tokenize) {
+        return $TOKEN("ModuleExportName", state, ModuleExportName$0(state) || ModuleExportName$1(state));
+      } else {
+        return ModuleExportName$0(state) || ModuleExportName$1(state);
+      }
+    }
+    var ModuleSpecifier$0 = StringLiteral;
+    function ModuleSpecifier(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ModuleSpecifier");
+      if (state.tokenize) {
+        return $TOKEN("ModuleSpecifier", state, ModuleSpecifier$0(state));
+      } else {
+        return ModuleSpecifier$0(state);
+      }
+    }
+    var ImportedBinding$0 = BindingIdentifier;
+    function ImportedBinding(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ImportedBinding");
+      if (state.tokenize) {
+        return $TOKEN("ImportedBinding", state, ImportedBinding$0(state));
+      } else {
+        return ImportedBinding$0(state);
+      }
+    }
+    var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L99, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
+    var ExportDeclaration$1 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, ExportFromClause, __, FromClause);
+    var ExportDeclaration$2 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $C(NamedExports, VariableStatement, Declaration));
+    function ExportDeclaration(state) {
+      if (state.tokenize) {
+        return $TOKEN("ExportDeclaration", state, ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state));
+      } else {
+        return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
+      }
+    }
+    var ExportFromClause$0 = $S($EXPECT($L8, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L110, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
+    var ExportFromClause$1 = NamedExports;
+    function ExportFromClause(state) {
+      if (state.tokenize) {
+        return $TOKEN("ExportFromClause", state, ExportFromClause$0(state) || ExportFromClause$1(state));
+      } else {
+        return ExportFromClause$0(state) || ExportFromClause$1(state);
+      }
+    }
+    var NamedExports$0 = $S($EXPECT($L10, fail, 'NamedExports "{"'), $Q(ExportSpecifier), $E($S(__, $EXPECT($L0, fail, 'NamedExports ","'))), __, $EXPECT($L15, fail, 'NamedExports "}"'));
+    function NamedExports(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NamedExports");
+      if (state.tokenize) {
+        return $TOKEN("NamedExports", state, NamedExports$0(state));
+      } else {
+        return NamedExports$0(state);
+      }
+    }
+    var ExportSpecifier$0 = $S(__, ModuleExportName, $E($S(__, $EXPECT($L110, fail, 'ExportSpecifier "as"'), __, ModuleExportName)), ObjectPropertyDelimiter);
+    function ExportSpecifier(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ExportSpecifier");
+      if (state.tokenize) {
+        return $TOKEN("ExportSpecifier", state, ExportSpecifier$0(state));
+      } else {
+        return ExportSpecifier$0(state);
+      }
+    }
+    var Declaration$0 = HoistableDeclaration;
+    var Declaration$1 = ClassDeclaration;
+    var Declaration$2 = LexicalDeclaration;
+    var Declaration$3 = TypeDeclaration;
+    function Declaration(state) {
+      if (state.tokenize) {
+        return $TOKEN("Declaration", state, Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state));
+      } else {
+        return Declaration$0(state) || Declaration$1(state) || Declaration$2(state) || Declaration$3(state);
+      }
+    }
+    var HoistableDeclaration$0 = AsyncGeneratorDeclaration;
+    var HoistableDeclaration$1 = AsyncFunctionDeclaration;
+    var HoistableDeclaration$2 = GeneratorDeclaration;
+    var HoistableDeclaration$3 = FunctionDeclaration;
+    function HoistableDeclaration(state) {
+      if (state.tokenize) {
+        return $TOKEN("HoistableDeclaration", state, HoistableDeclaration$0(state) || HoistableDeclaration$1(state) || HoistableDeclaration$2(state) || HoistableDeclaration$3(state));
+      } else {
+        return HoistableDeclaration$0(state) || HoistableDeclaration$1(state) || HoistableDeclaration$2(state) || HoistableDeclaration$3(state);
+      }
+    }
+    var LexicalDeclaration$0 = $S($C($EXPECT($L95, fail, 'LexicalDeclaration "let"'), $EXPECT($L96, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
+    function LexicalDeclaration(state) {
+      if (state.verbose)
+        console.log("ENTER:", "LexicalDeclaration");
+      if (state.tokenize) {
+        return $TOKEN("LexicalDeclaration", state, LexicalDeclaration$0(state));
+      } else {
+        return LexicalDeclaration$0(state);
+      }
+    }
+    var LexicalBinding$0 = $S(BindingPattern, $E(TypeSuffix), Initializer);
+    var LexicalBinding$1 = $S(BindingIdentifier, $E(TypeSuffix), $E(Initializer));
+    function LexicalBinding(state) {
+      if (state.tokenize) {
+        return $TOKEN("LexicalBinding", state, LexicalBinding$0(state) || LexicalBinding$1(state));
+      } else {
+        return LexicalBinding$0(state) || LexicalBinding$1(state);
+      }
+    }
+    var Initializer$0 = $S(__, $EXPECT($L54, fail, 'Initializer "="'), AssignmentExpression);
+    function Initializer(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Initializer");
+      if (state.tokenize) {
+        return $TOKEN("Initializer", state, Initializer$0(state));
+      } else {
+        return Initializer$0(state);
+      }
+    }
+    var VariableStatement$0 = $S($EXPECT($L92, fail, 'VariableStatement "var"'), __, VariableDeclarationList);
+    function VariableStatement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "VariableStatement");
+      if (state.tokenize) {
+        return $TOKEN("VariableStatement", state, VariableStatement$0(state));
+      } else {
+        return VariableStatement$0(state);
+      }
+    }
+    var VariableDeclarationList$0 = $S(VariableDeclaration, $Q($S(__, $EXPECT($L0, fail, 'VariableDeclarationList ","'), __, VariableDeclaration)));
+    function VariableDeclarationList(state) {
+      if (state.verbose)
+        console.log("ENTER:", "VariableDeclarationList");
+      if (state.tokenize) {
+        return $TOKEN("VariableDeclarationList", state, VariableDeclarationList$0(state));
+      } else {
+        return VariableDeclarationList$0(state);
+      }
+    }
+    var VariableDeclaration$0 = $S(BindingPattern, Initializer);
+    var VariableDeclaration$1 = $S(BindingIdentifier, $E(Initializer));
+    function VariableDeclaration(state) {
+      if (state.tokenize) {
+        return $TOKEN("VariableDeclaration", state, VariableDeclaration$0(state) || VariableDeclaration$1(state));
+      } else {
+        return VariableDeclaration$0(state) || VariableDeclaration$1(state);
+      }
+    }
+    var NumericLiteral$0 = DecimalBigIntegerLiteral;
+    var NumericLiteral$1 = BinaryIntegerLiteral;
+    var NumericLiteral$2 = OctalIntegerLiteral;
+    var NumericLiteral$3 = HexLiteral;
+    var NumericLiteral$4 = DecimalLiteral;
+    function NumericLiteral(state) {
+      if (state.tokenize) {
+        return $TOKEN("NumericLiteral", state, NumericLiteral$0(state) || NumericLiteral$1(state) || NumericLiteral$2(state) || NumericLiteral$3(state) || NumericLiteral$4(state));
+      } else {
+        return NumericLiteral$0(state) || NumericLiteral$1(state) || NumericLiteral$2(state) || NumericLiteral$3(state) || NumericLiteral$4(state);
+      }
+    }
+    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");
+      if (state.tokenize) {
+        return $TOKEN("DecimalBigIntegerLiteral", state, DecimalBigIntegerLiteral$0(state));
+      } else {
+        return DecimalBigIntegerLiteral$0(state);
+      }
+    }
+    var DecimalLiteral$0 = $R$0($EXPECT($R5, fail, "DecimalLiteral /\\d+(?:\\.\\d*)?/"));
+    function DecimalLiteral(state) {
+      if (state.verbose)
+        console.log("ENTER:", "DecimalLiteral");
+      if (state.tokenize) {
+        return $TOKEN("DecimalLiteral", state, DecimalLiteral$0(state));
+      } else {
+        return DecimalLiteral$0(state);
+      }
+    }
+    var BinaryIntegerLiteral$0 = $R$0($EXPECT($R6, fail, "BinaryIntegerLiteral /0[bB][01](?:[01]|_[01])*/"));
+    function BinaryIntegerLiteral(state) {
+      if (state.verbose)
+        console.log("ENTER:", "BinaryIntegerLiteral");
+      if (state.tokenize) {
+        return $TOKEN("BinaryIntegerLiteral", state, BinaryIntegerLiteral$0(state));
+      } else {
+        return BinaryIntegerLiteral$0(state);
+      }
+    }
+    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");
+      if (state.tokenize) {
+        return $TOKEN("OctalIntegerLiteral", state, OctalIntegerLiteral$0(state));
+      } else {
+        return OctalIntegerLiteral$0(state);
+      }
+    }
+    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");
+      if (state.tokenize) {
+        return $TOKEN("HexLiteral", state, HexLiteral$0(state));
+      } else {
+        return HexLiteral$0(state);
+      }
+    }
+    var StringLiteral$0 = $T($S($EXPECT($L113, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L113, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function(value) {
+      return ["`", value[1], "`"];
+    });
+    var StringLiteral$1 = $S($EXPECT($L114, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L114, fail, 'StringLiteral "\\\\\\""'));
+    var StringLiteral$2 = $S($EXPECT($L115, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L115, fail, `StringLiteral "\\\\'"`));
+    function StringLiteral(state) {
+      if (state.tokenize) {
+        return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
+      } else {
+        return StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state);
+      }
+    }
+    var DoubleStringCharacter$0 = $R$0($EXPECT($R9, fail, 'DoubleStringCharacter /[^"\\\\]+/'));
+    var DoubleStringCharacter$1 = EscapeSequence;
+    function DoubleStringCharacter(state) {
+      if (state.tokenize) {
+        return $TOKEN("DoubleStringCharacter", state, DoubleStringCharacter$0(state) || DoubleStringCharacter$1(state));
+      } else {
+        return DoubleStringCharacter$0(state) || DoubleStringCharacter$1(state);
+      }
+    }
+    var SingleStringCharacter$0 = $R$0($EXPECT($R10, fail, "SingleStringCharacter /[^'\\\\]+/"));
+    var SingleStringCharacter$1 = EscapeSequence;
+    function SingleStringCharacter(state) {
+      if (state.tokenize) {
+        return $TOKEN("SingleStringCharacter", state, SingleStringCharacter$0(state) || SingleStringCharacter$1(state));
+      } else {
+        return SingleStringCharacter$0(state) || SingleStringCharacter$1(state);
+      }
+    }
+    var TripleDoubleStringCharacter$0 = $R$0($EXPECT($R11, fail, 'TripleDoubleStringCharacter /(?:"(?!"")|\\\\.|[^"])+/'));
+    function TripleDoubleStringCharacter(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TripleDoubleStringCharacter");
+      if (state.tokenize) {
+        return $TOKEN("TripleDoubleStringCharacter", state, TripleDoubleStringCharacter$0(state));
+      } else {
+        return TripleDoubleStringCharacter$0(state);
+      }
+    }
+    var EscapeSequence$0 = $TEXT($S($EXPECT($L116, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R12, fail, "EscapeSequence /./")));
+    function EscapeSequence(state) {
+      if (state.verbose)
+        console.log("ENTER:", "EscapeSequence");
+      if (state.tokenize) {
+        return $TOKEN("EscapeSequence", state, EscapeSequence$0(state));
+      } else {
+        return EscapeSequence$0(state);
+      }
+    }
+    var RegularExpressionLiteral$0 = $S($EXPECT($L56, fail, 'RegularExpressionLiteral "/"'), $TEXT(RegularExpressionBody), $EXPECT($L56, fail, 'RegularExpressionLiteral "/"'), RegularExpressionFlags);
+    function RegularExpressionLiteral(state) {
+      if (state.verbose)
+        console.log("ENTER:", "RegularExpressionLiteral");
+      if (state.tokenize) {
+        return $TOKEN("RegularExpressionLiteral", state, RegularExpressionLiteral$0(state));
+      } else {
+        return RegularExpressionLiteral$0(state);
+      }
+    }
+    var RegularExpressionBody$0 = $S($R$0($EXPECT($R13, fail, "RegularExpressionBody /[^*\\/\\r\\n]/")), $Q(RegExpCharacter));
+    function RegularExpressionBody(state) {
+      if (state.verbose)
+        console.log("ENTER:", "RegularExpressionBody");
+      if (state.tokenize) {
+        return $TOKEN("RegularExpressionBody", state, RegularExpressionBody$0(state));
+      } else {
+        return RegularExpressionBody$0(state);
+      }
+    }
+    var RegExpCharacter$0 = $R$0($EXPECT($R14, fail, "RegExpCharacter /[^\\/\\r\\n]+/"));
+    var RegExpCharacter$1 = EscapeSequence;
+    function RegExpCharacter(state) {
+      if (state.tokenize) {
+        return $TOKEN("RegExpCharacter", state, RegExpCharacter$0(state) || RegExpCharacter$1(state));
+      } else {
+        return RegExpCharacter$0(state) || RegExpCharacter$1(state);
+      }
+    }
+    var RegularExpressionFlags$0 = $R$0($EXPECT($R15, fail, "RegularExpressionFlags /(:?\\p{ID_Continue}|[\\u200C\\u200D$])*/"));
+    function RegularExpressionFlags(state) {
+      if (state.verbose)
+        console.log("ENTER:", "RegularExpressionFlags");
+      if (state.tokenize) {
+        return $TOKEN("RegularExpressionFlags", state, RegularExpressionFlags$0(state));
+      } else {
+        return RegularExpressionFlags$0(state);
+      }
+    }
+    var TemplateLiteral$0 = $S($EXPECT($L117, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L117, fail, 'TemplateLiteral "`"'));
+    function TemplateLiteral(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TemplateLiteral");
+      if (state.tokenize) {
+        return $TOKEN("TemplateLiteral", state, TemplateLiteral$0(state));
+      } else {
+        return TemplateLiteral$0(state);
+      }
+    }
+    var TemplateSubstitution$0 = $S($EXPECT($L118, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L15, fail, 'TemplateSubstitution "}"'));
+    function TemplateSubstitution(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TemplateSubstitution");
+      if (state.tokenize) {
+        return $TOKEN("TemplateSubstitution", state, TemplateSubstitution$0(state));
+      } else {
+        return TemplateSubstitution$0(state);
+      }
+    }
+    var TemplateCharacters$0 = $R$0($EXPECT($R16, fail, "TemplateCharacters /(?:\\$(?!\\{)|\\\\.|[^$`])+/"));
+    function TemplateCharacters(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TemplateCharacters");
+      if (state.tokenize) {
+        return $TOKEN("TemplateCharacters", state, TemplateCharacters$0(state));
+      } else {
+        return TemplateCharacters$0(state);
+      }
+    }
+    var ReservedWord$0 = $R$0($EXPECT($R17, fail, "ReservedWord /(?:and|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|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");
+      if (state.tokenize) {
+        return $TOKEN("ReservedWord", state, ReservedWord$0(state));
+      } else {
+        return ReservedWord$0(state);
+      }
+    }
+    var Comment$0 = MultiLineComment;
+    var Comment$1 = SingleLineComment;
+    function Comment(state) {
+      if (state.tokenize) {
+        return $TOKEN("Comment", state, Comment$0(state) || Comment$1(state));
+      } else {
+        return Comment$0(state) || Comment$1(state);
+      }
+    }
+    var SingleLineComment$0 = $R$0($EXPECT($R18, fail, "SingleLineComment /\\/\\/[^\\r\\n]*/"));
+    var SingleLineComment$1 = CoffeeSingleLineComment;
+    function SingleLineComment(state) {
+      if (state.tokenize) {
+        return $TOKEN("SingleLineComment", state, SingleLineComment$0(state) || SingleLineComment$1(state));
+      } else {
+        return SingleLineComment$0(state) || SingleLineComment$1(state);
+      }
+    }
+    var MultiLineComment$0 = JSMultiLineComment;
+    var MultiLineComment$1 = CoffeeMultiLineComment;
+    function MultiLineComment(state) {
+      if (state.tokenize) {
+        return $TOKEN("MultiLineComment", state, MultiLineComment$0(state) || MultiLineComment$1(state));
+      } else {
+        return MultiLineComment$0(state) || MultiLineComment$1(state);
+      }
+    }
+    var JSMultiLineComment$0 = $S($EXPECT($L119, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L120, fail, 'JSMultiLineComment "*/"')), $EXPECT($R12, fail, "JSMultiLineComment /./")))), $EXPECT($L120, fail, 'JSMultiLineComment "*/"'));
+    function JSMultiLineComment(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSMultiLineComment");
+      if (state.tokenize) {
+        return $TOKEN("JSMultiLineComment", state, JSMultiLineComment$0(state));
+      } else {
+        return JSMultiLineComment$0(state);
+      }
+    }
+    var CoffeeSingleLineComment$0 = $TR($EXPECT($R19, fail, "CoffeeSingleLineComment /#([^\\r\\n]*)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      if (!global.coffeeCompat)
+        return $skip;
+      return ["//", $1];
+    });
+    function CoffeeSingleLineComment(state) {
+      if (state.verbose)
+        console.log("ENTER:", "CoffeeSingleLineComment");
+      if (state.tokenize) {
+        return $TOKEN("CoffeeSingleLineComment", state, CoffeeSingleLineComment$0(state));
+      } else {
+        return CoffeeSingleLineComment$0(state);
+      }
+    }
+    var CoffeeMultiLineComment$0 = $T($S($EXPECT($L121, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R12, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L121, fail, 'CoffeeMultiLineComment "###"')), function(value) {
+      return ["/*", value[1], "*/"];
+    });
+    function CoffeeMultiLineComment(state) {
+      if (state.verbose)
+        console.log("ENTER:", "CoffeeMultiLineComment");
+      if (state.tokenize) {
+        return $TOKEN("CoffeeMultiLineComment", state, CoffeeMultiLineComment$0(state));
+      } else {
+        return CoffeeMultiLineComment$0(state);
+      }
+    }
+    var InlineComment$0 = $S($EXPECT($L119, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L120, fail, 'InlineComment "*/"')), $EXPECT($R20, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L120, fail, 'InlineComment "*/"'));
+    function InlineComment(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InlineComment");
+      if (state.tokenize) {
+        return $TOKEN("InlineComment", state, InlineComment$0(state));
+      } else {
+        return InlineComment$0(state);
+      }
+    }
+    var RestOfLine$0 = $S($Q(TrailingComment), EOL);
+    function RestOfLine(state) {
+      if (state.verbose)
+        console.log("ENTER:", "RestOfLine");
+      if (state.tokenize) {
+        return $TOKEN("RestOfLine", state, RestOfLine$0(state));
+      } else {
+        return RestOfLine$0(state);
+      }
+    }
+    var TrailingComment$0 = $R$0($EXPECT($R21, fail, "TrailingComment /[\\t ]+/"));
+    var TrailingComment$1 = InlineComment;
+    var TrailingComment$2 = SingleLineComment;
+    function TrailingComment(state) {
+      if (state.tokenize) {
+        return $TOKEN("TrailingComment", state, TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state));
+      } else {
+        return TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
+      }
+    }
+    var _$0 = $P($C($R$0($EXPECT($R21, fail, "_ /[\\t ]+/")), Comment));
+    function _(state) {
+      if (state.verbose)
+        console.log("ENTER:", "_");
+      if (state.tokenize) {
+        return $TOKEN("_", state, _$0(state));
+      } else {
+        return _$0(state);
+      }
+    }
+    var __$0 = $Q($C($R$0($EXPECT($R22, fail, "__ /[\\s]+/")), Comment));
+    function __(state) {
+      if (state.verbose)
+        console.log("ENTER:", "__");
+      if (state.tokenize) {
+        return $TOKEN("__", state, __$0(state));
+      } else {
+        return __$0(state);
+      }
+    }
+    var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L84, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
+    var StatementDelimiter$1 = $T($Y(EOS), function(value) {
+      return [";", value];
+    });
+    function StatementDelimiter(state) {
+      if (state.tokenize) {
+        return $TOKEN("StatementDelimiter", state, StatementDelimiter$0(state) || StatementDelimiter$1(state));
+      } else {
+        return StatementDelimiter$0(state) || StatementDelimiter$1(state);
+      }
+    }
+    var TypeDeclaration$0 = $T($S($EXPECT($L122, fail, 'TypeDeclaration "interface"'), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
+      return { "ts": true, "children": value };
+    });
+    function TypeDeclaration(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TypeDeclaration");
+      if (state.tokenize) {
+        return $TOKEN("TypeDeclaration", state, TypeDeclaration$0(state));
+      } else {
+        return TypeDeclaration$0(state);
+      }
+    }
+    var InterfaceBlock$0 = $S(__, $EXPECT($L10, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L15, fail, 'InterfaceBlock "}"'));
+    var InterfaceBlock$1 = $S(InsertOpenBrace, EOS, NestedInterfaceProperties, InsertNewline, InsertIndent, InsertCloseBrace);
+    function InterfaceBlock(state) {
+      if (state.tokenize) {
+        return $TOKEN("InterfaceBlock", state, InterfaceBlock$0(state) || InterfaceBlock$1(state));
+      } else {
+        return InterfaceBlock$0(state) || InterfaceBlock$1(state);
+      }
+    }
+    var NestedInterfaceProperties$0 = $TS($S(PushIndent, $Q(NestedInterfaceProperty), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var props = $2;
+      if (props.length)
+        return props;
+      return $skip;
+    });
+    function NestedInterfaceProperties(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedInterfaceProperties");
+      if (state.tokenize) {
+        return $TOKEN("NestedInterfaceProperties", state, NestedInterfaceProperties$0(state));
+      } else {
+        return NestedInterfaceProperties$0(state);
+      }
+    }
+    var NestedInterfaceProperty$0 = $S(Nested, PropertyName, TypeSuffix, StatementDelimiter);
+    function NestedInterfaceProperty(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedInterfaceProperty");
+      if (state.tokenize) {
+        return $TOKEN("NestedInterfaceProperty", state, NestedInterfaceProperty$0(state));
+      } else {
+        return NestedInterfaceProperty$0(state);
+      }
+    }
+    var TypeSuffix$0 = $T($S(__, $EXPECT($L11, fail, 'TypeSuffix ":"'), Type), function(value) {
+      return { "ts": true, "children": value };
+    });
+    function TypeSuffix(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TypeSuffix");
+      if (state.tokenize) {
+        return $TOKEN("TypeSuffix", state, TypeSuffix$0(state));
+      } else {
+        return TypeSuffix$0(state);
+      }
+    }
+    var Type$0 = InterfaceBlock;
+    var Type$1 = $S($Q(_), FunctionType);
+    var Type$2 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'Type "."'), IdentifierName)), $E(TypeArguments), $Q($EXPECT($L123, fail, 'Type "[]"')));
+    var Type$3 = $S($Q(_), NumericLiteral);
+    var Type$4 = $S($Q(_), StringLiteral);
+    var Type$5 = $S($Q(_), $EXPECT($L82, fail, 'Type "void"'));
+    function Type(state) {
+      if (state.tokenize) {
+        return $TOKEN("Type", state, Type$0(state) || Type$1(state) || Type$2(state) || Type$3(state) || Type$4(state) || Type$5(state));
+      } else {
+        return Type$0(state) || Type$1(state) || Type$2(state) || Type$3(state) || Type$4(state) || Type$5(state);
+      }
+    }
+    var FunctionType$0 = $S(Parameters, __, $EXPECT($L9, fail, 'FunctionType "=>"'), Type);
+    function FunctionType(state) {
+      if (state.verbose)
+        console.log("ENTER:", "FunctionType");
+      if (state.tokenize) {
+        return $TOKEN("FunctionType", state, FunctionType$0(state));
+      } else {
+        return FunctionType$0(state);
+      }
+    }
+    var TypeArguments$0 = $S(__, $EXPECT($L13, fail, 'TypeArguments "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeArguments ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeArguments ","'))), __, $EXPECT($L65, fail, 'TypeArguments ">"'));
+    function TypeArguments(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TypeArguments");
+      if (state.tokenize) {
+        return $TOKEN("TypeArguments", state, TypeArguments$0(state));
+      } else {
+        return TypeArguments$0(state);
+      }
+    }
+    var Shebang$0 = $R$0($EXPECT($R23, fail, "Shebang /#![^\\r\\n]*/"));
+    function Shebang(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Shebang");
+      if (state.tokenize) {
+        return $TOKEN("Shebang", state, Shebang$0(state));
+      } else {
+        return Shebang$0(state);
+      }
+    }
+    var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R24, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
+      return $0.map((p) => p.join(""));
+    });
+    function DirectivePrologue(state) {
+      if (state.verbose)
+        console.log("ENTER:", "DirectivePrologue");
+      if (state.tokenize) {
+        return $TOKEN("DirectivePrologue", state, DirectivePrologue$0(state));
+      } else {
+        return DirectivePrologue$0(state);
+      }
+    }
+    var EOS$0 = $P(RestOfLine);
+    function EOS(state) {
+      if (state.verbose)
+        console.log("ENTER:", "EOS");
+      if (state.tokenize) {
+        return $TOKEN("EOS", state, EOS$0(state));
+      } else {
+        return EOS$0(state);
+      }
+    }
+    var EOL$0 = $R$0($EXPECT($R25, fail, "EOL /\\r\\n|\\n|\\r|$/"));
+    function EOL(state) {
+      if (state.verbose)
+        console.log("ENTER:", "EOL");
+      if (state.tokenize) {
+        return $TOKEN("EOL", state, EOL$0(state));
+      } else {
+        return EOL$0(state);
+      }
+    }
+    var EOF$0 = $R$0($EXPECT($R26, fail, "EOF /$/"));
+    function EOF(state) {
+      if (state.verbose)
+        console.log("ENTER:", "EOF");
+      if (state.tokenize) {
+        return $TOKEN("EOF", state, EOF$0(state));
+      } else {
+        return EOF$0(state);
+      }
+    }
+    var InsertOpenParen$0 = $T($EXPECT($L29, fail, 'InsertOpenParen ""'), function(value) {
+      return "(";
+    });
+    function InsertOpenParen(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InsertOpenParen");
+      if (state.tokenize) {
+        return $TOKEN("InsertOpenParen", state, InsertOpenParen$0(state));
+      } else {
+        return InsertOpenParen$0(state);
+      }
+    }
+    var InsertCloseParen$0 = $T($EXPECT($L29, fail, 'InsertCloseParen ""'), function(value) {
+      return ")";
+    });
+    function InsertCloseParen(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InsertCloseParen");
+      if (state.tokenize) {
+        return $TOKEN("InsertCloseParen", state, InsertCloseParen$0(state));
+      } else {
+        return InsertCloseParen$0(state);
+      }
+    }
+    var InsertOpenBrace$0 = $T($EXPECT($L29, fail, 'InsertOpenBrace ""'), function(value) {
+      return " {";
+    });
+    function InsertOpenBrace(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InsertOpenBrace");
+      if (state.tokenize) {
+        return $TOKEN("InsertOpenBrace", state, InsertOpenBrace$0(state));
+      } else {
+        return InsertOpenBrace$0(state);
+      }
+    }
+    var InsertCloseBrace$0 = $T($EXPECT($L29, fail, 'InsertCloseBrace ""'), function(value) {
+      return "}";
+    });
+    function InsertCloseBrace(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InsertCloseBrace");
+      if (state.tokenize) {
+        return $TOKEN("InsertCloseBrace", state, InsertCloseBrace$0(state));
+      } else {
+        return InsertCloseBrace$0(state);
+      }
+    }
+    var InsertNewline$0 = $TV($EXPECT($L29, fail, 'InsertNewline ""'), function($skip, $loc, $0, $1) {
+      return "\n";
+    });
+    function InsertNewline(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InsertNewline");
+      if (state.tokenize) {
+        return $TOKEN("InsertNewline", state, InsertNewline$0(state));
+      } else {
+        return InsertNewline$0(state);
+      }
+    }
+    var InsertIndent$0 = $TV($EXPECT($L29, fail, 'InsertIndent ""'), function($skip, $loc, $0, $1) {
+      return "".padStart(global.currentIndent * 2);
+    });
+    function InsertIndent(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InsertIndent");
+      if (state.tokenize) {
+        return $TOKEN("InsertIndent", state, InsertIndent$0(state));
+      } else {
+        return InsertIndent$0(state);
+      }
+    }
+    var InsertSpace$0 = $T($EXPECT($L29, fail, 'InsertSpace ""'), function(value) {
+      return " ";
+    });
+    function InsertSpace(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InsertSpace");
+      if (state.tokenize) {
+        return $TOKEN("InsertSpace", state, InsertSpace$0(state));
+      } else {
+        return InsertSpace$0(state);
+      }
+    }
+    var InsertDot$0 = $T($EXPECT($L29, fail, 'InsertDot ""'), function(value) {
+      return ".";
+    });
+    function InsertDot(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InsertDot");
+      if (state.tokenize) {
+        return $TOKEN("InsertDot", state, InsertDot$0(state));
+      } else {
+        return InsertDot$0(state);
+      }
+    }
+    var InsertBreak$0 = $T($EXPECT($L29, fail, 'InsertBreak ""'), function(value) {
+      return "break;";
+    });
+    function InsertBreak(state) {
+      if (state.verbose)
+        console.log("ENTER:", "InsertBreak");
+      if (state.tokenize) {
+        return $TOKEN("InsertBreak", state, InsertBreak$0(state));
+      } else {
+        return InsertBreak$0(state);
+      }
+    }
+    var Init$0 = $TS($S($E(Shebang), DirectivePrologue, $EXPECT($L29, fail, 'Init ""')), function($skip, $loc, $0, $1, $2, $3) {
+      var directives = $2;
+      global.currentIndent = 0;
+      global.indentLevels = [0];
+      global.verbose = false;
+      if (directives) {
+        const compatRe = /use coffee-compat/;
+        global.coffeeCompat = directives.some((d) => d.match(compatRe));
+      }
+      return $0;
+    });
+    function Init(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Init");
+      if (state.tokenize) {
+        return $TOKEN("Init", state, Init$0(state));
+      } else {
+        return Init$0(state);
+      }
+    }
+    var Indent$0 = $TV($Q($C($EXPECT($L124, fail, 'Indent "  "'), $EXPECT($L125, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
+      return $1.length;
+    });
+    function Indent(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Indent");
+      if (state.tokenize) {
+        return $TOKEN("Indent", state, Indent$0(state));
+      } else {
+        return Indent$0(state);
+      }
+    }
+    var PushIndent$0 = $TV($EXPECT($L29, fail, 'PushIndent ""'), function($skip, $loc, $0, $1) {
+      global.currentIndent++;
+      if (global.verbose) {
+        console.log("pushing indent", global.currentIndent);
+      }
+      global.indentLevels.push(global.currentIndent);
+      return global.currentIndent;
+    });
+    function PushIndent(state) {
+      if (state.verbose)
+        console.log("ENTER:", "PushIndent");
+      if (state.tokenize) {
+        return $TOKEN("PushIndent", state, PushIndent$0(state));
+      } else {
+        return PushIndent$0(state);
+      }
+    }
+    var PopIndent$0 = $TV($EXPECT($L29, 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]);
+      }
+      global.indentLevels.pop();
+      global.currentIndent = global.indentLevels[global.indentLevels.length - 1];
+      return global.currentIndent;
+    });
+    function PopIndent(state) {
+      if (state.verbose)
+        console.log("ENTER:", "PopIndent");
+      if (state.tokenize) {
+        return $TOKEN("PopIndent", state, PopIndent$0(state));
+      } else {
+        return PopIndent$0(state);
+      }
+    }
+    var Nested$0 = $TS($S($E(EOS), Indent), function($skip, $loc, $0, $1, $2) {
+      var eos = $1;
+      var indent = $2;
+      const currentIndent = global.indentLevels[global.indentLevels.length - 1];
+      if (global.verbose) {
+        console.log("global indent", global.currentIndent);
+        console.log("Indented", indent, currentIndent);
+      }
+      if (indent !== currentIndent) {
+        if (global.verbose) {
+          console.log("skipped nested");
+        }
+        return $skip;
+      }
+      return [eos, "".padStart(indent * 2)];
+    });
+    function Nested(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Nested");
+      if (state.tokenize) {
+        return $TOKEN("Nested", state, Nested$0(state));
+      } else {
+        return Nested$0(state);
+      }
+    }
+    module2.exports = {
+      parse: parse2
+    };
+  }
+});
+
+// source/generate.coffee
+var require_generate = __commonJS({
+  "source/generate.coffee"(exports2, module2) {
+    var gen2;
+    gen2 = function(node, options) {
+      if (node === null || node === void 0) {
+        return "";
+      }
+      if (typeof node === "string") {
+        return node;
+      }
+      if (Array.isArray(node)) {
+        return node.map(function(child) {
+          return gen2(child, options);
+        }).join("");
+      }
+      if (typeof node === "object") {
+        if ((options != null ? options.js : void 0) && node.ts) {
+          return "";
+        }
+        if (!node.children) {
+          debugger;
+          throw new Error("Unknown node", JSON.stringify(node));
+        }
+        return node.children.map(function(child) {
+          return gen2(child, options);
+        }).join("");
+      }
+      throw new Error("Unknown node", JSON.stringify(node));
+    };
+    module2.exports = gen2;
+  }
+});
+
+// source/main.coffee
+var gen;
+var parse;
+({ parse } = require_parser());
+gen = require_generate();
+module.exports = {
+  parse,
+  compile: function(src, options) {
+    return gen(parse(src), options);
+  }
+};