@danielx/civet 0.1.1 → 0.2.0

package/dist/main.js

@@ -581,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,
@@ -732,10 +759,14 @@ var require_parser = __commonJS({
     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"));
@@ -759,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)
@@ -973,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;
@@ -2164,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));
@@ -2703,16 +2743,184 @@ var require_parser = __commonJS({
         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 "}"'));
@@ -2749,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) {
@@ -2761,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($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);
@@ -2794,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");
@@ -2804,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) {
@@ -2826,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");
@@ -2836,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");
@@ -2974,7 +3294,7 @@ var require_parser = __commonJS({
         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) {

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@danielx/civet",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "bin": {
     "civet": "dist/civet"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "register.js",
+    "register.mjs"
   ],
   "scripts": {
     "build": "bash ./build/build.sh",

package/register.js

@@ -0,0 +1,12 @@
+if (require.extensions) {
+  const fs = require("fs");
+  const { compile } = require("./");
+
+  require.extensions[".civet"] = function (module, filename) {
+    const js = compile(fs.readFileSync(filename, 'utf8'), {
+      js: true
+    });
+    module._compile(js, filename);
+    return;
+  };
+}

package/register.mjs

@@ -0,0 +1,40 @@
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+
+import { compile } from "./dist/main.js";
+
+const baseURL = pathToFileURL(process.cwd() + '/').href;
+
+const extensionsRegex = /\.civet$/;
+
+export async function resolve(specifier, context, defaultResolve) {
+  const { parentURL = baseURL } = context;
+
+  if (extensionsRegex.test(specifier)) {
+    return {
+      format: "civet",
+      url: new URL(specifier, parentURL).href,
+    };
+  }
+
+  // Let Node.js handle all other specifiers.
+  return defaultResolve(specifier, context, defaultResolve);
+}
+
+export async function load(url, context, defaultLoad) {
+  if (extensionsRegex.test(url)) {
+    const { source: rawSource } = await defaultLoad(url, { format: "civet" });
+
+    return {
+      format: "module",
+      source: compile(rawSource.toString(), { js: true }),
+    };
+  }
+
+  // Let Node.js handle all other URLs.
+  return defaultLoad(url, context, defaultLoad);
+}
+
+// Also transform CommonJS files.
+const require = createRequire(import.meta.url);
+require("./register.js")