@danielx/civet 0.3.4 → 0.3.6

package/README.md

@@ -135,6 +135,10 @@ Things Added that CoffeeScript didn't
 ---
 
 - TypeScript Types
+  - Function annotaions
+  - `namespace`
+  - `interface`
+  - TypeParameters
 - JS Compatability
   - `var`, `let`, `const`
   - JS Comment Syntax `//` and `/* */`
@@ -147,7 +151,7 @@ Things Added that CoffeeScript didn't
 - Convenience for ES6+ Features
   - `<` as `extends` shorthand
   - `@#id` -> `this.#id` shorthand for private identifiers
-  - `import` shorthand `x from "./x"` -> `import x from "./x"`
+  - `import` shorthand `x from ./x` -> `import x from "./x"`
 - ClassStaticBlock
 - `get`/`set` method definitions
 - Private identifiers `#id`

package/dist/browser.js

@@ -498,6 +498,8 @@ var Civet = (() => {
         PropertyDefinition,
         PropertyName,
         MethodDefinition,
+        MethodModifier,
+        MethodSignature,
         ClassElementName,
         PrivateIdentifier,
         GeneratorMethod,
@@ -624,11 +626,19 @@ var Civet = (() => {
         JSXText,
         JSXChildExpression,
         TypeDeclaration,
+        TypeDeclarationModifier,
+        TypeDeclarationRest,
+        TypeKeyword,
+        Interface,
+        Namespace,
         InterfaceBlock,
         NestedInterfaceProperties,
         NestedInterfaceProperty,
         InterfaceProperty,
         InterfacePropertyDelimiter,
+        NamespaceBlock,
+        NestedTypeDeclarations,
+        NestedTypeDeclaration,
         TypeIndexSignature,
         TypeIndex,
         TypeSuffix,
@@ -800,13 +810,17 @@ var Civet = (() => {
       var $L125 = $L("</");
       var $L126 = $L("<>");
       var $L127 = $L("</>");
-      var $L128 = $L("readonly");
-      var $L129 = $L("asserts");
-      var $L130 = $L("keyof");
-      var $L131 = $L("infer");
-      var $L132 = $L("[]");
-      var $L133 = $L("  ");
-      var $L134 = $L("	");
+      var $L128 = $L("declare");
+      var $L129 = $L("type");
+      var $L130 = $L("interface");
+      var $L131 = $L("namespace");
+      var $L132 = $L("readonly");
+      var $L133 = $L("asserts");
+      var $L134 = $L("keyof");
+      var $L135 = $L("infer");
+      var $L136 = $L("[]");
+      var $L137 = $L("  ");
+      var $L138 = $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("[!~+-]", "suy"));
@@ -837,14 +851,12 @@ var Civet = (() => {
       var $R27 = $R(new RegExp('"[^"]*"', "suy"));
       var $R28 = $R(new RegExp("'[^']*'", "suy"));
       var $R29 = $R(new RegExp("[^{}<>]+", "suy"));
-      var $R30 = $R(new RegExp("type(?!\\p{ID_Continue})", "suy"));
-      var $R31 = $R(new RegExp("interface(?!\\p{ID_Continue})", "suy"));
-      var $R32 = $R(new RegExp("[+-]?", "suy"));
-      var $R33 = $R(new RegExp("[+-]", "suy"));
-      var $R34 = $R(new RegExp("#![^\\r\\n]*", "suy"));
-      var $R35 = $R(new RegExp("[\\t ]*", "suy"));
-      var $R36 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
-      var $R37 = $R(new RegExp("$", "suy"));
+      var $R30 = $R(new RegExp("[+-]?", "suy"));
+      var $R31 = $R(new RegExp("[+-]", "suy"));
+      var $R32 = $R(new RegExp("#![^\\r\\n]*", "suy"));
+      var $R33 = $R(new RegExp("[\\t ]*", "suy"));
+      var $R34 = $R(new RegExp("\\r\\n|\\n|\\r|$", "suy"));
+      var $R35 = $R(new RegExp("$", "suy"));
       var Program$0 = $S(Init, __, $Q(TopLevelStatement), __);
       function Program(state) {
         if (state.verbose)
@@ -1397,7 +1409,7 @@ var Civet = (() => {
           return MetaProperty$0(state) || MetaProperty$1(state);
         }
       }
-      var Parameters$0 = $S($EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
+      var Parameters$0 = $S($E(TypeParameters), $EXPECT($L1, fail, 'Parameters "("'), $Q(ParameterElement), __, $EXPECT($L2, fail, 'Parameters ")"'));
       var Parameters$1 = $T($EXPECT($L32, fail, 'Parameters ""'), function(value) {
         return "()";
       });
@@ -1898,6 +1910,26 @@ var Civet = (() => {
           return MethodDefinition$0(state) || MethodDefinition$1(state) || MethodDefinition$2(state) || MethodDefinition$3(state) || MethodDefinition$4(state) || MethodDefinition$5(state);
         }
       }
+      var MethodModifier$0 = $S($C($EXPECT($L39, fail, 'MethodModifier "get"'), $EXPECT($L40, fail, 'MethodModifier "set"')), NonIdContinue, $Q(TrailingComment));
+      function MethodModifier(state) {
+        if (state.verbose)
+          console.log("ENTER:", "MethodModifier");
+        if (state.tokenize) {
+          return $TOKEN("MethodModifier", state, MethodModifier$0(state));
+        } else {
+          return MethodModifier$0(state);
+        }
+      }
+      var MethodSignature$0 = $S($E(MethodModifier), ClassElementName, $Q(_), Parameters);
+      function MethodSignature(state) {
+        if (state.verbose)
+          console.log("ENTER:", "MethodSignature");
+        if (state.tokenize) {
+          return $TOKEN("MethodSignature", state, MethodSignature$0(state));
+        } else {
+          return MethodSignature$0(state);
+        }
+      }
       var ClassElementName$0 = PropertyName;
       var ClassElementName$1 = PrivateIdentifier;
       function ClassElementName(state) {
@@ -3312,17 +3344,65 @@ var Civet = (() => {
           return JSXChildExpression$0(state);
         }
       }
-      var TypeDeclaration$0 = $T($S($EXPECT($R30, fail, "TypeDeclaration /type(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclaration "="'), __, Type), function(value) {
-        return { "ts": true, "children": value };
-      });
-      var TypeDeclaration$1 = $T($S($EXPECT($R31, fail, "TypeDeclaration /interface(?!\\p{ID_Continue})/"), $Q(TrailingComment), IdentifierName, InterfaceBlock), function(value) {
+      var TypeDeclaration$0 = $T($S($Q($S(TypeDeclarationModifier, $Q(TrailingComment))), TypeDeclarationRest), function(value) {
         return { "ts": true, "children": value };
       });
       function TypeDeclaration(state) {
+        if (state.verbose)
+          console.log("ENTER:", "TypeDeclaration");
+        if (state.tokenize) {
+          return $TOKEN("TypeDeclaration", state, TypeDeclaration$0(state));
+        } else {
+          return TypeDeclaration$0(state);
+        }
+      }
+      var TypeDeclarationModifier$0 = $S($EXPECT($L128, fail, 'TypeDeclarationModifier "declare"'), NonIdContinue);
+      var TypeDeclarationModifier$1 = $S($EXPECT($L113, fail, 'TypeDeclarationModifier "export"'), NonIdContinue);
+      function TypeDeclarationModifier(state) {
+        if (state.tokenize) {
+          return $TOKEN("TypeDeclarationModifier", state, TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state));
+        } else {
+          return TypeDeclarationModifier$0(state) || TypeDeclarationModifier$1(state);
+        }
+      }
+      var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, $EXPECT($L56, fail, 'TypeDeclarationRest "="'), __, Type);
+      var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, InterfaceBlock);
+      var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, NamespaceBlock);
+      function TypeDeclarationRest(state) {
+        if (state.tokenize) {
+          return $TOKEN("TypeDeclarationRest", state, TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state));
+        } else {
+          return TypeDeclarationRest$0(state) || TypeDeclarationRest$1(state) || TypeDeclarationRest$2(state);
+        }
+      }
+      var TypeKeyword$0 = $S($EXPECT($L129, fail, 'TypeKeyword "type"'), NonIdContinue);
+      function TypeKeyword(state) {
+        if (state.verbose)
+          console.log("ENTER:", "TypeKeyword");
+        if (state.tokenize) {
+          return $TOKEN("TypeKeyword", state, TypeKeyword$0(state));
+        } else {
+          return TypeKeyword$0(state);
+        }
+      }
+      var Interface$0 = $S($EXPECT($L130, fail, 'Interface "interface"'), NonIdContinue);
+      function Interface(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Interface");
+        if (state.tokenize) {
+          return $TOKEN("Interface", state, Interface$0(state));
+        } else {
+          return Interface$0(state);
+        }
+      }
+      var Namespace$0 = $S($EXPECT($L131, fail, 'Namespace "namespace"'), NonIdContinue);
+      function Namespace(state) {
+        if (state.verbose)
+          console.log("ENTER:", "Namespace");
         if (state.tokenize) {
-          return $TOKEN("TypeDeclaration", state, TypeDeclaration$0(state) || TypeDeclaration$1(state));
+          return $TOKEN("Namespace", state, Namespace$0(state));
         } else {
-          return TypeDeclaration$0(state) || TypeDeclaration$1(state);
+          return Namespace$0(state);
         }
       }
       var InterfaceBlock$0 = $S(__, $EXPECT($L12, fail, 'InterfaceBlock "{"'), EOS, NestedInterfaceProperties, __, $EXPECT($L13, fail, 'InterfaceBlock "}"'));
@@ -3361,13 +3441,12 @@ var Civet = (() => {
         }
       }
       var InterfaceProperty$0 = $S($C(TypeIndexSignature, PropertyName), TypeSuffix, InterfacePropertyDelimiter);
+      var InterfaceProperty$1 = $S(MethodSignature, $E(TypeSuffix));
       function InterfaceProperty(state) {
-        if (state.verbose)
-          console.log("ENTER:", "InterfaceProperty");
         if (state.tokenize) {
-          return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state));
+          return $TOKEN("InterfaceProperty", state, InterfaceProperty$0(state) || InterfaceProperty$1(state));
         } else {
-          return InterfaceProperty$0(state);
+          return InterfaceProperty$0(state) || InterfaceProperty$1(state);
         }
       }
       var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L88, fail, 'InterfacePropertyDelimiter ";"'));
@@ -3385,7 +3464,42 @@ var Civet = (() => {
           return InterfacePropertyDelimiter$0(state) || InterfacePropertyDelimiter$1(state) || InterfacePropertyDelimiter$2(state) || InterfacePropertyDelimiter$3(state);
         }
       }
-      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R32, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L128, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L26, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L27, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R33, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
+      var NamespaceBlock$0 = $S(__, $EXPECT($L12, fail, 'NamespaceBlock "{"'), EOS, NestedTypeDeclarations, __, $EXPECT($L13, fail, 'NamespaceBlock "}"'));
+      var NamespaceBlock$1 = $S(__, $EXPECT($L12, fail, 'NamespaceBlock "{"'), $Q($S(__, TypeDeclaration, InterfacePropertyDelimiter)), __, $EXPECT($L13, fail, 'NamespaceBlock "}"'));
+      var NamespaceBlock$2 = $S(InsertOpenBrace, EOS, NestedTypeDeclarations, InsertNewline, InsertIndent, InsertCloseBrace);
+      function NamespaceBlock(state) {
+        if (state.tokenize) {
+          return $TOKEN("NamespaceBlock", state, NamespaceBlock$0(state) || NamespaceBlock$1(state) || NamespaceBlock$2(state));
+        } else {
+          return NamespaceBlock$0(state) || NamespaceBlock$1(state) || NamespaceBlock$2(state);
+        }
+      }
+      var NestedTypeDeclarations$0 = $TS($S(PushIndent, $Q(NestedTypeDeclaration), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+        var decs = $2;
+        if (decs.length)
+          return decs;
+        return $skip;
+      });
+      function NestedTypeDeclarations(state) {
+        if (state.verbose)
+          console.log("ENTER:", "NestedTypeDeclarations");
+        if (state.tokenize) {
+          return $TOKEN("NestedTypeDeclarations", state, NestedTypeDeclarations$0(state));
+        } else {
+          return NestedTypeDeclarations$0(state);
+        }
+      }
+      var NestedTypeDeclaration$0 = $S(Nested, TypeDeclaration, InterfacePropertyDelimiter);
+      function NestedTypeDeclaration(state) {
+        if (state.verbose)
+          console.log("ENTER:", "NestedTypeDeclaration");
+        if (state.tokenize) {
+          return $TOKEN("NestedTypeDeclaration", state, NestedTypeDeclaration$0(state));
+        } else {
+          return NestedTypeDeclaration$0(state);
+        }
+      }
+      var TypeIndexSignature$0 = $S($E($S($R$0($EXPECT($R30, fail, "TypeIndexSignature /[+-]?/")), $EXPECT($L132, fail, 'TypeIndexSignature "readonly"'), __)), $EXPECT($L26, fail, 'TypeIndexSignature "["'), TypeIndex, $EXPECT($L27, fail, 'TypeIndexSignature "]"'), $E($S(__, $R$0($EXPECT($R31, fail, "TypeIndexSignature /[+-]/")), $EXPECT($L3, fail, 'TypeIndexSignature "?"'))));
       function TypeIndexSignature(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeIndexSignature");
@@ -3416,7 +3530,7 @@ var Civet = (() => {
           return TypeSuffix$0(state);
         }
       }
-      var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L129, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
+      var ReturnTypeSuffix$0 = $T($S(__, $EXPECT($L14, fail, 'ReturnTypeSuffix ":"'), $E($S(__, $EXPECT($L133, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function(value) {
         return { "ts": true, "children": value };
       });
       function ReturnTypeSuffix(state) {
@@ -3478,9 +3592,9 @@ var Civet = (() => {
           return TypeUnarySuffix$0(state);
         }
       }
-      var TypeUnaryOp$0 = $EXPECT($L130, fail, 'TypeUnaryOp "keyof"');
+      var TypeUnaryOp$0 = $EXPECT($L134, fail, 'TypeUnaryOp "keyof"');
       var TypeUnaryOp$1 = $EXPECT($L85, fail, 'TypeUnaryOp "typeof"');
-      var TypeUnaryOp$2 = $EXPECT($L131, fail, 'TypeUnaryOp "infer"');
+      var TypeUnaryOp$2 = $EXPECT($L135, fail, 'TypeUnaryOp "infer"');
       function TypeUnaryOp(state) {
         if (state.tokenize) {
           return $TOKEN("TypeUnaryOp", state, TypeUnaryOp$0(state) || TypeUnaryOp$1(state) || TypeUnaryOp$2(state));
@@ -3522,7 +3636,7 @@ var Civet = (() => {
       }
       var TypeLiteral$0 = Literal;
       var TypeLiteral$1 = $EXPECT($L84, fail, 'TypeLiteral "void"');
-      var TypeLiteral$2 = $EXPECT($L132, fail, 'TypeLiteral "[]"');
+      var TypeLiteral$2 = $EXPECT($L136, fail, 'TypeLiteral "[]"');
       function TypeLiteral(state) {
         if (state.tokenize) {
           return $TOKEN("TypeLiteral", state, TypeLiteral$0(state) || TypeLiteral$1(state) || TypeLiteral$2(state));
@@ -3559,7 +3673,9 @@ var Civet = (() => {
           return TypeArguments$0(state);
         }
       }
-      var TypeParameters$0 = $S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"'));
+      var TypeParameters$0 = $TS($S(__, $EXPECT($L16, fail, 'TypeParameters "<"'), __, Type, $Q($S(__, $EXPECT($L0, fail, 'TypeParameters ","'), __, Type)), $E($S(__, $EXPECT($L0, fail, 'TypeParameters ","'))), __, $EXPECT($L67, fail, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+        return { ts: true, children: $0 };
+      });
       function TypeParameters(state) {
         if (state.verbose)
           console.log("ENTER:", "TypeParameters");
@@ -3604,7 +3720,7 @@ var Civet = (() => {
           return TypeParameterDelimiter$0(state) || TypeParameterDelimiter$1(state) || TypeParameterDelimiter$2(state) || TypeParameterDelimiter$3(state);
         }
       }
-      var Shebang$0 = $R$0($EXPECT($R34, fail, "Shebang /#![^\\r\\n]*/"));
+      var Shebang$0 = $R$0($EXPECT($R32, fail, "Shebang /#![^\\r\\n]*/"));
       function Shebang(state) {
         if (state.verbose)
           console.log("ENTER:", "Shebang");
@@ -3614,7 +3730,7 @@ var Civet = (() => {
           return Shebang$0(state);
         }
       }
-      var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R35, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
+      var DirectivePrologue$0 = $TV($Q($S($TEXT($EXPECT($R33, fail, "DirectivePrologue /[\\t ]*/")), $TEXT(StringLiteral), $TEXT(StatementDelimiter), $TEXT(EOS))), function($skip, $loc, $0, $1) {
         return $0.map((p) => p.join(""));
       });
       function DirectivePrologue(state) {
@@ -3636,7 +3752,7 @@ var Civet = (() => {
           return EOS$0(state);
         }
       }
-      var EOL$0 = $R$0($EXPECT($R36, fail, "EOL /\\r\\n|\\n|\\r|$/"));
+      var EOL$0 = $R$0($EXPECT($R34, fail, "EOL /\\r\\n|\\n|\\r|$/"));
       function EOL(state) {
         if (state.verbose)
           console.log("ENTER:", "EOL");
@@ -3646,7 +3762,7 @@ var Civet = (() => {
           return EOL$0(state);
         }
       }
-      var EOF$0 = $R$0($EXPECT($R37, fail, "EOF /$/"));
+      var EOF$0 = $R$0($EXPECT($R35, fail, "EOF /$/"));
       function EOF(state) {
         if (state.verbose)
           console.log("ENTER:", "EOF");
@@ -3804,7 +3920,7 @@ var Civet = (() => {
           return Init$0(state);
         }
       }
-      var Indent$0 = $TV($Q($C($EXPECT($L133, fail, 'Indent "  "'), $EXPECT($L134, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
+      var Indent$0 = $TV($Q($C($EXPECT($L137, fail, 'Indent "  "'), $EXPECT($L138, fail, 'Indent "\\\\t"'))), function($skip, $loc, $0, $1) {
         return $1.length;
       });
       function Indent(state) {