@danielx/civet 0.2.9 → 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 =
@@ -65,19 +73,25 @@ Things Kept from CoffeeScript
 - TODO
   - [ ] `"""` Strings (for compatibility with existing .coffee code)
   - [ ] Chained comparisons
+  - [ ] `until`
+  - [ ] Prototype shorthand `X::` -> `X.prototype`, `X::a` -> `X.prototype.a`
 
 Things Removed from CoffeeScript
 ---
 
 - `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
 
@@ -92,10 +106,15 @@ Things Changed from CoffeeScript
 - 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 `/* */`
@@ -117,7 +136,6 @@ Things Added that CoffeeScript didn't
   #!./node_modules/.bin/ts-node
   console.log "hi"
   ```
-- TypeScript Types
 
 Things Changed from ES6
 ---

package/dist/browser.js

@@ -538,6 +538,8 @@ var Civet = (() => {
         ModuleSpecifier,
         ImportedBinding,
         ExportDeclaration,
+        As,
+        Export,
         ExportFromClause,
         NamedExports,
         ExportSpecifier,
@@ -1985,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) {
@@ -1998,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");
@@ -2008,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");
@@ -2018,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($L87, fail, 'ForStatement ";"'), __, $E(Expression), $EXPECT($L87, 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");
@@ -2028,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));
@@ -2039,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");
@@ -2058,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");
@@ -2102,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));
@@ -2112,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) {
@@ -2209,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));
@@ -2222,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));
@@ -2244,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");
@@ -2264,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");
@@ -2274,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) {
@@ -2312,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));
@@ -2322,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) {