@danielx/civet 0.2.7 → 0.2.10

package/README.md

@@ -5,11 +5,18 @@ Civet
 
 A new CoffeeScript. Much closer to ES2015+ (for better or worse).
 
-Also TypeScript, the sky is the limit.
+Also TypeScript, the sky is the limit. [Online Civet Playground](https://civet-web.vercel.app/)
+
+Quickstart Guide
+---
 
 ```bash
+# Install
 npm install -g @danielx/civet
+# Compile civet source file to typescript
 civet < source.civet > output.ts
+# Execute a civet source file in node
+node --loader @danielx/civet/register.mjs source.civet
 ```
 
 ![image](https://user-images.githubusercontent.com/18894/184558519-b675a903-7490-43ba-883e-0d8addacd4b9.png)
@@ -20,7 +27,7 @@ Code Sample
 ```typescript
 import ts, {CompilerOptions} from "typescript"
 
-const DefaultCompilerOptions : CompilerOptions =
+DefaultCompilerOptions : CompilerOptions :=
   allowNonTsExtensions: true
   allowJs: true
   target: ts.ScriptTarget.Latest
@@ -29,13 +36,13 @@ const DefaultCompilerOptions : CompilerOptions =
   allowSyntheticDefaultImports: true
   experimentalDecorators: true
 
-const fileCache : Record<string, any> = {}
+fileCache : Record<string, any> := {}
 
-const createCompilerHost = (options: CompilerOptions, moduleSearchLocations : string[]) ->
-  const fileExists = (fileName: string) : boolean ->
+createCompilerHost := (options: CompilerOptions, moduleSearchLocations : string[]) ->
+  fileExists := (fileName: string) : boolean ->
     return fileCache[fileName]?
 
-  const readFile = (fileName: string) ->
+  readFile := (fileName: string) ->
     return fileCache[fileName]
 ```
 
@@ -46,6 +53,7 @@ Things Kept from CoffeeScript
 - `or` -> `||`
 - `and` -> `&&`
 - `loop` -> `while(true)`
+- `unless` conditional (without the `else`)
 - Object literal syntax
   ```coffee
   x =
@@ -60,25 +68,32 @@ Things Kept from CoffeeScript
 - OptionalChain shorthand for index and function application `a?[b]` -> `a?.[b]`, `a?(b)` -> `a?.(b)`
 - `@` -> `this`
 - `@id` -> `this.id`
+- Postfix `if/unless`
 - JSX 😿
 - TODO
   - [ ] `"""` Strings (for compatibility with existing .coffee code)
-  - [ ] `///` Heregexp
   - [ ] Chained comparisons
+  - [ ] `until`
+  - [ ] Prototype shorthand `X::` -> `X.prototype`, `X::a` -> `X.prototype.a`
 
 Things Removed from CoffeeScript
 ---
 
-- `on` (use `true`)
-- `off` (use `false`)
+- `on/yes/off/no` (use `true/false`)
+- `isnt` (use `!==`)
+- `not` (use `!`)
 - `do` keyword (replaced with JS `do`)
 - `for from` (use JS `for of`)
 - Array slices `list[0...2]` (use `list.slice(0, 2)`)
+- Slice assignment `numbers[3..6] = [-3, -4, -5, -6]`
 - Comprensions (a case could be made for keeping them)
 - Iteration expression results
 - Implicit declarations
 - Implicit returns (will probably add later)
 - Rest parameter in any assignment position (might add later)
+- Postfix `while/until`
+- `///` Heregexp
+- Embedded JS
 
 Things Changed from CoffeeScript
 ---
@@ -89,10 +104,17 @@ Things Changed from CoffeeScript
 - `a...` is now `...a` just like JS
 - `x?.y` now compiles to `x?.y` rather than the `if typeof x !== 'undefined' && x !== null` if check
 - Existential `x?` -> `(x != null)` no longer checks for undeclared variables.
+- Embedded JS `\`\`` has been replaced with JS template literals.
+- No longer allowing multiple postfix `if/unless` on the same line.
+- No `else` block on `unless` (negate condition and use `if`)
+- Civet tries to keep the transpiled output verbatim as much as possible.
+  In Coffee `(x)` -> `x;` but in Civet `(x)` -> `(x);`.
+  Also in Coffee `x    +    3` -> `x + 3` but in Civet `x    +    3` remains as is.
 
 Things Added that CoffeeScript didn't
 ---
 
+- TypeScript Types
 - JS Compatability
   - `var`, `let`, `const`
   - JS Comment Syntax `//` and `/* */`
@@ -114,4 +136,11 @@ Things Added that CoffeeScript didn't
   #!./node_modules/.bin/ts-node
   console.log "hi"
   ```
-- TypeScript Types
+
+Things Changed from ES6
+---
+
+- Disallow no parens on single argument arrow function. `x => ...` must become `(x) => ...`
+  The reasoning is `x -> ` => `x(function() ...)` in CoffeeScript and having `->` and `=>`
+  behave more differently than they already do is bad. Passing an anonymous function to an
+  application without parens is also convenient.

package/dist/browser.js

@@ -421,6 +421,7 @@ var Civet = (() => {
         AssignmentExpressionRest,
         YieldExpression,
         ArrowFunction,
+        FatArrow,
         ConciseBody,
         ConditionalExpression,
         ShortCircuitExpression,
@@ -498,6 +499,8 @@ var Civet = (() => {
         BinaryOp,
         UnaryOp,
         ModuleItem,
+        StatementListItem,
+        PostfixConditional,
         Statement,
         EmptyStatement,
         BlockStatement,
@@ -535,6 +538,8 @@ var Civet = (() => {
         ModuleSpecifier,
         ImportedBinding,
         ExportDeclaration,
+        As,
+        Export,
         ExportFromClause,
         NamedExports,
         ExportSpecifier,
@@ -726,10 +731,10 @@ var Civet = (() => {
       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");
@@ -951,7 +956,7 @@ var Civet = (() => {
       }
       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) {
@@ -971,7 +976,7 @@ var Civet = (() => {
         }
       }
       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));
@@ -979,8 +984,23 @@ var Civet = (() => {
           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) {
@@ -1419,7 +1439,7 @@ var Civet = (() => {
           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;
@@ -1449,7 +1469,7 @@ var Civet = (() => {
           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");
@@ -1859,13 +1879,45 @@ var Civet = (() => {
       }
       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;
@@ -1884,7 +1936,7 @@ var Civet = (() => {
           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");
@@ -1904,8 +1956,8 @@ var Civet = (() => {
           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) => {
@@ -1935,8 +1987,8 @@ var Civet = (() => {
           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) {
@@ -1948,7 +2000,7 @@ var Civet = (() => {
           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");
@@ -1958,7 +2010,7 @@ var Civet = (() => {
           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");
@@ -1968,7 +2020,7 @@ var Civet = (() => {
           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");
@@ -1978,10 +2030,10 @@ var Civet = (() => {
           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));
@@ -1989,7 +2041,7 @@ var Civet = (() => {
           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");
@@ -2008,7 +2060,7 @@ var Civet = (() => {
           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");
@@ -2052,9 +2104,9 @@ var Civet = (() => {
           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));
@@ -2062,7 +2114,7 @@ var Civet = (() => {
           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) {
@@ -2159,12 +2211,12 @@ var Civet = (() => {
           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));
@@ -2172,11 +2224,11 @@ var Civet = (() => {
           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));
@@ -2194,7 +2246,7 @@ var Civet = (() => {
           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");
@@ -2214,7 +2266,7 @@ var Civet = (() => {
           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");
@@ -2224,7 +2276,7 @@ var Civet = (() => {
           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) {
@@ -2262,9 +2314,9 @@ var Civet = (() => {
           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));
@@ -2272,7 +2324,27 @@ var Civet = (() => {
           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) {
@@ -2689,7 +2761,7 @@ var Civet = (() => {
           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];
       });
@@ -2934,7 +3006,7 @@ var Civet = (() => {
           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 ";";