@danielx/civet 0.1.1 → 0.2.0

package/README.md

@@ -7,6 +7,11 @@ A new CoffeeScript. Much closer to ES2015+ (for better or worse).
 
 Also TypeScript, the sky is the limit.
 
+```bash
+npm install -g @danielx/civet
+civet < source.civet > output.ts
+```
+
 ![image](https://user-images.githubusercontent.com/18894/184558519-b675a903-7490-43ba-883e-0d8addacd4b9.png)
 
 Code Sample
@@ -55,9 +60,11 @@ Things Kept from CoffeeScript
 - OptionalChain shorthand for index and function application `a?[b]` -> `a?.[b]`, `a?(b)` -> `a?.(b)`
 - `@` -> `this`
 - `@id` -> `this.id`
+- JSX 😿
 - TODO
-  - `"""` Strings (for compatibility with existing .coffee code)
-  - `///` Heregexp
+  - [ ] `"""` Strings (for compatibility with existing .coffee code)
+  - [ ] `///` Heregexp
+  - [ ] Chained comparisons
 
 Things Removed from CoffeeScript
 ---

package/dist/browser.js

@@ -582,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,
@@ -733,10 +760,14 @@ var Civet = (() => {
       var $L120 = $L("/*");
       var $L121 = $L("*/");
       var $L122 = $L("###");
-      var $L123 = $L("interface");
-      var $L124 = $L("[]");
-      var $L125 = $L("  ");
-      var $L126 = $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"));
@@ -760,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)
@@ -974,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;
@@ -2165,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));
@@ -2704,16 +2744,184 @@ var Civet = (() => {
           return StatementDelimiter$0(state) || StatementDelimiter$1(state);
         }
       }
-      var TypeDeclaration$0 = $T($S($EXPECT($L123, 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 "}"'));
@@ -2750,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) {
@@ -2762,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($L124, 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("TypeBinary", state, TypeBinary$0(state));
+        } else {
+          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("Type", state, Type$0(state) || Type$1(state) || Type$2(state) || Type$3(state) || Type$4(state) || Type$5(state));
+          return $TOKEN("TypeConditional", state, TypeConditional$0(state));
         } else {
-          return Type$0(state) || Type$1(state) || Type$2(state) || Type$3(state) || Type$4(state) || Type$5(state);
+          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);
@@ -2795,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");
@@ -2805,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) {
@@ -2827,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");
@@ -2837,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");
@@ -2975,7 +3295,7 @@ var Civet = (() => {
           return Init$0(state);
         }
       }
-      var Indent$0 = $TV($Q($C($EXPECT($L125, fail, 'Indent "  "'), $EXPECT($L126, 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) {