@danielx/civet 0.1.0 → 0.2.1

package/dist/main.js

@@ -409,6 +409,8 @@ var require_parser = __commonJS({
       Expression,
       Arguments,
       ArgumentList,
+      NestedArgumentList,
+      NestedArgument,
       CommaExpression,
       BinaryOpExpression,
       UnaryExpression,
@@ -579,14 +581,41 @@ var require_parser = __commonJS({
       _,
       __,
       StatementDelimiter,
+      JSXElement,
+      JSXSelfClosingElement,
+      JSXOpeningElement,
+      JSXClosingElement,
+      JSXFragment,
+      JSXElementName,
+      JSXIdentifierName,
+      JSXAttributes,
+      JSXAttribute,
+      JSXAttributeName,
+      JSXAttributeInitializer,
+      JSXAttributeValue,
+      JSXChildren,
+      JSXChild,
+      JSXText,
+      JSXChildExpression,
       TypeDeclaration,
       InterfaceBlock,
       NestedInterfaceProperties,
       NestedInterfaceProperty,
       TypeSuffix,
       Type,
+      TypeBinary,
+      TypeUnary,
+      TypeUnaryOp,
+      TypePrimary,
+      TypeConditional,
+      TypeLiteral,
+      TypeBinaryOp,
       FunctionType,
       TypeArguments,
+      TypeParameters,
+      TypeParameter,
+      TypeConstraint,
+      TypeParameterDelimiter,
       Shebang,
       DirectivePrologue,
       EOS,
@@ -720,19 +749,24 @@ var require_parser = __commonJS({
     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 $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("###");
+    var $L123 = $L("/>");
+    var $L124 = $L("</");
+    var $L125 = $L("<>");
+    var $L126 = $L("</>");
+    var $L127 = $L("infer");
+    var $L128 = $L("[]");
+    var $L129 = $L("  ");
+    var $L130 = $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"));
@@ -756,10 +790,17 @@ var require_parser = __commonJS({
     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 $R23 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*", "suy"));
+    var $R24 = $R(new RegExp('"[^"]*"', "suy"));
+    var $R25 = $R(new RegExp("'[^']*'", "suy"));
+    var $R26 = $R(new RegExp("[^{}<>]+", "suy"));
+    var $R27 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
+    var $R28 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
+    var $R29 = $R(new RegExp("(?!\\p{ID_Continue})", "suy"));
+    var $R30 = $R(new RegExp("#![^\\r\\n]*", "suy"));
+    var $R31 = $R(new RegExp("[\\t ]*", "suy"));
+    var $R32 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
+    var $R33 = $R(new RegExp("$", "suy"));
     var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
     function Program(state) {
       if (state.verbose)
@@ -790,7 +831,7 @@ var require_parser = __commonJS({
         return Expression$0(state);
       }
     }
-    var Arguments$0 = $S($EXPECT($L1, fail, 'Arguments "("'), $C(ArgumentList, __), $E($S($EXPECT($L0, fail, 'Arguments ","'), __)), $EXPECT($L2, fail, 'Arguments ")"'));
+    var Arguments$0 = $S($EXPECT($L1, fail, 'Arguments "("'), $E(ArgumentList), $E($S(__, $EXPECT($L0, fail, 'Arguments ","'))), __, $EXPECT($L2, fail, 'Arguments ")"'));
     function Arguments(state) {
       if (state.verbose)
         console.log("ENTER:", "Arguments");
@@ -800,14 +841,38 @@ var require_parser = __commonJS({
         return Arguments$0(state);
       }
     }
-    var ArgumentList$0 = $S(Expression, $Q(CommaExpression));
+    var ArgumentList$0 = $S($Y(EOS), NestedArgumentList);
+    var ArgumentList$1 = $S(__, Expression, $Q(CommaExpression));
     function ArgumentList(state) {
+      if (state.tokenize) {
+        return $TOKEN("ArgumentList", state, ArgumentList$0(state) || ArgumentList$1(state));
+      } else {
+        return ArgumentList$0(state) || ArgumentList$1(state);
+      }
+    }
+    var NestedArgumentList$0 = $TS($S(PushIndent, $Q(NestedArgument), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var args = $2;
+      if (args.length)
+        return args;
+      return $skip;
+    });
+    function NestedArgumentList(state) {
       if (state.verbose)
-        console.log("ENTER:", "ArgumentList");
+        console.log("ENTER:", "NestedArgumentList");
       if (state.tokenize) {
-        return $TOKEN("ArgumentList", state, ArgumentList$0(state));
+        return $TOKEN("NestedArgumentList", state, NestedArgumentList$0(state));
       } else {
-        return ArgumentList$0(state);
+        return NestedArgumentList$0(state);
+      }
+    }
+    var NestedArgument$0 = $S(Nested, Expression, ParameterElementDelimiter);
+    function NestedArgument(state) {
+      if (state.verbose)
+        console.log("ENTER:", "NestedArgument");
+      if (state.tokenize) {
+        return $TOKEN("NestedArgument", state, NestedArgument$0(state));
+      } else {
+        return NestedArgument$0(state);
       }
     }
     var CommaExpression$0 = $S(__, $EXPECT($L0, fail, 'CommaExpression ","'), __, Expression);
@@ -946,11 +1011,13 @@ var require_parser = __commonJS({
     var PrimaryExpression$7 = RegularExpressionLiteral;
     var PrimaryExpression$8 = TemplateLiteral;
     var PrimaryExpression$9 = $S($EXPECT($L1, fail, 'PrimaryExpression "("'), __, Expression, __, $EXPECT($L2, fail, 'PrimaryExpression ")"'));
+    var PrimaryExpression$10 = JSXElement;
+    var PrimaryExpression$11 = JSXFragment;
     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));
+        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) || PrimaryExpression$10(state) || PrimaryExpression$11(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);
+        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) || PrimaryExpression$10(state) || PrimaryExpression$11(state);
       }
     }
     var ClassDeclaration$0 = ClassExpression;
@@ -2137,9 +2204,9 @@ var require_parser = __commonJS({
     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$3 = $S($EXPECT($L107, fail, 'KeywordStatement "return"'), Expression);
     var KeywordStatement$4 = $EXPECT($L107, fail, 'KeywordStatement "return"');
-    var KeywordStatement$5 = $S($EXPECT($L108, fail, 'KeywordStatement "throw"'), $P(_), Expression);
+    var KeywordStatement$5 = $S($EXPECT($L108, fail, 'KeywordStatement "throw"'), 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));
@@ -2299,13 +2366,18 @@ var require_parser = __commonJS({
       }
     }
     var LexicalDeclaration$0 = $S($C($EXPECT($L95, fail, 'LexicalDeclaration "let"'), $EXPECT($L96, fail, 'LexicalDeclaration "const"')), __, LexicalBinding, $Q($S(__, $EXPECT($L0, fail, 'LexicalDeclaration ","'), __, LexicalBinding)));
+    var LexicalDeclaration$1 = $T($S($C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, $EXPECT($L113, fail, 'LexicalDeclaration ":="'), AssignmentExpression), function(value) {
+      var bind = value[0];
+      var suffix = value[1];
+      var ws = value[2];
+      var exp = value[4];
+      return ["const ", bind, suffix, ws, "=", exp];
+    });
     function LexicalDeclaration(state) {
-      if (state.verbose)
-        console.log("ENTER:", "LexicalDeclaration");
       if (state.tokenize) {
-        return $TOKEN("LexicalDeclaration", state, LexicalDeclaration$0(state));
+        return $TOKEN("LexicalDeclaration", state, LexicalDeclaration$0(state) || LexicalDeclaration$1(state));
       } else {
-        return LexicalDeclaration$0(state);
+        return LexicalDeclaration$0(state) || LexicalDeclaration$1(state);
       }
     }
     var LexicalBinding$0 = $S(BindingPattern, $E(TypeSuffix), Initializer);
@@ -2418,11 +2490,11 @@ var require_parser = __commonJS({
         return HexLiteral$0(state);
       }
     }
-    var StringLiteral$0 = $T($S($EXPECT($L113, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L113, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""')), function(value) {
+    var StringLiteral$0 = $T($S($EXPECT($L114, fail, 'StringLiteral "\\\\\\"\\\\\\"\\\\\\""'), $TEXT($Q(TripleDoubleStringCharacter)), $EXPECT($L114, 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 "\\\\'"`));
+    var StringLiteral$1 = $S($EXPECT($L115, fail, 'StringLiteral "\\\\\\""'), $TEXT($Q(DoubleStringCharacter)), $EXPECT($L115, fail, 'StringLiteral "\\\\\\""'));
+    var StringLiteral$2 = $S($EXPECT($L116, fail, `StringLiteral "\\\\'"`), $TEXT($Q(SingleStringCharacter)), $EXPECT($L116, fail, `StringLiteral "\\\\'"`));
     function StringLiteral(state) {
       if (state.tokenize) {
         return $TOKEN("StringLiteral", state, StringLiteral$0(state) || StringLiteral$1(state) || StringLiteral$2(state));
@@ -2458,7 +2530,7 @@ var require_parser = __commonJS({
         return TripleDoubleStringCharacter$0(state);
       }
     }
-    var EscapeSequence$0 = $TEXT($S($EXPECT($L116, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R12, fail, "EscapeSequence /./")));
+    var EscapeSequence$0 = $TEXT($S($EXPECT($L117, fail, 'EscapeSequence "\\\\\\\\"'), $EXPECT($R12, fail, "EscapeSequence /./")));
     function EscapeSequence(state) {
       if (state.verbose)
         console.log("ENTER:", "EscapeSequence");
@@ -2507,7 +2579,7 @@ var require_parser = __commonJS({
         return RegularExpressionFlags$0(state);
       }
     }
-    var TemplateLiteral$0 = $S($EXPECT($L117, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L117, fail, 'TemplateLiteral "`"'));
+    var TemplateLiteral$0 = $S($EXPECT($L118, fail, 'TemplateLiteral "`"'), $Q($C(TemplateCharacters, TemplateSubstitution)), $EXPECT($L118, fail, 'TemplateLiteral "`"'));
     function TemplateLiteral(state) {
       if (state.verbose)
         console.log("ENTER:", "TemplateLiteral");
@@ -2517,7 +2589,7 @@ var require_parser = __commonJS({
         return TemplateLiteral$0(state);
       }
     }
-    var TemplateSubstitution$0 = $S($EXPECT($L118, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L15, fail, 'TemplateSubstitution "}"'));
+    var TemplateSubstitution$0 = $S($EXPECT($L119, fail, 'TemplateSubstitution "${"'), __, Expression, __, $EXPECT($L15, fail, 'TemplateSubstitution "}"'));
     function TemplateSubstitution(state) {
       if (state.verbose)
         console.log("ENTER:", "TemplateSubstitution");
@@ -2574,7 +2646,7 @@ var require_parser = __commonJS({
         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 "*/"'));
+    var JSMultiLineComment$0 = $S($EXPECT($L120, fail, 'JSMultiLineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'JSMultiLineComment "*/"')), $EXPECT($R12, fail, "JSMultiLineComment /./")))), $EXPECT($L121, fail, 'JSMultiLineComment "*/"'));
     function JSMultiLineComment(state) {
       if (state.verbose)
         console.log("ENTER:", "JSMultiLineComment");
@@ -2598,7 +2670,7 @@ var require_parser = __commonJS({
         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) {
+    var CoffeeMultiLineComment$0 = $T($S($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"'), $TEXT($Q($S($N($EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), $EXPECT($R12, fail, "CoffeeMultiLineComment /./")))), $EXPECT($L122, fail, 'CoffeeMultiLineComment "###"')), function(value) {
       return ["/*", value[1], "*/"];
     });
     function CoffeeMultiLineComment(state) {
@@ -2610,7 +2682,7 @@ var require_parser = __commonJS({
         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 "*/"'));
+    var InlineComment$0 = $S($EXPECT($L120, fail, 'InlineComment "/*"'), $TEXT($Q($S($N($EXPECT($L121, fail, 'InlineComment "*/"')), $EXPECT($R20, fail, "InlineComment /[^\\r\\n]/")))), $EXPECT($L121, fail, 'InlineComment "*/"'));
     function InlineComment(state) {
       if (state.verbose)
         console.log("ENTER:", "InlineComment");
@@ -2671,16 +2743,184 @@ var require_parser = __commonJS({
         return StatementDelimiter$0(state) || StatementDelimiter$1(state);
       }
     }
-    var TypeDeclaration$0 = $T($S($EXPECT($L122, fail, 'TypeDeclaration "interface"'), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
+    var JSXElement$0 = JSXSelfClosingElement;
+    var JSXElement$1 = $TS($S(JSXOpeningElement, $Q(JSXChildren), __, JSXClosingElement), function($skip, $loc, $0, $1, $2, $3, $4) {
+      if ($1[1] !== $4[2]) {
+        console.log($1, $4, $loc);
+        throw new Error(`mismatched closing tags at ${JSON.stringify($loc)}`);
+      }
+      return $0;
+    });
+    function JSXElement(state) {
+      if (state.tokenize) {
+        return $TOKEN("JSXElement", state, JSXElement$0(state) || JSXElement$1(state));
+      } else {
+        return JSXElement$0(state) || JSXElement$1(state);
+      }
+    }
+    var JSXSelfClosingElement$0 = $S($EXPECT($L13, fail, 'JSXSelfClosingElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L123, fail, 'JSXSelfClosingElement "/>"'));
+    function JSXSelfClosingElement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXSelfClosingElement");
+      if (state.tokenize) {
+        return $TOKEN("JSXSelfClosingElement", state, JSXSelfClosingElement$0(state));
+      } else {
+        return JSXSelfClosingElement$0(state);
+      }
+    }
+    var JSXOpeningElement$0 = $S($EXPECT($L13, fail, 'JSXOpeningElement "<"'), $TEXT(JSXElementName), $E(JSXAttributes), __, $EXPECT($L65, fail, 'JSXOpeningElement ">"'));
+    function JSXOpeningElement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXOpeningElement");
+      if (state.tokenize) {
+        return $TOKEN("JSXOpeningElement", state, JSXOpeningElement$0(state));
+      } else {
+        return JSXOpeningElement$0(state);
+      }
+    }
+    var JSXClosingElement$0 = $S($EXPECT($L124, fail, 'JSXClosingElement "</"'), __, $TEXT(JSXElementName), __, $EXPECT($L65, fail, 'JSXClosingElement ">"'));
+    function JSXClosingElement(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXClosingElement");
+      if (state.tokenize) {
+        return $TOKEN("JSXClosingElement", state, JSXClosingElement$0(state));
+      } else {
+        return JSXClosingElement$0(state);
+      }
+    }
+    var JSXFragment$0 = $S($EXPECT($L125, fail, 'JSXFragment "<>"'), $E(JSXChildren), $EXPECT($L126, fail, 'JSXFragment "</>"'));
+    function JSXFragment(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXFragment");
+      if (state.tokenize) {
+        return $TOKEN("JSXFragment", state, JSXFragment$0(state));
+      } else {
+        return JSXFragment$0(state);
+      }
+    }
+    var JSXElementName$0 = $S(JSXIdentifierName, $C($S($EXPECT($L11, fail, 'JSXElementName ":"'), JSXIdentifierName), $Q($S($EXPECT($L25, fail, 'JSXElementName "."'), JSXIdentifierName))));
+    function JSXElementName(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXElementName");
+      if (state.tokenize) {
+        return $TOKEN("JSXElementName", state, JSXElementName$0(state));
+      } else {
+        return JSXElementName$0(state);
+      }
+    }
+    var JSXIdentifierName$0 = $R$0($EXPECT($R23, fail, "JSXIdentifierName /(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$-])*/"));
+    function JSXIdentifierName(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXIdentifierName");
+      if (state.tokenize) {
+        return $TOKEN("JSXIdentifierName", state, JSXIdentifierName$0(state));
+      } else {
+        return JSXIdentifierName$0(state);
+      }
+    }
+    var JSXAttributes$0 = $Q($S(__, JSXAttribute));
+    function JSXAttributes(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXAttributes");
+      if (state.tokenize) {
+        return $TOKEN("JSXAttributes", state, JSXAttributes$0(state));
+      } else {
+        return JSXAttributes$0(state);
+      }
+    }
+    var JSXAttribute$0 = $S($EXPECT($L10, fail, 'JSXAttribute "{"'), __, $EXPECT($L30, fail, 'JSXAttribute "..."'), __, AssignmentExpression, __, $EXPECT($L15, fail, 'JSXAttribute "}"'));
+    var JSXAttribute$1 = $S(JSXAttributeName, $E(JSXAttributeInitializer));
+    function JSXAttribute(state) {
+      if (state.tokenize) {
+        return $TOKEN("JSXAttribute", state, JSXAttribute$0(state) || JSXAttribute$1(state));
+      } else {
+        return JSXAttribute$0(state) || JSXAttribute$1(state);
+      }
+    }
+    var JSXAttributeName$0 = $S(JSXIdentifierName, $E($S($EXPECT($L11, fail, 'JSXAttributeName ":"'), JSXIdentifierName)));
+    function JSXAttributeName(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXAttributeName");
+      if (state.tokenize) {
+        return $TOKEN("JSXAttributeName", state, JSXAttributeName$0(state));
+      } else {
+        return JSXAttributeName$0(state);
+      }
+    }
+    var JSXAttributeInitializer$0 = $S(__, $EXPECT($L54, fail, 'JSXAttributeInitializer "="'), __, JSXAttributeValue);
+    function JSXAttributeInitializer(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXAttributeInitializer");
+      if (state.tokenize) {
+        return $TOKEN("JSXAttributeInitializer", state, JSXAttributeInitializer$0(state));
+      } else {
+        return JSXAttributeInitializer$0(state);
+      }
+    }
+    var JSXAttributeValue$0 = $R$0($EXPECT($R24, fail, 'JSXAttributeValue /"[^"]*"/'));
+    var JSXAttributeValue$1 = $R$0($EXPECT($R25, fail, "JSXAttributeValue /'[^']*'/"));
+    var JSXAttributeValue$2 = $S($EXPECT($L10, fail, 'JSXAttributeValue "{"'), __, AssignmentExpression, __, $EXPECT($L15, fail, 'JSXAttributeValue "}"'));
+    var JSXAttributeValue$3 = JSXElement;
+    var JSXAttributeValue$4 = JSXFragment;
+    function JSXAttributeValue(state) {
+      if (state.tokenize) {
+        return $TOKEN("JSXAttributeValue", state, JSXAttributeValue$0(state) || JSXAttributeValue$1(state) || JSXAttributeValue$2(state) || JSXAttributeValue$3(state) || JSXAttributeValue$4(state));
+      } else {
+        return JSXAttributeValue$0(state) || JSXAttributeValue$1(state) || JSXAttributeValue$2(state) || JSXAttributeValue$3(state) || JSXAttributeValue$4(state);
+      }
+    }
+    var JSXChildren$0 = $Q($S(__, JSXChild));
+    function JSXChildren(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXChildren");
+      if (state.tokenize) {
+        return $TOKEN("JSXChildren", state, JSXChildren$0(state));
+      } else {
+        return JSXChildren$0(state);
+      }
+    }
+    var JSXChild$0 = JSXText;
+    var JSXChild$1 = JSXElement;
+    var JSXChild$2 = JSXFragment;
+    var JSXChild$3 = $S($EXPECT($L10, fail, 'JSXChild "{"'), $E(JSXChildExpression), __, $EXPECT($L15, fail, 'JSXChild "}"'));
+    function JSXChild(state) {
+      if (state.tokenize) {
+        return $TOKEN("JSXChild", state, JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state));
+      } else {
+        return JSXChild$0(state) || JSXChild$1(state) || JSXChild$2(state) || JSXChild$3(state);
+      }
+    }
+    var JSXText$0 = $R$0($EXPECT($R26, fail, "JSXText /[^{}<>]+/"));
+    function JSXText(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXText");
+      if (state.tokenize) {
+        return $TOKEN("JSXText", state, JSXText$0(state));
+      } else {
+        return JSXText$0(state);
+      }
+    }
+    var JSXChildExpression$0 = $S(__, $E($S($EXPECT($L30, fail, 'JSXChildExpression "..."'), __)), AssignmentExpression);
+    function JSXChildExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "JSXChildExpression");
+      if (state.tokenize) {
+        return $TOKEN("JSXChildExpression", state, JSXChildExpression$0(state));
+      } else {
+        return JSXChildExpression$0(state);
+      }
+    }
+    var TypeDeclaration$0 = $T($S($EXPECT($R27, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L54, fail, 'TypeDeclaration "="'), __, Type), function(value) {
+      return { "ts": true, "children": value };
+    });
+    var TypeDeclaration$1 = $T($S($EXPECT($R28, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $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));
+        return $TOKEN("TypeDeclaration", state, TypeDeclaration$0(state) || TypeDeclaration$1(state));
       } else {
-        return TypeDeclaration$0(state);
+        return TypeDeclaration$0(state) || TypeDeclaration$1(state);
       }
     }
     var InterfaceBlock$0 = $S(__, $EXPECT($L10, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L15, fail, 'InterfaceBlock "}"'));
@@ -2717,7 +2957,7 @@ var require_parser = __commonJS({
         return NestedInterfaceProperty$0(state);
       }
     }
-    var TypeSuffix$0 = $T($S(__, $EXPECT($L11, fail, 'TypeSuffix ":"'), Type), function(value) {
+    var TypeSuffix$0 = $T($S($E($EXPECT($L3, fail, 'TypeSuffix "?"')), __, $EXPECT($L11, fail, 'TypeSuffix ":"'), Type), function(value) {
       return { "ts": true, "children": value };
     });
     function TypeSuffix(state) {
@@ -2729,17 +2969,84 @@ var require_parser = __commonJS({
         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"'));
+    var Type$0 = TypeConditional;
     function Type(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Type");
+      if (state.tokenize) {
+        return $TOKEN("Type", state, Type$0(state));
+      } else {
+        return Type$0(state);
+      }
+    }
+    var TypeBinary$0 = $S(TypeUnary, $Q($S(__, TypeBinaryOp, TypeUnary)));
+    function TypeBinary(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TypeBinary");
       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));
+        return $TOKEN("TypeBinary", state, TypeBinary$0(state));
       } else {
-        return Type$0(state) || Type$1(state) || Type$2(state) || Type$3(state) || Type$4(state) || Type$5(state);
+        return TypeBinary$0(state);
+      }
+    }
+    var TypeUnary$0 = $S($Q(TypeUnaryOp), TypePrimary);
+    function TypeUnary(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TypeUnary");
+      if (state.tokenize) {
+        return $TOKEN("TypeUnary", state, TypeUnary$0(state));
+      } else {
+        return TypeUnary$0(state);
+      }
+    }
+    var TypeUnaryOp$0 = $S(__, $EXPECT($L83, fail, 'TypeUnaryOp "typeof"'), $R$0($EXPECT($R29, fail, "TypeUnaryOp /(?!\\p{ID_Continue})/")));
+    var TypeUnaryOp$1 = $S(__, $EXPECT($L127, fail, 'TypeUnaryOp "infer"'), $R$0($EXPECT($R29, fail, "TypeUnaryOp /(?!\\p{ID_Continue})/")));
+    function TypeUnaryOp(state) {
+      if (state.tokenize) {
+        return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state));
+      } else {
+        return TypeUnaryOp$0(state) || TypeUnaryOp$1(state);
+      }
+    }
+    var TypePrimary$0 = InterfaceBlock;
+    var TypePrimary$1 = $S(__, $EXPECT($L1, fail, 'TypePrimary "("'), Type, __, $EXPECT($L2, fail, 'TypePrimary ")"'));
+    var TypePrimary$2 = $S($Q(_), FunctionType);
+    var TypePrimary$3 = $S($Q(_), IdentifierName, $Q($S($EXPECT($L25, fail, 'TypePrimary "."'), IdentifierName)), $E(TypeArguments), $Q($EXPECT($L128, fail, 'TypePrimary "[]"')));
+    var TypePrimary$4 = $S($Q(_), TypeLiteral);
+    function TypePrimary(state) {
+      if (state.tokenize) {
+        return $TOKEN("TypePrimary", state, TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state));
+      } else {
+        return TypePrimary$0(state) || TypePrimary$1(state) || TypePrimary$2(state) || TypePrimary$3(state) || TypePrimary$4(state);
+      }
+    }
+    var TypeConditional$0 = $S(TypeBinary, $E($S(__, $EXPECT($L14, fail, 'TypeConditional "extends"'), Type, __, $EXPECT($L3, fail, 'TypeConditional "?"'), Type, __, $EXPECT($L11, fail, 'TypeConditional ":"'), Type)));
+    function TypeConditional(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TypeConditional");
+      if (state.tokenize) {
+        return $TOKEN("TypeConditional", state, TypeConditional$0(state));
+      } else {
+        return TypeConditional$0(state);
+      }
+    }
+    var TypeLiteral$0 = Literal;
+    var TypeLiteral$1 = $EXPECT($L82, fail, 'TypeLiteral "void"');
+    var TypeLiteral$2 = $EXPECT($L128, fail, 'TypeLiteral "[]"');
+    function TypeLiteral(state) {
+      if (state.tokenize) {
+        return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
+      } else {
+        return TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state);
+      }
+    }
+    var TypeBinaryOp$0 = $EXPECT($L80, fail, 'TypeBinaryOp "|"');
+    var TypeBinaryOp$1 = $EXPECT($L78, fail, 'TypeBinaryOp "&"');
+    function TypeBinaryOp(state) {
+      if (state.tokenize) {
+        return $TOKEN("TypeBinaryOp", state, TypeBinaryOp$0(state) || TypeBinaryOp$1(state));
+      } else {
+        return TypeBinaryOp$0(state) || TypeBinaryOp$1(state);
       }
     }
     var FunctionType$0 = $S(Parameters, __, $EXPECT($L9, fail, 'FunctionType "=>"'), Type);
@@ -2762,7 +3069,52 @@ var require_parser = __commonJS({
         return TypeArguments$0(state);
       }
     }
-    var Shebang$0 = $R$0($EXPECT($R23, fail, "Shebang /#![^\\r\\n]*/"));
+    var TypeParameters$0 = $S(__, $EXPECT($L13, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L65, fail, 'TypeParameters ">"'));
+    function TypeParameters(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TypeParameters");
+      if (state.tokenize) {
+        return $TOKEN("TypeParameters", state, TypeParameters$0(state));
+      } else {
+        return TypeParameters$0(state);
+      }
+    }
+    var TypeParameter$0 = $S(__, Identifier, $E(TypeConstraint), TypeParameterDelimiter);
+    function TypeParameter(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TypeParameter");
+      if (state.tokenize) {
+        return $TOKEN("TypeParameter", state, TypeParameter$0(state));
+      } else {
+        return TypeParameter$0(state);
+      }
+    }
+    var TypeConstraint$0 = $S(__, $EXPECT($L14, fail, 'TypeConstraint "extends"'), Type);
+    function TypeConstraint(state) {
+      if (state.verbose)
+        console.log("ENTER:", "TypeConstraint");
+      if (state.tokenize) {
+        return $TOKEN("TypeConstraint", state, TypeConstraint$0(state));
+      } else {
+        return TypeConstraint$0(state);
+      }
+    }
+    var TypeParameterDelimiter$0 = $S($Q(_), $EXPECT($L0, fail, 'TypeParameterDelimiter ","'));
+    var TypeParameterDelimiter$1 = $Y($S($Q(_), $EXPECT($L65, fail, 'TypeParameterDelimiter ">"')));
+    var TypeParameterDelimiter$2 = $T($Y($S(__, $EXPECT($L65, fail, 'TypeParameterDelimiter ">"'))), function(value) {
+      return ",";
+    });
+    var TypeParameterDelimiter$3 = $T($Y(EOS), function(value) {
+      return ",";
+    });
+    function TypeParameterDelimiter(state) {
+      if (state.tokenize) {
+        return $TOKEN("TypeParameterDelimiter", state, TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state));
+      } else {
+        return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
+      }
+    }
+    var Shebang$0 = $R$0($EXPECT($R30, fail, "Shebang /#![^\\r\\n]*/"));
     function Shebang(state) {
       if (state.verbose)
         console.log("ENTER:", "Shebang");
@@ -2772,7 +3124,7 @@ var require_parser = __commonJS({
         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) {
+    var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R31, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
       return $0.map((p) => p.join(""));
     });
     function DirectivePrologue(state) {
@@ -2794,7 +3146,7 @@ var require_parser = __commonJS({
         return EOS$0(state);
       }
     }
-    var EOL$0 = $R$0($EXPECT($R25, fail, "EOL /\\r\\n|\\n|\\r|$/"));
+    var EOL$0 = $R$0($EXPECT($R32, fail, "EOL /\\r\\n|\\n|\\r|$/"));
     function EOL(state) {
       if (state.verbose)
         console.log("ENTER:", "EOL");
@@ -2804,7 +3156,7 @@ var require_parser = __commonJS({
         return EOL$0(state);
       }
     }
-    var EOF$0 = $R$0($EXPECT($R26, fail, "EOF /$/"));
+    var EOF$0 = $R$0($EXPECT($R33, fail, "EOF /$/"));
     function EOF(state) {
       if (state.verbose)
         console.log("ENTER:", "EOF");
@@ -2942,7 +3294,7 @@ var require_parser = __commonJS({
         return Init$0(state);
       }
     }
-    var Indent$0 = $TV($Q($C($EXPECT($L124, fail, 'Indent "  "'), $EXPECT($L125, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
+    var Indent$0 = $TV($Q($C($EXPECT($L129, fail, 'Indent "  "'), $EXPECT($L130, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
       return $1.length;
     });
     function Indent(state) {
@@ -3040,7 +3392,6 @@ var require_generate = __commonJS({
           return "";
         }
         if (!node.children) {
-          debugger;
           throw new Error("Unknown node", JSON.stringify(node));
         }
         return node.children.map(function(child) {