@danielx/civet 0.1.0 → 0.2.1

package/dist/browser.js

@@ -410,6 +410,8 @@ var Civet = (() => {
         Expression,
         Arguments,
         ArgumentList,
+        NestedArgumentList,
+        NestedArgument,
         CommaExpression,
         BinaryOpExpression,
         UnaryExpression,
@@ -580,14 +582,41 @@ var Civet = (() => {
         _,
         __,
         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,
@@ -721,19 +750,24 @@ var Civet = (() => {
       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"));
@@ -757,10 +791,17 @@ var Civet = (() => {
       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)
@@ -791,7 +832,7 @@ var Civet = (() => {
           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");
@@ -801,14 +842,38 @@ var Civet = (() => {
           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);
@@ -947,11 +1012,13 @@ var Civet = (() => {
       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;
@@ -2138,9 +2205,9 @@ var Civet = (() => {
       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));
@@ -2300,13 +2367,18 @@ var Civet = (() => {
         }
       }
       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);
@@ -2419,11 +2491,11 @@ var Civet = (() => {
           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));
@@ -2459,7 +2531,7 @@ var Civet = (() => {
           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");
@@ -2508,7 +2580,7 @@ var Civet = (() => {
           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");
@@ -2518,7 +2590,7 @@ var Civet = (() => {
           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");
@@ -2575,7 +2647,7 @@ var Civet = (() => {
           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");
@@ -2599,7 +2671,7 @@ var Civet = (() => {
           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) {
@@ -2611,7 +2683,7 @@ var Civet = (() => {
           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");
@@ -2672,16 +2744,184 @@ var Civet = (() => {
           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 "}"'));
@@ -2718,7 +2958,7 @@ var Civet = (() => {
           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) {
@@ -2730,17 +2970,84 @@ var Civet = (() => {
           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);
@@ -2763,7 +3070,52 @@ var Civet = (() => {
           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");
@@ -2773,7 +3125,7 @@ var Civet = (() => {
           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) {
@@ -2795,7 +3147,7 @@ var Civet = (() => {
           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");
@@ -2805,7 +3157,7 @@ var Civet = (() => {
           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");
@@ -2943,7 +3295,7 @@ var Civet = (() => {
           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) {
@@ -3041,7 +3393,6 @@ var Civet = (() => {
             return "";
           }
           if (!node.children) {
-            debugger;
             throw new Error("Unknown node", JSON.stringify(node));
           }
           return node.children.map(function(child) {