@danielx/civet 0.2.7 → 0.2.10

package/dist/main.js

@@ -420,6 +420,7 @@ var require_parser = __commonJS({
       AssignmentExpressionRest,
       YieldExpression,
       ArrowFunction,
+      FatArrow,
       ConciseBody,
       ConditionalExpression,
       ShortCircuitExpression,
@@ -497,6 +498,8 @@ var require_parser = __commonJS({
       BinaryOp,
       UnaryOp,
       ModuleItem,
+      StatementListItem,
+      PostfixConditional,
       Statement,
       EmptyStatement,
       BlockStatement,
@@ -534,6 +537,8 @@ var require_parser = __commonJS({
       ModuleSpecifier,
       ImportedBinding,
       ExportDeclaration,
+      As,
+      Export,
       ExportFromClause,
       NamedExports,
       ExportSpecifier,
@@ -725,10 +730,10 @@ var require_parser = __commonJS({
     var $L82 = $L("delete");
     var $L83 = $L("void");
     var $L84 = $L("typeof");
-    var $L85 = $L(";");
-    var $L86 = $L("if");
-    var $L87 = $L("else");
-    var $L88 = $L("unless");
+    var $L85 = $L("if");
+    var $L86 = $L("unless");
+    var $L87 = $L(";");
+    var $L88 = $L("else");
     var $L89 = $L("loop");
     var $L90 = $L("do");
     var $L91 = $L("while");
@@ -950,7 +955,7 @@ var require_parser = __commonJS({
     }
     var AssignmentExpressionRest$0 = YieldExpression;
     var AssignmentExpressionRest$1 = $S($E($S($EXPECT($L7, fail, 'AssignmentExpressionRest "async"'), __)), ArrowFunction);
-    var AssignmentExpressionRest$2 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), $C($S($Q(_), Expression), $S(__, Expression)));
+    var AssignmentExpressionRest$2 = $S($P($S(__, LeftHandSideExpression, __, AssignmentOp)), Expression);
     var AssignmentExpressionRest$3 = ConditionalExpression;
     function AssignmentExpressionRest(state) {
       if (state.tokenize) {
@@ -970,7 +975,7 @@ var require_parser = __commonJS({
       }
     }
     var ArrowFunction$0 = ThinArrowFunction;
-    var ArrowFunction$1 = $S($C(BindingIdentifier, Parameters), $E(ReturnTypeSuffix), __, $EXPECT($L10, fail, 'ArrowFunction "=>"'), ConciseBody);
+    var ArrowFunction$1 = $S(Parameters, $E(ReturnTypeSuffix), FatArrow, ConciseBody);
     function ArrowFunction(state) {
       if (state.tokenize) {
         return $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
@@ -978,8 +983,23 @@ var require_parser = __commonJS({
         return ArrowFunction$0(state) || ArrowFunction$1(state);
       }
     }
-    var ConciseBody$0 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
-    var ConciseBody$1 = $S(EOS, SingleNestedBlockExpression);
+    var FatArrow$0 = $TS($S(__, $EXPECT($L10, fail, 'FatArrow "=>"')), function($skip, $loc, $0, $1, $2) {
+      var ws = $1;
+      if (!ws.length)
+        return " =>";
+      return $0;
+    });
+    function FatArrow(state) {
+      if (state.verbose)
+        console.log("ENTER:", "FatArrow");
+      if (state.tokenize) {
+        return $TOKEN("FatArrow", state, FatArrow$0(state));
+      } else {
+        return FatArrow$0(state);
+      }
+    }
+    var ConciseBody$0 = $S(EOS, SingleNestedBlockExpression);
+    var ConciseBody$1 = $S($N($S($Q(_), $EXPECT($L11, fail, 'ConciseBody "{"'))), AssignmentExpression);
     var ConciseBody$2 = BracedBlock;
     function ConciseBody(state) {
       if (state.tokenize) {
@@ -1418,7 +1438,7 @@ var require_parser = __commonJS({
         return BracedBlock$0(state) || BracedBlock$1(state) || BracedBlock$2(state);
       }
     }
-    var SingleNestedBlockExpression$0 = $TS($S(PushIndent, $E($S(Nested, $C(Declaration, Statement))), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+    var SingleNestedBlockExpression$0 = $TS($S(PushIndent, $E($S(Nested, StatementListItem)), $C($C($N($S(Nested, StatementListItem)), $S(PopIndent, $N($EXPECT($L30, fail, 'SingleNestedBlockExpression ""')))), PopIndent)), function($skip, $loc, $0, $1, $2, $3) {
       var exp = $2;
       if (exp)
         return exp;
@@ -1448,7 +1468,7 @@ var require_parser = __commonJS({
         return NestedBlockExpressions$0(state);
       }
     }
-    var BlockExpression$0 = $S(Nested, $C(Declaration, Statement), StatementDelimiter);
+    var BlockExpression$0 = $S(Nested, StatementListItem, StatementDelimiter);
     function BlockExpression(state) {
       if (state.verbose)
         console.log("ENTER:", "BlockExpression");
@@ -1858,13 +1878,45 @@ var require_parser = __commonJS({
     }
     var ModuleItem$0 = ImportDeclaration;
     var ModuleItem$1 = ExportDeclaration;
-    var ModuleItem$2 = Declaration;
-    var ModuleItem$3 = Statement;
+    var ModuleItem$2 = StatementListItem;
     function ModuleItem(state) {
       if (state.tokenize) {
-        return $TOKEN("ModuleItem", state, ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state) || ModuleItem$3(state));
+        return $TOKEN("ModuleItem", state, ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state));
+      } else {
+        return ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state);
+      }
+    }
+    var StatementListItem$0 = $TS($S($C(Declaration, Statement), $E(PostfixConditional)), function($skip, $loc, $0, $1, $2) {
+      var statement = $1;
+      var cond = $2;
+      if (cond)
+        return [cond, statement, "}"];
+      return $0;
+    });
+    function StatementListItem(state) {
+      if (state.verbose)
+        console.log("ENTER:", "StatementListItem");
+      if (state.tokenize) {
+        return $TOKEN("StatementListItem", state, StatementListItem$0(state));
+      } else {
+        return StatementListItem$0(state);
+      }
+    }
+    var PostfixConditional$0 = $TS($S($Q(TrailingComment), $C($EXPECT($L85, fail, 'PostfixConditional "if"'), $EXPECT($L86, fail, 'PostfixConditional "unless"')), NonIdContinue, Expression), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ws = $1;
+      var cond = $2;
+      var exp = $4;
+      if (cond === "if")
+        return [ws, "if(", exp, ") {"];
+      return [ws, "if(!(", exp, ")) {"];
+    });
+    function PostfixConditional(state) {
+      if (state.verbose)
+        console.log("ENTER:", "PostfixConditional");
+      if (state.tokenize) {
+        return $TOKEN("PostfixConditional", state, PostfixConditional$0(state));
       } else {
-        return ModuleItem$0(state) || ModuleItem$1(state) || ModuleItem$2(state) || ModuleItem$3(state);
+        return PostfixConditional$0(state);
       }
     }
     var Statement$0 = KeywordStatement;
@@ -1883,7 +1935,7 @@ var require_parser = __commonJS({
         return Statement$0(state) || Statement$1(state) || Statement$2(state) || Statement$3(state) || Statement$4(state) || Statement$5(state) || Statement$6(state) || Statement$7(state) || Statement$8(state);
       }
     }
-    var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"')));
+    var EmptyStatement$0 = $S($Q(TrailingComment), $Y($EXPECT($L87, fail, 'EmptyStatement ";"')));
     function EmptyStatement(state) {
       if (state.verbose)
         console.log("ENTER:", "EmptyStatement");
@@ -1903,8 +1955,8 @@ var require_parser = __commonJS({
         return BlockStatement$0(state);
       }
     }
-    var IfStatement$0 = $S($EXPECT($L86, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L87, fail, 'IfStatement "else"'), Block)));
-    var IfStatement$1 = $TS($S($EXPECT($L88, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
+    var IfStatement$0 = $S($EXPECT($L85, fail, 'IfStatement "if"'), Condition, Block, $E($S(__, $EXPECT($L88, fail, 'IfStatement "else"'), Block)));
+    var IfStatement$1 = $TS($S($EXPECT($L86, fail, 'IfStatement "unless"'), Condition, Block), function($skip, $loc, $0, $1, $2, $3) {
       var condition = $2;
       var block = $3;
       return ["if", condition.map((c) => {
@@ -1934,8 +1986,8 @@ var require_parser = __commonJS({
         return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
       }
     }
-    var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), Block), function($skip, $loc, $0, $1, $2) {
-      var b = $2;
+    var LoopStatement$0 = $TS($S($EXPECT($L89, fail, 'LoopStatement "loop"'), NonIdContinue, Block), function($skip, $loc, $0, $1, $2, $3) {
+      var b = $3;
       return ["while(true)", b];
     });
     function LoopStatement(state) {
@@ -1947,7 +1999,7 @@ var require_parser = __commonJS({
         return LoopStatement$0(state);
       }
     }
-    var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
+    var DoWhileStatement$0 = $S($EXPECT($L90, fail, 'DoWhileStatement "do"'), NonIdContinue, Block, __, $EXPECT($L91, fail, 'DoWhileStatement "while"'), Condition);
     function DoWhileStatement(state) {
       if (state.verbose)
         console.log("ENTER:", "DoWhileStatement");
@@ -1957,7 +2009,7 @@ var require_parser = __commonJS({
         return DoWhileStatement$0(state);
       }
     }
-    var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), Condition, Block);
+    var WhileStatement$0 = $S($EXPECT($L91, fail, 'WhileStatement "while"'), NonIdContinue, Condition, Block);
     function WhileStatement(state) {
       if (state.verbose)
         console.log("ENTER:", "WhileStatement");
@@ -1967,7 +2019,7 @@ var require_parser = __commonJS({
         return WhileStatement$0(state);
       }
     }
-    var ForStatement$0 = $S($EXPECT($L92, fail, 'ForStatement "for"'), __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L85, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L85, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
+    var ForStatement$0 = $S($EXPECT($L92, fail, 'ForStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForStatement "("'), __, $C(LexicalDeclaration, VariableStatement, $E(Expression)), __, $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L2, fail, 'ForStatement ")"'), Block);
     function ForStatement(state) {
       if (state.verbose)
         console.log("ENTER:", "ForStatement");
@@ -1977,10 +2029,10 @@ var require_parser = __commonJS({
         return ForStatement$0(state);
       }
     }
-    var ForInOfStatement$0 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
-    var ForInOfStatement$1 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
-    var ForInOfStatement$2 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
-    var ForInOfStatement$3 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
+    var ForInOfStatement$0 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
+    var ForInOfStatement$1 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L78, fail, 'ForInOfStatement "in"'), __, Expression, InsertCloseParen, Block);
+    var ForInOfStatement$2 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, $EXPECT($L1, fail, 'ForInOfStatement "("'), __, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, __, $EXPECT($L2, fail, 'ForInOfStatement ")"'), Block);
+    var ForInOfStatement$3 = $S($EXPECT($L92, fail, 'ForInOfStatement "for"'), NonIdContinue, $E($S(__, $EXPECT($L94, fail, 'ForInOfStatement "await"'))), __, InsertOpenParen, $C($S($EXPECT($L93, fail, 'ForInOfStatement "var"'), __, ForBinding), ForDeclaration, LeftHandSideExpression), __, $EXPECT($L95, fail, 'ForInOfStatement "of"'), AssignmentExpression, InsertCloseParen, Block);
     function ForInOfStatement(state) {
       if (state.tokenize) {
         return $TOKEN("ForInOfStatement", state, ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state));
@@ -1988,7 +2040,7 @@ var require_parser = __commonJS({
         return ForInOfStatement$0(state) || ForInOfStatement$1(state) || ForInOfStatement$2(state) || ForInOfStatement$3(state);
       }
     }
-    var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), __, ForBinding);
+    var ForDeclaration$0 = $S($C($EXPECT($L96, fail, 'ForDeclaration "let"'), $EXPECT($L97, fail, 'ForDeclaration "const"')), NonIdContinue, __, ForBinding);
     function ForDeclaration(state) {
       if (state.verbose)
         console.log("ENTER:", "ForDeclaration");
@@ -2007,7 +2059,7 @@ var require_parser = __commonJS({
         return ForBinding$0(state) || ForBinding$1(state);
       }
     }
-    var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), Condition, CaseBlock);
+    var SwitchStatement$0 = $S($EXPECT($L98, fail, 'SwitchStatement "switch"'), NonIdContinue, Condition, CaseBlock);
     function SwitchStatement(state) {
       if (state.verbose)
         console.log("ENTER:", "SwitchStatement");
@@ -2051,9 +2103,9 @@ var require_parser = __commonJS({
         return NestedCaseClause$0(state);
       }
     }
-    var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
+    var CaseClause$0 = $S($EXPECT($L99, fail, 'CaseClause "case"'), NonIdContinue, $Q(_), Expression, ImpliedColon, NestedBlockExpressions);
     var CaseClause$1 = $S(When, $Q(_), Expression, ImpliedColon, NestedBlockExpressions, InsertBreak);
-    var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), ImpliedColon, NestedBlockExpressions);
+    var CaseClause$2 = $S($EXPECT($L100, fail, 'CaseClause "default"'), NonIdContinue, ImpliedColon, NestedBlockExpressions);
     function CaseClause(state) {
       if (state.tokenize) {
         return $TOKEN("CaseClause", state, CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state));
@@ -2061,7 +2113,7 @@ var require_parser = __commonJS({
         return CaseClause$0(state) || CaseClause$1(state) || CaseClause$2(state);
       }
     }
-    var When$0 = $T($EXPECT($L101, fail, 'When "when"'), function(value) {
+    var When$0 = $T($S($EXPECT($L101, fail, 'When "when"'), NonIdContinue), function(value) {
       return "case";
     });
     function When(state) {
@@ -2158,12 +2210,12 @@ var require_parser = __commonJS({
         return ExpressionStatement$0(state);
       }
     }
-    var KeywordStatement$0 = $EXPECT($L105, fail, 'KeywordStatement "break"');
-    var KeywordStatement$1 = $EXPECT($L106, fail, 'KeywordStatement "continue"');
-    var KeywordStatement$2 = $EXPECT($L107, fail, 'KeywordStatement "debugger"');
-    var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), Expression);
-    var KeywordStatement$4 = $EXPECT($L108, fail, 'KeywordStatement "return"');
-    var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), Expression);
+    var KeywordStatement$0 = $S($EXPECT($L105, fail, 'KeywordStatement "break"'), NonIdContinue);
+    var KeywordStatement$1 = $S($EXPECT($L106, fail, 'KeywordStatement "continue"'), NonIdContinue);
+    var KeywordStatement$2 = $S($EXPECT($L107, fail, 'KeywordStatement "debugger"'), NonIdContinue);
+    var KeywordStatement$3 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), NonIdContinue, Expression);
+    var KeywordStatement$4 = $S($EXPECT($L108, fail, 'KeywordStatement "return"'), NonIdContinue);
+    var KeywordStatement$5 = $S($EXPECT($L109, fail, 'KeywordStatement "throw"'), NonIdContinue, 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));
@@ -2171,11 +2223,11 @@ var require_parser = __commonJS({
         return KeywordStatement$0(state) || KeywordStatement$1(state) || KeywordStatement$2(state) || KeywordStatement$3(state) || KeywordStatement$4(state) || KeywordStatement$5(state);
       }
     }
-    var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), __, ImportClause, __, FromClause), function(value) {
+    var ImportDeclaration$0 = $T($S($EXPECT($L110, fail, 'ImportDeclaration "import type"'), NonIdContinue, __, ImportClause, __, FromClause), function(value) {
       return { "ts": true, "children": value };
     });
-    var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ImportClause, __, FromClause);
-    var ImportDeclaration$2 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), __, ModuleSpecifier);
+    var ImportDeclaration$1 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), NonIdContinue, __, ImportClause, __, FromClause);
+    var ImportDeclaration$2 = $S($EXPECT($L23, fail, 'ImportDeclaration "import"'), NonIdContinue, __, ModuleSpecifier);
     function ImportDeclaration(state) {
       if (state.tokenize) {
         return $TOKEN("ImportDeclaration", state, ImportDeclaration$0(state) || ImportDeclaration$1(state) || ImportDeclaration$2(state));
@@ -2193,7 +2245,7 @@ var require_parser = __commonJS({
         return ImportClause$0(state) || ImportClause$1(state) || ImportClause$2(state);
       }
     }
-    var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), __, ImportedBinding);
+    var NameSpaceImport$0 = $S($EXPECT($L9, fail, 'NameSpaceImport "*"'), __, $EXPECT($L4, fail, 'NameSpaceImport "as"'), NonIdContinue, __, ImportedBinding);
     function NameSpaceImport(state) {
       if (state.verbose)
         console.log("ENTER:", "NameSpaceImport");
@@ -2213,7 +2265,7 @@ var require_parser = __commonJS({
         return NamedImports$0(state);
       }
     }
-    var FromClause$0 = $S($EXPECT($L111, fail, 'FromClause "from"'), __, ModuleSpecifier);
+    var FromClause$0 = $S($EXPECT($L111, fail, 'FromClause "from"'), NonIdContinue, __, ModuleSpecifier);
     function FromClause(state) {
       if (state.verbose)
         console.log("ENTER:", "FromClause");
@@ -2223,7 +2275,7 @@ var require_parser = __commonJS({
         return FromClause$0(state);
       }
     }
-    var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), __, ImportedBinding, ObjectPropertyDelimiter);
+    var ImportSpecifier$0 = $S(__, ModuleExportName, __, $EXPECT($L4, fail, 'ImportSpecifier "as"'), NonIdContinue, __, ImportedBinding, ObjectPropertyDelimiter);
     var ImportSpecifier$1 = $S(__, ImportedBinding, ObjectPropertyDelimiter);
     function ImportSpecifier(state) {
       if (state.tokenize) {
@@ -2261,9 +2313,9 @@ var require_parser = __commonJS({
         return ImportedBinding$0(state);
       }
     }
-    var ExportDeclaration$0 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
-    var ExportDeclaration$1 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, ExportFromClause, __, FromClause);
-    var ExportDeclaration$2 = $S($EXPECT($L112, fail, 'ExportDeclaration "export"'), __, $C(NamedExports, VariableStatement, Declaration));
+    var ExportDeclaration$0 = $S(Export, __, $EXPECT($L100, fail, 'ExportDeclaration "default"'), NonIdContinue, __, $C(HoistableDeclaration, ClassDeclaration, AssignmentExpression));
+    var ExportDeclaration$1 = $S(Export, __, ExportFromClause, __, FromClause);
+    var ExportDeclaration$2 = $S(Export, __, $C(NamedExports, VariableStatement, Declaration));
     function ExportDeclaration(state) {
       if (state.tokenize) {
         return $TOKEN("ExportDeclaration", state, ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state));
@@ -2271,7 +2323,27 @@ var require_parser = __commonJS({
         return ExportDeclaration$0(state) || ExportDeclaration$1(state) || ExportDeclaration$2(state);
       }
     }
-    var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), __, ModuleExportName)));
+    var As$0 = $S($EXPECT($L4, fail, 'As "as"'), NonIdContinue);
+    function As(state) {
+      if (state.verbose)
+        console.log("ENTER:", "As");
+      if (state.tokenize) {
+        return $TOKEN("As", state, As$0(state));
+      } else {
+        return As$0(state);
+      }
+    }
+    var Export$0 = $S($EXPECT($L112, fail, 'Export "export"'), NonIdContinue);
+    function Export(state) {
+      if (state.verbose)
+        console.log("ENTER:", "Export");
+      if (state.tokenize) {
+        return $TOKEN("Export", state, Export$0(state));
+      } else {
+        return Export$0(state);
+      }
+    }
+    var ExportFromClause$0 = $S($EXPECT($L9, fail, 'ExportFromClause "*"'), $E($S(__, $EXPECT($L4, fail, 'ExportFromClause "as"'), NonIdContinue, __, ModuleExportName)));
     var ExportFromClause$1 = NamedExports;
     function ExportFromClause(state) {
       if (state.tokenize) {
@@ -2688,7 +2760,7 @@ var require_parser = __commonJS({
         return __$0(state);
       }
     }
-    var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L85, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
+    var StatementDelimiter$0 = $S($Q(TrailingComment), $EXPECT($L87, fail, 'StatementDelimiter ";"'), $Q(TrailingComment));
     var StatementDelimiter$1 = $T($Y(EOS), function(value) {
       return [";", value];
     });
@@ -2933,7 +3005,7 @@ var require_parser = __commonJS({
         return InterfaceProperty$0(state);
       }
     }
-    var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L85, fail, 'InterfacePropertyDelimiter ";"'));
+    var InterfacePropertyDelimiter$0 = $S($Q(_), $EXPECT($L87, fail, 'InterfacePropertyDelimiter ";"'));
     var InterfacePropertyDelimiter$1 = $Y($S($Q(_), $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"')));
     var InterfacePropertyDelimiter$2 = $T($Y($S(__, $EXPECT($L16, fail, 'InterfacePropertyDelimiter "}"'))), function(value) {
       return ";";

package/dist/types.d.ts

@@ -0,0 +1,16 @@
+declare module "@danielx/civet" {
+  export type CivetAST = unknown;
+  export type CompileOptions = {
+    js?: boolean
+  }
+
+  export function compile(source: string, options?: CompileOptions): string
+  export function parse(source: string): CivetAST
+  export function generate(ast: CivetAST, options?: CompileOptions): string
+
+  export default interface Civet {
+    compile: typeof compile;
+    parse: typeof parse;
+    generate: typeof generate;
+  }
+}

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@danielx/civet",
-  "version": "0.2.7",
+  "version": "0.2.10",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
+  "types": "dist/types.d.ts",
   "bin": {
     "civet": "dist/civet"
   },