@danielx/civet 0.2.6 → 0.2.9

package/README.md

@@ -60,17 +60,16 @@ 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
 
 Things Removed from CoffeeScript
 ---
 
-- `on` (use `true`)
-- `off` (use `false`)
+- `on/yes/off/no` (use `true/false`)
 - `do` keyword (replaced with JS `do`)
 - `for from` (use JS `for of`)
 - Array slices `list[0...2]` (use `list.slice(0, 2)`)
@@ -79,6 +78,8 @@ Things Removed from CoffeeScript
 - Implicit declarations
 - Implicit returns (will probably add later)
 - Rest parameter in any assignment position (might add later)
+- `///` Heregexp
+- Embedded JS
 
 Things Changed from CoffeeScript
 ---
@@ -89,6 +90,8 @@ 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.
 
 Things Added that CoffeeScript didn't
 ---
@@ -115,3 +118,11 @@ Things Added that CoffeeScript didn't
   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,
@@ -726,10 +729,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 +954,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 +974,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 +982,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 +1437,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 +1467,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 +1877,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) || ModuleItem$3(state);
+          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 PostfixConditional$0(state);
         }
       }
       var Statement$0 = KeywordStatement;
@@ -1884,7 +1934,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 +1954,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) => {
@@ -1968,7 +2018,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"'), __, $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");
@@ -2689,7 +2739,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 +2984,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 ";";
@@ -3469,7 +3519,8 @@ var Civet = (() => {
         parse,
         compile: function(src, options) {
           return gen(parse(src), options);
-        }
+        },
+        generate: gen
       };
     }
   });