@danielx/civet 0.4.19-pre.4 → 0.4.19-pre.6

package/README.md

@@ -86,7 +86,7 @@ Things Kept from CoffeeScript
 - Late assignment `x + y = z` -> `x + (y = z)`
 - Braceless inline objects `x = coolStory: true`
 - Simplified number method calls `1.toFixed()` -> `1..toFixed()`
-- `if`/`switch` expressions
+- `if`/`switch`/`for`/`loop`/`while`/`throw` expressions
 - Destructuring object assignment doesn't require being wrapped in parens at the statement level `{a, b} = c` -> `({a, b} = c)`
 - JSX 😿
 
@@ -115,7 +115,6 @@ Civet.
 - Backtick embedded JS (replaced by template literals)
 - Will likely add later
   - Optional assignment `x?.y = 3` -> `x != null ? x.y = 3 : undefined`
-  - Loop expressions (at least in compatibility mode)
   - Conditional assignment `a?[x] = 3` -> `a ? a[x] = 3 : undefined`
 - Might add later
   - `///` Heregexp

package/dist/browser.js

@@ -544,13 +544,16 @@ var Civet = (() => {
         EmptyStatement,
         BlockStatement,
         IfStatement,
+        ElseClause,
         IfClause,
         UnlessClause,
         IfExpression,
+        UnlessExpression,
         ExpressionBlock,
         NestedBlockExpressions,
         NestedBlockExpression,
         IterationStatement,
+        IterationExpression,
         LoopStatement,
         LoopClause,
         DoWhileStatement,
@@ -561,6 +564,7 @@ var Civet = (() => {
         ForStatementControl,
         WhenCondition,
         CoffeeForStatementParameters,
+        CoffeeForIndex,
         CoffeeForDeclaration,
         ForStatementParameters,
         ForInOfDeclaration,
@@ -973,7 +977,7 @@ var Civet = (() => {
       var $L153 = $L("civet");
       var $L154 = $L("  ");
       var $L155 = $L("	");
-      var $R0 = $R(new RegExp("(of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
+      var $R0 = $R(new RegExp("(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
       var $R1 = $R(new RegExp("[&]", "suy"));
       var $R2 = $R(new RegExp("[!~+-]+", "suy"));
       var $R3 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
@@ -1061,13 +1065,15 @@ var Civet = (() => {
       }
       var ExpressionizedStatement$0 = DebuggerExpression;
       var ExpressionizedStatement$1 = IfExpression;
-      var ExpressionizedStatement$2 = SwitchExpression;
-      var ExpressionizedStatement$3 = ThrowExpression;
+      var ExpressionizedStatement$2 = UnlessExpression;
+      var ExpressionizedStatement$3 = IterationExpression;
+      var ExpressionizedStatement$4 = SwitchExpression;
+      var ExpressionizedStatement$5 = ThrowExpression;
       function ExpressionizedStatement(state) {
         if (state.tokenize) {
-          return $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state));
+          return $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state));
         } else {
-          return ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state);
+          return ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state);
         }
       }
       var Expression$0 = $TS($S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
@@ -1247,7 +1253,9 @@ var Civet = (() => {
         var exp = $2;
         var post = $3;
         if (post?.token === "?") {
-          return ["(", pre, "(", exp, ") != null)"];
+          return {
+            children: ["(", ...pre, "(", exp, ") != null)"]
+          };
         }
         if (exp.type === "Literal") {
           if (pre.length === 1 && pre[0].token === "-") {
@@ -1267,12 +1275,16 @@ var Civet = (() => {
           exp.unshift(...pre);
           if (post)
             exp.push(post);
-          return exp;
+          return {
+            children: exp
+          };
         } else {
           const result = [...pre, exp];
           if (post)
             result.push(post);
-          return result;
+          return {
+            children: result
+          };
         }
       });
       var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
@@ -1564,8 +1576,21 @@ var Civet = (() => {
           return PrimaryExpression$0(state) || PrimaryExpression$1(state) || PrimaryExpression$2(state) || PrimaryExpression$3(state) || PrimaryExpression$4(state) || PrimaryExpression$5(state) || PrimaryExpression$6(state) || PrimaryExpression$7(state) || PrimaryExpression$8(state) || PrimaryExpression$9(state) || PrimaryExpression$10(state) || PrimaryExpression$11(state);
         }
       }
-      var ParenthesizedExpression$0 = $TS($S(OpenParen, ExtendedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ParenthesizedExpression$0 = $TS($S(OpenParen, ExtendedExpression, $E($S($Q(TrailingComment), PostfixStatement)), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var exp = $2;
+        var post = $3;
+        if (post) {
+          let clause;
+          switch (post[1].type) {
+            case "IterationStatement":
+            case "ForStatement":
+              clause = module.addPostfixStatement(exp, ...post);
+              return module.expressionizeIteration(clause);
+            case "IfStatement":
+              clause = module.expressionizeIfClause(post[1], exp);
+              return clause;
+          }
+        }
         return {
           type: "ParenthesizedExpression",
           expression: exp,
@@ -1774,7 +1799,7 @@ var Civet = (() => {
           return NonNullAssertion$0(state);
         }
       }
-      var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
+      var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
       function AdditionalReservedWords(state) {
         if (state.verbose)
           console.log("ENTER:", "AdditionalReservedWords");
@@ -3278,27 +3303,11 @@ var Civet = (() => {
         }
       }
       var StatementListItem$0 = Declaration;
-      var StatementListItem$1 = $TS($S(Statement, $Q(TrailingComment), $E(PostfixStatement)), function($skip, $loc, $0, $1, $2, $3) {
+      var StatementListItem$1 = $TS($S(Statement, $E($S($Q(TrailingComment), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
         var statement = $1;
-        var ws = $2;
-        var post = $3;
-        if (post) {
-          let block;
-          if (post.type === "ForStatement") {
-            if (post.blockPrefix?.length) {
-              block = [" {", ...post.blockPrefix, ...statement, " }"];
-            } else {
-              block = statement;
-            }
-          } else {
-            block = statement;
-          }
-          post.block = block;
-          post.children.push(block);
-          if (!module.isWhitespaceOrEmpty(ws))
-            post.children.push(ws);
-          return post;
-        }
+        var post = $2;
+        if (post)
+          return module.addPostfixStatement(statement, ...post);
         return statement;
       });
       function StatementListItem(state) {
@@ -3361,7 +3370,7 @@ var Civet = (() => {
           return BlockStatement$0(state);
         }
       }
-      var IfStatement$0 = $TS($S($C(IfClause, UnlessClause), Block, $E($S(__, Else, Block))), function($skip, $loc, $0, $1, $2, $3) {
+      var IfStatement$0 = $TS($S($C(IfClause, UnlessClause), Block, $E(ElseClause)), function($skip, $loc, $0, $1, $2, $3) {
         var clause = $1;
         var block = $2;
         var e = $3;
@@ -3379,6 +3388,17 @@ var Civet = (() => {
           return IfStatement$0(state);
         }
       }
+      var ElseClause$0 = $T($S($Y(EOS), Samedent, Else, Block), function(value) {
+        return [value[1], value[2], value[3]];
+      });
+      var ElseClause$1 = $S($Q(TrailingComment), Else, Block);
+      function ElseClause(state) {
+        if (state.tokenize) {
+          return $TOKEN("ElseClause", state, ElseClause$0(state) || ElseClause$1(state));
+        } else {
+          return ElseClause$0(state) || ElseClause$1(state);
+        }
+      }
       var IfClause$0 = $T($S(If, Condition), function(value) {
         return { "type": "IfStatement", "children": value };
       });
@@ -3415,16 +3435,7 @@ var Civet = (() => {
         var clause = $1;
         var b = $2;
         var e = $3;
-        clause.children.shift();
-        clause.children.push("?", b, ":");
-        if (e) {
-          e.splice(1, 1);
-          clause.children.push(e);
-        } else {
-          clause.children.push("void 0");
-        }
-        clause.type = "IfExpression";
-        return clause;
+        return module.expressionizeIfClause(clause, b, e);
       });
       function IfExpression(state) {
         if (state.verbose)
@@ -3435,6 +3446,21 @@ var Civet = (() => {
           return IfExpression$0(state);
         }
       }
+      var UnlessExpression$0 = $TS($S(UnlessClause, ExpressionBlock, $E($S(__, Else, ExpressionBlock))), function($skip, $loc, $0, $1, $2, $3) {
+        var clause = $1;
+        var b = $2;
+        var e = $3;
+        return module.expressionizeIfClause(clause, b, e);
+      });
+      function UnlessExpression(state) {
+        if (state.verbose)
+          console.log("ENTER:", "UnlessExpression");
+        if (state.tokenize) {
+          return $TOKEN("UnlessExpression", state, UnlessExpression$0(state));
+        } else {
+          return UnlessExpression$0(state);
+        }
+      }
       var ExpressionBlock$0 = $TS($S(InsertOpenParen, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
         var exps = $3;
         exps[exps.length - 1].pop();
@@ -3490,9 +3516,22 @@ var Civet = (() => {
           return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state);
         }
       }
+      var IterationExpression$0 = $TS($S(IterationStatement), function($skip, $loc, $0, $1) {
+        return module.expressionizeIteration($1);
+      });
+      function IterationExpression(state) {
+        if (state.verbose)
+          console.log("ENTER:", "IterationExpression");
+        if (state.tokenize) {
+          return $TOKEN("IterationExpression", state, IterationExpression$0(state));
+        } else {
+          return IterationExpression$0(state);
+        }
+      }
       var LoopStatement$0 = $TS($S(LoopClause, Block), function($skip, $loc, $0, $1, $2) {
         var clause = $1;
         var block = $2;
+        clause.block = block;
         clause.children.push(block);
         return clause;
       });
@@ -3506,7 +3545,7 @@ var Civet = (() => {
         }
       }
       var LoopClause$0 = $T($S(Loop), function(value) {
-        return { "type": "IterationStatement", "children": value };
+        return { "type": "IterationStatement", "children": [value[0]], "block": null };
       });
       function LoopClause(state) {
         if (state.verbose)
@@ -3518,7 +3557,8 @@ var Civet = (() => {
         }
       }
       var DoWhileStatement$0 = $T($S(Do, BracedBlock, __, WhileClause), function(value) {
-        return { "type": "IterationStatement", "children": value };
+        var block = value[1];
+        return { "type": "IterationStatement", "children": value, "block": block };
       });
       function DoWhileStatement(state) {
         if (state.verbose)
@@ -3532,6 +3572,7 @@ var Civet = (() => {
       var WhileStatement$0 = $TS($S(WhileClause, Block), function($skip, $loc, $0, $1, $2) {
         var clause = $1;
         var block = $2;
+        clause.block = block;
         clause.children.push(block);
         return clause;
       });
@@ -3555,7 +3596,8 @@ var Civet = (() => {
         }
         return {
           type: "IterationStatement",
-          children: $0
+          children: $0,
+          block: null
         };
       });
       function WhileClause(state) {
@@ -3614,10 +3656,10 @@ var Civet = (() => {
         if ($3) {
           const indent = "".padStart((module.currentIndent + 1) * 2);
           module.insertTrimmingSpace($3, "");
-          $2.blockPrefix.push({
+          $2.blockPrefix.push([indent, {
             type: "IfStatement",
-            children: [indent, "if (!(", $3, ")) continue\n"]
-          });
+            children: ["if (!(", $3, ")) continue\n"]
+          }]);
         }
         return $2;
       });
@@ -3641,13 +3683,14 @@ var Civet = (() => {
           return WhenCondition$0(state);
         }
       }
-      var CoffeeForStatementParameters$0 = $TS($S($E($S(Await, __)), InsertOpenParen, CoffeeForDeclaration, __, $C(In, Of, From), ExtendedExpression, $E($S(__, By, ExtendedExpression)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+      var CoffeeForStatementParameters$0 = $TS($S($E($S(Await, __)), InsertOpenParen, CoffeeForDeclaration, $E(CoffeeForIndex), __, $C(In, Of, From), ExtendedExpression, $E($S(__, By, ExtendedExpression)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         var open = $2;
         var declaration = $3;
-        var kind = $5;
-        var exp = $6;
-        var step = $7;
-        var close = $8;
+        var index = $4;
+        var kind = $6;
+        var exp = $7;
+        var step = $8;
+        var close = $9;
         let blockPrefix = [];
         const indent = "".padStart((module.currentIndent + 1) * 2);
         if (kind.token === "from") {
@@ -3726,7 +3769,7 @@ var Civet = (() => {
                 children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", varRef2, " = ", startRef, ...ascDec],
                 names: []
               };
-              blockPrefix.push([{
+              blockPrefix.push(["", {
                 type: "AssignmentExpression",
                 children: [],
                 names: varRef2.names
@@ -3757,10 +3800,17 @@ var Civet = (() => {
             children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", expRef, ".length"],
             names: []
           };
-          blockPrefix.push([{
+          let indexAssignment;
+          let assignmentNames = [...varRef.names];
+          if (index) {
+            module.insertTrimmingSpace(index, "");
+            indexAssignment = [index, "="];
+            assignmentNames.push(...index.names);
+          }
+          blockPrefix.push([indent, {
             type: "AssignmentExpression",
-            children: [indent, varRef, " = ", expRef, "[", counterRef, "]\n"],
-            names: varRef.names
+            children: [varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
+            names: assignmentNames
           }]);
           return {
             declaration,
@@ -3783,6 +3833,20 @@ var Civet = (() => {
           return CoffeeForStatementParameters$0(state);
         }
       }
+      var CoffeeForIndex$0 = $TS($S($Q(TrailingComment), Comma, $Q(TrailingComment), BindingIdentifier), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var id = $4;
+        id.children.unshift(...$1, ...$3);
+        return id;
+      });
+      function CoffeeForIndex(state) {
+        if (state.verbose)
+          console.log("ENTER:", "CoffeeForIndex");
+        if (state.tokenize) {
+          return $TOKEN("CoffeeForIndex", state, CoffeeForIndex$0(state));
+        } else {
+          return CoffeeForIndex$0(state);
+        }
+      }
       var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L76, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
         var own = $1;
         var binding = $2;
@@ -3815,14 +3879,14 @@ var Civet = (() => {
           children: $0
         };
       });
-      var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationSuppressed, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         var declaration = $4;
         return {
           declaration,
           children: $0
         };
       });
-      var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+      var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationSuppressed, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
         var declaration = $3;
         return {
           declaration,
@@ -3943,7 +4007,7 @@ var Civet = (() => {
         var e = $0;
         module.addImplicitReturns(e.children[2]);
         e.type = "SwitchExpression";
-        e.children = ["($=>{", e.children, "})()"];
+        e.children = ["(()=>{", e.children, "})()"];
         return e;
       });
       function SwitchExpression(state) {
@@ -4226,7 +4290,7 @@ var Civet = (() => {
       var DebuggerExpression$0 = $TS($S($EXPECT($L80, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
         return {
           type: "DebuggerExpression",
-          children: ["($=>{", $1, "})()"]
+          children: ["(()=>{", $1, "})()"]
         };
       });
       function DebuggerExpression(state) {
@@ -4241,7 +4305,7 @@ var Civet = (() => {
       var ThrowExpression$0 = $TS($S(Throw, ExtendedExpression), function($skip, $loc, $0, $1, $2) {
         return {
           type: "ThrowExpression",
-          children: ["($=>{", ...$0, "})()"]
+          children: ["(()=>{", $0, "})()"]
         };
       });
       function ThrowExpression(state) {
@@ -7055,6 +7119,143 @@ var Civet = (() => {
             Object.assign(module.config, directive.config);
           }
         });
+        module.expressionizeIfClause = function(clause, b, e) {
+          clause.children.shift();
+          clause.children.push("?", b, ":");
+          if (e) {
+            e.splice(1, 1);
+            clause.children.push(e);
+          } else {
+            clause.children.push("void 0");
+          }
+          clause.type = "IfExpression";
+          return clause;
+        };
+        module.addPostfixStatement = function(statement, ws, post) {
+          let children, expressions;
+          if (post.blockPrefix?.length) {
+            let indent = post.blockPrefix[0][0];
+            expressions = [...post.blockPrefix, [indent, statement]];
+            children = [" {\n", ...expressions, "\n", indent?.slice?.(0, -2), "}"];
+          } else {
+            expressions = [["", statement]];
+            children = [" { ", ...expressions, " }"];
+          }
+          const block = {
+            type: "BlockStatement",
+            children,
+            expressions
+          };
+          post.block = block;
+          post.children.push(block);
+          if (!module.isWhitespaceOrEmpty(ws))
+            post.children.push(ws);
+          return post;
+        };
+        module.expressionizeIteration = function(statement) {
+          const resultsRef = {
+            type: "Ref",
+            base: "results"
+          };
+          insertPush(statement.block, resultsRef);
+          return {
+            type: "IterationExpression",
+            children: ["((", resultsRef, ")=>{", statement, "; return ", resultsRef, "})([])"]
+          };
+        };
+        function wrapIterationReturningResults(statement, outerRef) {
+          const resultsRef = {
+            type: "Ref",
+            base: "results"
+          };
+          const declaration = {
+            type: "Declaration",
+            children: ["const ", resultsRef, "=[];"]
+          };
+          insertPush(statement.block, resultsRef);
+          statement.children.unshift(declaration);
+          if (outerRef) {
+            statement.children.push(";", outerRef, ".push(", resultsRef, ");");
+          } else {
+            statement.children.push(";return ", resultsRef, ";");
+          }
+        }
+        function insertPush(node, ref) {
+          if (!node)
+            return;
+          switch (node.type) {
+            case "AssignmentExpression":
+              node.children.unshift(ref, ".push(");
+              node.children.push(")");
+              return;
+            case "Identifier":
+              node.children.unshift(ref, ".push(");
+              node.children.push(")");
+              return;
+            case "BlockStatement":
+              insertPush(node.expressions[node.expressions.length - 1], ref);
+              return;
+            case "ObjectExpression":
+              module.insertTrimmingSpace(node.children[0], "");
+              node.children.unshift(ref, ".push(");
+              node.children.push(")");
+              return;
+            case "CaseBlock":
+              node.clauses.forEach((clause) => {
+                insertPush(clause, ref);
+              });
+              return;
+            case "CaseClause":
+              return;
+            case "WhenClause":
+              insertPush(node.expressions[node.expressions.length - 1], ref);
+              return;
+            case "DefaultClause":
+              insertPush(node.expressions[node.expressions.length - 1], ref);
+              return;
+          }
+          if (!Array.isArray(node))
+            return;
+          const [, exp] = node;
+          if (!exp)
+            return;
+          let indent = node[0];
+          if (Array.isArray(indent))
+            indent = indent[indent.length - 1];
+          switch (exp.type) {
+            case "BreakStatement":
+            case "ContinueStatement":
+            case "DebuggerStatement":
+            case "EmptyStatement":
+            case "ReturnStatement":
+            case "ThrowStatement":
+            case "Declaration":
+              return;
+            case "ForStatement":
+            case "IterationStatement":
+              wrapIterationReturningResults(exp, ref);
+              return;
+            case "BlockStatement":
+              insertPush(exp.expressions[exp.expressions.length - 1], ref);
+              return;
+            case "IfStatement":
+              insertPush(exp.children[2], ref);
+              if (exp.children[3])
+                insertPush(exp.children[3][2], ref);
+              else
+                exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
+              return;
+            case "SwitchStatement":
+              insertPush(exp.children[2], ref);
+              return;
+            case "TryStatement":
+              insertPush(exp.children[1], ref);
+              insertPush(exp.children[2][3], ref);
+              return;
+          }
+          node.splice(1, 0, ref, ".push(");
+          node.push(")");
+        }
         function insertReturn(node) {
           if (!node)
             return;
@@ -7100,12 +7301,14 @@ var Civet = (() => {
             case "ContinueStatement":
             case "DebuggerStatement":
             case "EmptyStatement":
-            case "ForStatement":
-            case "IterationStatement":
             case "ReturnStatement":
             case "ThrowStatement":
             case "Declaration":
               return;
+            case "ForStatement":
+            case "IterationStatement":
+              wrapIterationReturningResults(exp);
+              return;
             case "BlockStatement":
               insertReturn(exp.expressions[exp.expressions.length - 1]);
               return;

package/dist/esm.mjs

@@ -36,7 +36,7 @@ function normalizeSlashes(value) {
 }
 
 function ensureRegister () {
-  if (registered)return
+  if (registered) { return }
 
   const installation = {
     environment: 'node',

package/dist/main.js

@@ -543,13 +543,16 @@ var require_parser = __commonJS({
       EmptyStatement,
       BlockStatement,
       IfStatement,
+      ElseClause,
       IfClause,
       UnlessClause,
       IfExpression,
+      UnlessExpression,
       ExpressionBlock,
       NestedBlockExpressions,
       NestedBlockExpression,
       IterationStatement,
+      IterationExpression,
       LoopStatement,
       LoopClause,
       DoWhileStatement,
@@ -560,6 +563,7 @@ var require_parser = __commonJS({
       ForStatementControl,
       WhenCondition,
       CoffeeForStatementParameters,
+      CoffeeForIndex,
       CoffeeForDeclaration,
       ForStatementParameters,
       ForInOfDeclaration,
@@ -972,7 +976,7 @@ var require_parser = __commonJS({
     var $L153 = $L("civet");
     var $L154 = $L("  ");
     var $L155 = $L("	");
-    var $R0 = $R(new RegExp("(of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
+    var $R0 = $R(new RegExp("(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
     var $R1 = $R(new RegExp("[&]", "suy"));
     var $R2 = $R(new RegExp("[!~+-]+", "suy"));
     var $R3 = $R(new RegExp("(?:\\p{ID_Start}|[_$])(?:\\p{ID_Continue}|[\\u200C\\u200D$])*", "suy"));
@@ -1060,13 +1064,15 @@ var require_parser = __commonJS({
     }
     var ExpressionizedStatement$0 = DebuggerExpression;
     var ExpressionizedStatement$1 = IfExpression;
-    var ExpressionizedStatement$2 = SwitchExpression;
-    var ExpressionizedStatement$3 = ThrowExpression;
+    var ExpressionizedStatement$2 = UnlessExpression;
+    var ExpressionizedStatement$3 = IterationExpression;
+    var ExpressionizedStatement$4 = SwitchExpression;
+    var ExpressionizedStatement$5 = ThrowExpression;
     function ExpressionizedStatement(state) {
       if (state.tokenize) {
-        return $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state));
+        return $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state));
       } else {
-        return ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state);
+        return ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state);
       }
     }
     var Expression$0 = $TS($S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
@@ -1246,7 +1252,9 @@ var require_parser = __commonJS({
       var exp = $2;
       var post = $3;
       if (post?.token === "?") {
-        return ["(", pre, "(", exp, ") != null)"];
+        return {
+          children: ["(", ...pre, "(", exp, ") != null)"]
+        };
       }
       if (exp.type === "Literal") {
         if (pre.length === 1 && pre[0].token === "-") {
@@ -1266,12 +1274,16 @@ var require_parser = __commonJS({
         exp.unshift(...pre);
         if (post)
           exp.push(post);
-        return exp;
+        return {
+          children: exp
+        };
       } else {
         const result = [...pre, exp];
         if (post)
           result.push(post);
-        return result;
+        return {
+          children: result
+        };
       }
     });
     var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
@@ -1563,8 +1575,21 @@ var require_parser = __commonJS({
         return PrimaryExpression$0(state) || PrimaryExpression$1(state) || PrimaryExpression$2(state) || PrimaryExpression$3(state) || PrimaryExpression$4(state) || PrimaryExpression$5(state) || PrimaryExpression$6(state) || PrimaryExpression$7(state) || PrimaryExpression$8(state) || PrimaryExpression$9(state) || PrimaryExpression$10(state) || PrimaryExpression$11(state);
       }
     }
-    var ParenthesizedExpression$0 = $TS($S(OpenParen, ExtendedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var ParenthesizedExpression$0 = $TS($S(OpenParen, ExtendedExpression, $E($S($Q(TrailingComment), PostfixStatement)), __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var exp = $2;
+      var post = $3;
+      if (post) {
+        let clause;
+        switch (post[1].type) {
+          case "IterationStatement":
+          case "ForStatement":
+            clause = module2.addPostfixStatement(exp, ...post);
+            return module2.expressionizeIteration(clause);
+          case "IfStatement":
+            clause = module2.expressionizeIfClause(post[1], exp);
+            return clause;
+        }
+      }
       return {
         type: "ParenthesizedExpression",
         expression: exp,
@@ -1773,7 +1798,7 @@ var require_parser = __commonJS({
         return NonNullAssertion$0(state);
       }
     }
-    var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
+    var AdditionalReservedWords$0 = $R$0($EXPECT($R0, fail, "AdditionalReservedWords /(for|of|then|when)(?!\\p{ID_Continue}|[\\u200C\\u200D$])/"));
     function AdditionalReservedWords(state) {
       if (state.verbose)
         console.log("ENTER:", "AdditionalReservedWords");
@@ -3277,27 +3302,11 @@ var require_parser = __commonJS({
       }
     }
     var StatementListItem$0 = Declaration;
-    var StatementListItem$1 = $TS($S(Statement, $Q(TrailingComment), $E(PostfixStatement)), function($skip, $loc, $0, $1, $2, $3) {
+    var StatementListItem$1 = $TS($S(Statement, $E($S($Q(TrailingComment), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
       var statement = $1;
-      var ws = $2;
-      var post = $3;
-      if (post) {
-        let block;
-        if (post.type === "ForStatement") {
-          if (post.blockPrefix?.length) {
-            block = [" {", ...post.blockPrefix, ...statement, " }"];
-          } else {
-            block = statement;
-          }
-        } else {
-          block = statement;
-        }
-        post.block = block;
-        post.children.push(block);
-        if (!module2.isWhitespaceOrEmpty(ws))
-          post.children.push(ws);
-        return post;
-      }
+      var post = $2;
+      if (post)
+        return module2.addPostfixStatement(statement, ...post);
       return statement;
     });
     function StatementListItem(state) {
@@ -3360,7 +3369,7 @@ var require_parser = __commonJS({
         return BlockStatement$0(state);
       }
     }
-    var IfStatement$0 = $TS($S($C(IfClause, UnlessClause), Block, $E($S(__, Else, Block))), function($skip, $loc, $0, $1, $2, $3) {
+    var IfStatement$0 = $TS($S($C(IfClause, UnlessClause), Block, $E(ElseClause)), function($skip, $loc, $0, $1, $2, $3) {
       var clause = $1;
       var block = $2;
       var e = $3;
@@ -3378,6 +3387,17 @@ var require_parser = __commonJS({
         return IfStatement$0(state);
       }
     }
+    var ElseClause$0 = $T($S($Y(EOS), Samedent, Else, Block), function(value) {
+      return [value[1], value[2], value[3]];
+    });
+    var ElseClause$1 = $S($Q(TrailingComment), Else, Block);
+    function ElseClause(state) {
+      if (state.tokenize) {
+        return $TOKEN("ElseClause", state, ElseClause$0(state) || ElseClause$1(state));
+      } else {
+        return ElseClause$0(state) || ElseClause$1(state);
+      }
+    }
     var IfClause$0 = $T($S(If, Condition), function(value) {
       return { "type": "IfStatement", "children": value };
     });
@@ -3414,16 +3434,7 @@ var require_parser = __commonJS({
       var clause = $1;
       var b = $2;
       var e = $3;
-      clause.children.shift();
-      clause.children.push("?", b, ":");
-      if (e) {
-        e.splice(1, 1);
-        clause.children.push(e);
-      } else {
-        clause.children.push("void 0");
-      }
-      clause.type = "IfExpression";
-      return clause;
+      return module2.expressionizeIfClause(clause, b, e);
     });
     function IfExpression(state) {
       if (state.verbose)
@@ -3434,6 +3445,21 @@ var require_parser = __commonJS({
         return IfExpression$0(state);
       }
     }
+    var UnlessExpression$0 = $TS($S(UnlessClause, ExpressionBlock, $E($S(__, Else, ExpressionBlock))), function($skip, $loc, $0, $1, $2, $3) {
+      var clause = $1;
+      var b = $2;
+      var e = $3;
+      return module2.expressionizeIfClause(clause, b, e);
+    });
+    function UnlessExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "UnlessExpression");
+      if (state.tokenize) {
+        return $TOKEN("UnlessExpression", state, UnlessExpression$0(state));
+      } else {
+        return UnlessExpression$0(state);
+      }
+    }
     var ExpressionBlock$0 = $TS($S(InsertOpenParen, EOS, NestedBlockExpressions, InsertNewline, InsertIndent, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
       var exps = $3;
       exps[exps.length - 1].pop();
@@ -3489,9 +3515,22 @@ var require_parser = __commonJS({
         return IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state);
       }
     }
+    var IterationExpression$0 = $TS($S(IterationStatement), function($skip, $loc, $0, $1) {
+      return module2.expressionizeIteration($1);
+    });
+    function IterationExpression(state) {
+      if (state.verbose)
+        console.log("ENTER:", "IterationExpression");
+      if (state.tokenize) {
+        return $TOKEN("IterationExpression", state, IterationExpression$0(state));
+      } else {
+        return IterationExpression$0(state);
+      }
+    }
     var LoopStatement$0 = $TS($S(LoopClause, Block), function($skip, $loc, $0, $1, $2) {
       var clause = $1;
       var block = $2;
+      clause.block = block;
       clause.children.push(block);
       return clause;
     });
@@ -3505,7 +3544,7 @@ var require_parser = __commonJS({
       }
     }
     var LoopClause$0 = $T($S(Loop), function(value) {
-      return { "type": "IterationStatement", "children": value };
+      return { "type": "IterationStatement", "children": [value[0]], "block": null };
     });
     function LoopClause(state) {
       if (state.verbose)
@@ -3517,7 +3556,8 @@ var require_parser = __commonJS({
       }
     }
     var DoWhileStatement$0 = $T($S(Do, BracedBlock, __, WhileClause), function(value) {
-      return { "type": "IterationStatement", "children": value };
+      var block = value[1];
+      return { "type": "IterationStatement", "children": value, "block": block };
     });
     function DoWhileStatement(state) {
       if (state.verbose)
@@ -3531,6 +3571,7 @@ var require_parser = __commonJS({
     var WhileStatement$0 = $TS($S(WhileClause, Block), function($skip, $loc, $0, $1, $2) {
       var clause = $1;
       var block = $2;
+      clause.block = block;
       clause.children.push(block);
       return clause;
     });
@@ -3554,7 +3595,8 @@ var require_parser = __commonJS({
       }
       return {
         type: "IterationStatement",
-        children: $0
+        children: $0,
+        block: null
       };
     });
     function WhileClause(state) {
@@ -3613,10 +3655,10 @@ var require_parser = __commonJS({
       if ($3) {
         const indent = "".padStart((module2.currentIndent + 1) * 2);
         module2.insertTrimmingSpace($3, "");
-        $2.blockPrefix.push({
+        $2.blockPrefix.push([indent, {
           type: "IfStatement",
-          children: [indent, "if (!(", $3, ")) continue\n"]
-        });
+          children: ["if (!(", $3, ")) continue\n"]
+        }]);
       }
       return $2;
     });
@@ -3640,13 +3682,14 @@ var require_parser = __commonJS({
         return WhenCondition$0(state);
       }
     }
-    var CoffeeForStatementParameters$0 = $TS($S($E($S(Await, __)), InsertOpenParen, CoffeeForDeclaration, __, $C(In, Of, From), ExtendedExpression, $E($S(__, By, ExtendedExpression)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+    var CoffeeForStatementParameters$0 = $TS($S($E($S(Await, __)), InsertOpenParen, CoffeeForDeclaration, $E(CoffeeForIndex), __, $C(In, Of, From), ExtendedExpression, $E($S(__, By, ExtendedExpression)), InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       var open = $2;
       var declaration = $3;
-      var kind = $5;
-      var exp = $6;
-      var step = $7;
-      var close = $8;
+      var index = $4;
+      var kind = $6;
+      var exp = $7;
+      var step = $8;
+      var close = $9;
       let blockPrefix = [];
       const indent = "".padStart((module2.currentIndent + 1) * 2);
       if (kind.token === "from") {
@@ -3725,7 +3768,7 @@ var require_parser = __commonJS({
               children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", varRef2, " = ", startRef, ...ascDec],
               names: []
             };
-            blockPrefix.push([{
+            blockPrefix.push(["", {
               type: "AssignmentExpression",
               children: [],
               names: varRef2.names
@@ -3756,10 +3799,17 @@ var require_parser = __commonJS({
           children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", expRef, ".length"],
           names: []
         };
-        blockPrefix.push([{
+        let indexAssignment;
+        let assignmentNames = [...varRef.names];
+        if (index) {
+          module2.insertTrimmingSpace(index, "");
+          indexAssignment = [index, "="];
+          assignmentNames.push(...index.names);
+        }
+        blockPrefix.push([indent, {
           type: "AssignmentExpression",
-          children: [indent, varRef, " = ", expRef, "[", counterRef, "]\n"],
-          names: varRef.names
+          children: [varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
+          names: assignmentNames
         }]);
         return {
           declaration,
@@ -3782,6 +3832,20 @@ var require_parser = __commonJS({
         return CoffeeForStatementParameters$0(state);
       }
     }
+    var CoffeeForIndex$0 = $TS($S($Q(TrailingComment), Comma, $Q(TrailingComment), BindingIdentifier), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var id = $4;
+      id.children.unshift(...$1, ...$3);
+      return id;
+    });
+    function CoffeeForIndex(state) {
+      if (state.verbose)
+        console.log("ENTER:", "CoffeeForIndex");
+      if (state.tokenize) {
+        return $TOKEN("CoffeeForIndex", state, CoffeeForIndex$0(state));
+      } else {
+        return CoffeeForIndex$0(state);
+      }
+    }
     var CoffeeForDeclaration$0 = $TS($S($E($S(__, $EXPECT($L76, fail, 'CoffeeForDeclaration "own"'))), ForBinding), function($skip, $loc, $0, $1, $2) {
       var own = $1;
       var binding = $2;
@@ -3814,14 +3878,14 @@ var require_parser = __commonJS({
         children: $0
       };
     });
-    var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var ForStatementParameters$2 = $TS($S($E($S(Await, __)), OpenParen, __, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationSuppressed, __, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       var declaration = $4;
       return {
         declaration,
         children: $0
       };
     });
-    var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExtendedExpression, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+    var ForStatementParameters$3 = $TS($S($E($S(Await, __)), InsertOpenParen, ForInOfDeclaration, __, $C(In, Of), ExpressionWithIndentedApplicationSuppressed, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
       var declaration = $3;
       return {
         declaration,
@@ -3942,7 +4006,7 @@ var require_parser = __commonJS({
       var e = $0;
       module2.addImplicitReturns(e.children[2]);
       e.type = "SwitchExpression";
-      e.children = ["($=>{", e.children, "})()"];
+      e.children = ["(()=>{", e.children, "})()"];
       return e;
     });
     function SwitchExpression(state) {
@@ -4225,7 +4289,7 @@ var require_parser = __commonJS({
     var DebuggerExpression$0 = $TS($S($EXPECT($L80, fail, 'DebuggerExpression "debugger"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return {
         type: "DebuggerExpression",
-        children: ["($=>{", $1, "})()"]
+        children: ["(()=>{", $1, "})()"]
       };
     });
     function DebuggerExpression(state) {
@@ -4240,7 +4304,7 @@ var require_parser = __commonJS({
     var ThrowExpression$0 = $TS($S(Throw, ExtendedExpression), function($skip, $loc, $0, $1, $2) {
       return {
         type: "ThrowExpression",
-        children: ["($=>{", ...$0, "})()"]
+        children: ["(()=>{", $0, "})()"]
       };
     });
     function ThrowExpression(state) {
@@ -7054,6 +7118,143 @@ var require_parser = __commonJS({
           Object.assign(module2.config, directive.config);
         }
       });
+      module2.expressionizeIfClause = function(clause, b, e) {
+        clause.children.shift();
+        clause.children.push("?", b, ":");
+        if (e) {
+          e.splice(1, 1);
+          clause.children.push(e);
+        } else {
+          clause.children.push("void 0");
+        }
+        clause.type = "IfExpression";
+        return clause;
+      };
+      module2.addPostfixStatement = function(statement, ws, post) {
+        let children, expressions;
+        if (post.blockPrefix?.length) {
+          let indent = post.blockPrefix[0][0];
+          expressions = [...post.blockPrefix, [indent, statement]];
+          children = [" {\n", ...expressions, "\n", indent?.slice?.(0, -2), "}"];
+        } else {
+          expressions = [["", statement]];
+          children = [" { ", ...expressions, " }"];
+        }
+        const block = {
+          type: "BlockStatement",
+          children,
+          expressions
+        };
+        post.block = block;
+        post.children.push(block);
+        if (!module2.isWhitespaceOrEmpty(ws))
+          post.children.push(ws);
+        return post;
+      };
+      module2.expressionizeIteration = function(statement) {
+        const resultsRef = {
+          type: "Ref",
+          base: "results"
+        };
+        insertPush(statement.block, resultsRef);
+        return {
+          type: "IterationExpression",
+          children: ["((", resultsRef, ")=>{", statement, "; return ", resultsRef, "})([])"]
+        };
+      };
+      function wrapIterationReturningResults(statement, outerRef) {
+        const resultsRef = {
+          type: "Ref",
+          base: "results"
+        };
+        const declaration = {
+          type: "Declaration",
+          children: ["const ", resultsRef, "=[];"]
+        };
+        insertPush(statement.block, resultsRef);
+        statement.children.unshift(declaration);
+        if (outerRef) {
+          statement.children.push(";", outerRef, ".push(", resultsRef, ");");
+        } else {
+          statement.children.push(";return ", resultsRef, ";");
+        }
+      }
+      function insertPush(node, ref) {
+        if (!node)
+          return;
+        switch (node.type) {
+          case "AssignmentExpression":
+            node.children.unshift(ref, ".push(");
+            node.children.push(")");
+            return;
+          case "Identifier":
+            node.children.unshift(ref, ".push(");
+            node.children.push(")");
+            return;
+          case "BlockStatement":
+            insertPush(node.expressions[node.expressions.length - 1], ref);
+            return;
+          case "ObjectExpression":
+            module2.insertTrimmingSpace(node.children[0], "");
+            node.children.unshift(ref, ".push(");
+            node.children.push(")");
+            return;
+          case "CaseBlock":
+            node.clauses.forEach((clause) => {
+              insertPush(clause, ref);
+            });
+            return;
+          case "CaseClause":
+            return;
+          case "WhenClause":
+            insertPush(node.expressions[node.expressions.length - 1], ref);
+            return;
+          case "DefaultClause":
+            insertPush(node.expressions[node.expressions.length - 1], ref);
+            return;
+        }
+        if (!Array.isArray(node))
+          return;
+        const [, exp] = node;
+        if (!exp)
+          return;
+        let indent = node[0];
+        if (Array.isArray(indent))
+          indent = indent[indent.length - 1];
+        switch (exp.type) {
+          case "BreakStatement":
+          case "ContinueStatement":
+          case "DebuggerStatement":
+          case "EmptyStatement":
+          case "ReturnStatement":
+          case "ThrowStatement":
+          case "Declaration":
+            return;
+          case "ForStatement":
+          case "IterationStatement":
+            wrapIterationReturningResults(exp, ref);
+            return;
+          case "BlockStatement":
+            insertPush(exp.expressions[exp.expressions.length - 1], ref);
+            return;
+          case "IfStatement":
+            insertPush(exp.children[2], ref);
+            if (exp.children[3])
+              insertPush(exp.children[3][2], ref);
+            else
+              exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
+            return;
+          case "SwitchStatement":
+            insertPush(exp.children[2], ref);
+            return;
+          case "TryStatement":
+            insertPush(exp.children[1], ref);
+            insertPush(exp.children[2][3], ref);
+            return;
+        }
+        node.splice(1, 0, ref, ".push(");
+        node.push(")");
+      }
       function insertReturn(node) {
         if (!node)
           return;
@@ -7099,12 +7300,14 @@ var require_parser = __commonJS({
           case "ContinueStatement":
           case "DebuggerStatement":
           case "EmptyStatement":
-          case "ForStatement":
-          case "IterationStatement":
           case "ReturnStatement":
           case "ThrowStatement":
           case "Declaration":
             return;
+          case "ForStatement":
+          case "IterationStatement":
+            wrapIterationReturningResults(exp);
+            return;
           case "BlockStatement":
             insertReturn(exp.expressions[exp.expressions.length - 1]);
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.4.19-pre.4",
+  "version": "0.4.19-pre.6",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "exports": {