@danielx/civet 0.4.19-pre.3 → 0.4.19-pre.5

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

@@ -490,6 +490,7 @@ var Civet = (() => {
         ThinArrowFunction,
         Arrow,
         Block,
+        ThenClause,
         BracedOrEmptyBlock,
         EmptyBlock,
         BracedBlock,
@@ -543,6 +544,7 @@ var Civet = (() => {
         EmptyStatement,
         BlockStatement,
         IfStatement,
+        ElseClause,
         IfClause,
         UnlessClause,
         IfExpression,
@@ -550,6 +552,7 @@ var Civet = (() => {
         NestedBlockExpressions,
         NestedBlockExpression,
         IterationStatement,
+        IterationExpression,
         LoopStatement,
         LoopClause,
         DoWhileStatement,
@@ -560,12 +563,14 @@ var Civet = (() => {
         ForStatementControl,
         WhenCondition,
         CoffeeForStatementParameters,
+        CoffeeForIndex,
         CoffeeForDeclaration,
         ForStatementParameters,
         ForInOfDeclaration,
         ForDeclaration,
         ForBinding,
         SwitchStatement,
+        EmptyCondition,
         SwitchExpression,
         CaseBlock,
         NestedCaseClauses,
@@ -971,7 +976,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"));
@@ -1059,13 +1064,14 @@ var Civet = (() => {
       }
       var ExpressionizedStatement$0 = DebuggerExpression;
       var ExpressionizedStatement$1 = IfExpression;
-      var ExpressionizedStatement$2 = SwitchExpression;
-      var ExpressionizedStatement$3 = ThrowExpression;
+      var ExpressionizedStatement$2 = IterationExpression;
+      var ExpressionizedStatement$3 = SwitchExpression;
+      var ExpressionizedStatement$4 = 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));
         } 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);
         }
       }
       var Expression$0 = $TS($S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
@@ -1772,7 +1778,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");
@@ -2385,12 +2391,8 @@ var Civet = (() => {
         var exps = value[2];
         return { "type": "BlockStatement", "expressions": exps, "children": value };
       });
-      var Block$2 = $T($S($E(Then), Statement), function(value) {
-        return value[1];
-      });
-      var Block$3 = $T($S($E(Then), __, Statement), function(value) {
-        return [value[1], value[2]];
-      });
+      var Block$2 = ThenClause;
+      var Block$3 = $S($Q(TrailingComment), Statement);
       function Block(state) {
         if (state.tokenize) {
           return $TOKEN("Block", state, Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state));
@@ -2398,6 +2400,18 @@ var Civet = (() => {
           return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
         }
       }
+      var ThenClause$0 = $T($S(Then, $Q(TrailingComment), Statement), function(value) {
+        return [value[1], value[2]];
+      });
+      function ThenClause(state) {
+        if (state.verbose)
+          console.log("ENTER:", "ThenClause");
+        if (state.tokenize) {
+          return $TOKEN("ThenClause", state, ThenClause$0(state));
+        } else {
+          return ThenClause$0(state);
+        }
+      }
       var BracedOrEmptyBlock$0 = BracedBlock;
       var BracedOrEmptyBlock$1 = EmptyBlock;
       function BracedOrEmptyBlock(state) {
@@ -3273,16 +3287,20 @@ var Civet = (() => {
         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;
-            }
+          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 {
-            block = statement;
+            expressions = [["", statement]];
+            children = [" { ", ...expressions, " }"];
           }
+          const block = {
+            type: "BlockStatement",
+            children,
+            expressions
+          };
           post.block = block;
           post.children.push(block);
           if (!module.isWhitespaceOrEmpty(ws))
@@ -3351,7 +3369,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;
@@ -3369,6 +3387,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 };
       });
@@ -3480,9 +3509,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;
       });
@@ -3496,7 +3538,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)
@@ -3508,7 +3550,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)
@@ -3522,6 +3565,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;
       });
@@ -3545,7 +3589,8 @@ var Civet = (() => {
         }
         return {
           type: "IterationStatement",
-          children: $0
+          children: $0,
+          block: null
         };
       });
       function WhileClause(state) {
@@ -3631,13 +3676,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") {
@@ -3747,10 +3793,17 @@ var Civet = (() => {
             children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", expRef, ".length"],
             names: []
           };
+          let indexAssignment;
+          let assignmentNames = [...varRef.names];
+          if (index) {
+            module.insertTrimmingSpace(index, "");
+            indexAssignment = [index, "="];
+            assignmentNames.push(...index.names);
+          }
           blockPrefix.push([{
             type: "AssignmentExpression",
-            children: [indent, varRef, " = ", expRef, "[", counterRef, "]\n"],
-            names: varRef.names
+            children: [indent, varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
+            names: assignmentNames
           }]);
           return {
             declaration,
@@ -3773,6 +3826,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;
@@ -3805,14 +3872,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,
@@ -3877,8 +3944,30 @@ var Civet = (() => {
           return ForBinding$0(state) || ForBinding$1(state);
         }
       }
-      var SwitchStatement$0 = $T($S(Switch, Condition, CaseBlock), function(value) {
-        return { "type": "SwitchStatement", "children": value };
+      var SwitchStatement$0 = $TS($S(Switch, $C(EmptyCondition, Condition), CaseBlock), function($skip, $loc, $0, $1, $2, $3) {
+        var condition = $2;
+        var caseBlock = $3;
+        if (condition.type === "EmptyCondition") {
+          caseBlock.clauses.forEach(({ cases }) => {
+            if (cases) {
+              cases.forEach((c) => {
+                const exp = c[1];
+                switch (exp.type) {
+                  case "Identifier":
+                  case "Literal":
+                    c.splice(1, 0, "!");
+                    break;
+                  default:
+                    c.splice(1, 1, "!(", exp, ")");
+                }
+              });
+            }
+          });
+        }
+        return {
+          type: "SwitchStatement",
+          children: $0
+        };
       });
       function SwitchStatement(state) {
         if (state.verbose)
@@ -3889,11 +3978,29 @@ var Civet = (() => {
           return SwitchStatement$0(state);
         }
       }
+      var EmptyCondition$0 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
+        return {
+          type: "EmptyCondition",
+          children: [{
+            $loc,
+            token: " (false)"
+          }]
+        };
+      });
+      function EmptyCondition(state) {
+        if (state.verbose)
+          console.log("ENTER:", "EmptyCondition");
+        if (state.tokenize) {
+          return $TOKEN("EmptyCondition", state, EmptyCondition$0(state));
+        } else {
+          return EmptyCondition$0(state);
+        }
+      }
       var SwitchExpression$0 = $TV(SwitchStatement, function($skip, $loc, $0, $1) {
         var e = $0;
         module.addImplicitReturns(e.children[2]);
         e.type = "SwitchExpression";
-        e.children = ["($=>{", e.children, "})()"];
+        e.children = ["(()=>{", e.children, "})()"];
         return e;
       });
       function SwitchExpression(state) {
@@ -3959,18 +4066,20 @@ var Civet = (() => {
         }
       }
       var CaseClause$0 = $T($S(Case, CaseExpressionList, $C(NestedBlockStatements, NoExpressions)), function(value) {
-        var exps = value[2];
-        return { "type": "CaseClause", "expressions": exps, "children": value };
+        var cases = value[1];
+        var expressions = value[2];
+        return { "type": "CaseClause", "cases": cases, "expressions": expressions, "children": value };
       });
-      var CaseClause$1 = $T($S(When, CaseExpressionList, NestedBlockStatements, InsertBreak), function(value) {
-        var exps = value[2];
-        return { "type": "WhenClause", "expressions": exps, "children": value };
+      var CaseClause$1 = $T($S(When, CaseExpressionList, $C(ThenClause, NestedBlockStatements), InsertBreak), function(value) {
+        var cases = value[1];
+        var expressions = value[2];
+        return { "type": "WhenClause", "cases": cases, "expressions": expressions, "children": value };
       });
       var CaseClause$2 = $T($S(Default, ImpliedColon, $C(NestedBlockStatements, NoExpressions)), function(value) {
         var exps = value[2];
         return { "type": "DefaultClause", "expressions": exps, "children": value };
       });
-      var CaseClause$3 = $TS($S(Else, ImpliedColon, NestedBlockStatements), function($skip, $loc, $0, $1, $2, $3) {
+      var CaseClause$3 = $TS($S(Else, ImpliedColon, $C(NestedBlockStatements, $S($Q(TrailingComment), Statement))), function($skip, $loc, $0, $1, $2, $3) {
         var exps = $3;
         $1.token = "default";
         return {
@@ -4174,7 +4283,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) {
@@ -4189,7 +4298,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) {
@@ -7003,6 +7112,110 @@ var Civet = (() => {
             Object.assign(module.config, directive.config);
           }
         });
+        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;
@@ -7048,12 +7261,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

@@ -489,6 +489,7 @@ var require_parser = __commonJS({
       ThinArrowFunction,
       Arrow,
       Block,
+      ThenClause,
       BracedOrEmptyBlock,
       EmptyBlock,
       BracedBlock,
@@ -542,6 +543,7 @@ var require_parser = __commonJS({
       EmptyStatement,
       BlockStatement,
       IfStatement,
+      ElseClause,
       IfClause,
       UnlessClause,
       IfExpression,
@@ -549,6 +551,7 @@ var require_parser = __commonJS({
       NestedBlockExpressions,
       NestedBlockExpression,
       IterationStatement,
+      IterationExpression,
       LoopStatement,
       LoopClause,
       DoWhileStatement,
@@ -559,12 +562,14 @@ var require_parser = __commonJS({
       ForStatementControl,
       WhenCondition,
       CoffeeForStatementParameters,
+      CoffeeForIndex,
       CoffeeForDeclaration,
       ForStatementParameters,
       ForInOfDeclaration,
       ForDeclaration,
       ForBinding,
       SwitchStatement,
+      EmptyCondition,
       SwitchExpression,
       CaseBlock,
       NestedCaseClauses,
@@ -970,7 +975,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"));
@@ -1058,13 +1063,14 @@ var require_parser = __commonJS({
     }
     var ExpressionizedStatement$0 = DebuggerExpression;
     var ExpressionizedStatement$1 = IfExpression;
-    var ExpressionizedStatement$2 = SwitchExpression;
-    var ExpressionizedStatement$3 = ThrowExpression;
+    var ExpressionizedStatement$2 = IterationExpression;
+    var ExpressionizedStatement$3 = SwitchExpression;
+    var ExpressionizedStatement$4 = 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));
       } 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);
       }
     }
     var Expression$0 = $TS($S(AssignmentExpression, $Q($S(__, Comma, AssignmentExpression))), function($skip, $loc, $0, $1, $2) {
@@ -1771,7 +1777,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");
@@ -2384,12 +2390,8 @@ var require_parser = __commonJS({
       var exps = value[2];
       return { "type": "BlockStatement", "expressions": exps, "children": value };
     });
-    var Block$2 = $T($S($E(Then), Statement), function(value) {
-      return value[1];
-    });
-    var Block$3 = $T($S($E(Then), __, Statement), function(value) {
-      return [value[1], value[2]];
-    });
+    var Block$2 = ThenClause;
+    var Block$3 = $S($Q(TrailingComment), Statement);
     function Block(state) {
       if (state.tokenize) {
         return $TOKEN("Block", state, Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state));
@@ -2397,6 +2399,18 @@ var require_parser = __commonJS({
         return Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state);
       }
     }
+    var ThenClause$0 = $T($S(Then, $Q(TrailingComment), Statement), function(value) {
+      return [value[1], value[2]];
+    });
+    function ThenClause(state) {
+      if (state.verbose)
+        console.log("ENTER:", "ThenClause");
+      if (state.tokenize) {
+        return $TOKEN("ThenClause", state, ThenClause$0(state));
+      } else {
+        return ThenClause$0(state);
+      }
+    }
     var BracedOrEmptyBlock$0 = BracedBlock;
     var BracedOrEmptyBlock$1 = EmptyBlock;
     function BracedOrEmptyBlock(state) {
@@ -3272,16 +3286,20 @@ var require_parser = __commonJS({
       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;
-          }
+        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 {
-          block = statement;
+          expressions = [["", statement]];
+          children = [" { ", ...expressions, " }"];
         }
+        const block = {
+          type: "BlockStatement",
+          children,
+          expressions
+        };
         post.block = block;
         post.children.push(block);
         if (!module2.isWhitespaceOrEmpty(ws))
@@ -3350,7 +3368,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;
@@ -3368,6 +3386,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 };
     });
@@ -3479,9 +3508,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;
     });
@@ -3495,7 +3537,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)
@@ -3507,7 +3549,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)
@@ -3521,6 +3564,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;
     });
@@ -3544,7 +3588,8 @@ var require_parser = __commonJS({
       }
       return {
         type: "IterationStatement",
-        children: $0
+        children: $0,
+        block: null
       };
     });
     function WhileClause(state) {
@@ -3630,13 +3675,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") {
@@ -3746,10 +3792,17 @@ var require_parser = __commonJS({
           children: ["let ", ...expRefDec, counterRef, " = 0, ", lenRef, " = ", expRef, ".length"],
           names: []
         };
+        let indexAssignment;
+        let assignmentNames = [...varRef.names];
+        if (index) {
+          module2.insertTrimmingSpace(index, "");
+          indexAssignment = [index, "="];
+          assignmentNames.push(...index.names);
+        }
         blockPrefix.push([{
           type: "AssignmentExpression",
-          children: [indent, varRef, " = ", expRef, "[", counterRef, "]\n"],
-          names: varRef.names
+          children: [indent, varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
+          names: assignmentNames
         }]);
         return {
           declaration,
@@ -3772,6 +3825,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;
@@ -3804,14 +3871,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,
@@ -3876,8 +3943,30 @@ var require_parser = __commonJS({
         return ForBinding$0(state) || ForBinding$1(state);
       }
     }
-    var SwitchStatement$0 = $T($S(Switch, Condition, CaseBlock), function(value) {
-      return { "type": "SwitchStatement", "children": value };
+    var SwitchStatement$0 = $TS($S(Switch, $C(EmptyCondition, Condition), CaseBlock), function($skip, $loc, $0, $1, $2, $3) {
+      var condition = $2;
+      var caseBlock = $3;
+      if (condition.type === "EmptyCondition") {
+        caseBlock.clauses.forEach(({ cases }) => {
+          if (cases) {
+            cases.forEach((c) => {
+              const exp = c[1];
+              switch (exp.type) {
+                case "Identifier":
+                case "Literal":
+                  c.splice(1, 0, "!");
+                  break;
+                default:
+                  c.splice(1, 1, "!(", exp, ")");
+              }
+            });
+          }
+        });
+      }
+      return {
+        type: "SwitchStatement",
+        children: $0
+      };
     });
     function SwitchStatement(state) {
       if (state.verbose)
@@ -3888,11 +3977,29 @@ var require_parser = __commonJS({
         return SwitchStatement$0(state);
       }
     }
+    var EmptyCondition$0 = $TV($Y(EOS), function($skip, $loc, $0, $1) {
+      return {
+        type: "EmptyCondition",
+        children: [{
+          $loc,
+          token: " (false)"
+        }]
+      };
+    });
+    function EmptyCondition(state) {
+      if (state.verbose)
+        console.log("ENTER:", "EmptyCondition");
+      if (state.tokenize) {
+        return $TOKEN("EmptyCondition", state, EmptyCondition$0(state));
+      } else {
+        return EmptyCondition$0(state);
+      }
+    }
     var SwitchExpression$0 = $TV(SwitchStatement, function($skip, $loc, $0, $1) {
       var e = $0;
       module2.addImplicitReturns(e.children[2]);
       e.type = "SwitchExpression";
-      e.children = ["($=>{", e.children, "})()"];
+      e.children = ["(()=>{", e.children, "})()"];
       return e;
     });
     function SwitchExpression(state) {
@@ -3958,18 +4065,20 @@ var require_parser = __commonJS({
       }
     }
     var CaseClause$0 = $T($S(Case, CaseExpressionList, $C(NestedBlockStatements, NoExpressions)), function(value) {
-      var exps = value[2];
-      return { "type": "CaseClause", "expressions": exps, "children": value };
+      var cases = value[1];
+      var expressions = value[2];
+      return { "type": "CaseClause", "cases": cases, "expressions": expressions, "children": value };
     });
-    var CaseClause$1 = $T($S(When, CaseExpressionList, NestedBlockStatements, InsertBreak), function(value) {
-      var exps = value[2];
-      return { "type": "WhenClause", "expressions": exps, "children": value };
+    var CaseClause$1 = $T($S(When, CaseExpressionList, $C(ThenClause, NestedBlockStatements), InsertBreak), function(value) {
+      var cases = value[1];
+      var expressions = value[2];
+      return { "type": "WhenClause", "cases": cases, "expressions": expressions, "children": value };
     });
     var CaseClause$2 = $T($S(Default, ImpliedColon, $C(NestedBlockStatements, NoExpressions)), function(value) {
       var exps = value[2];
       return { "type": "DefaultClause", "expressions": exps, "children": value };
     });
-    var CaseClause$3 = $TS($S(Else, ImpliedColon, NestedBlockStatements), function($skip, $loc, $0, $1, $2, $3) {
+    var CaseClause$3 = $TS($S(Else, ImpliedColon, $C(NestedBlockStatements, $S($Q(TrailingComment), Statement))), function($skip, $loc, $0, $1, $2, $3) {
       var exps = $3;
       $1.token = "default";
       return {
@@ -4173,7 +4282,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) {
@@ -4188,7 +4297,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) {
@@ -7002,6 +7111,110 @@ var require_parser = __commonJS({
           Object.assign(module2.config, directive.config);
         }
       });
+      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;
@@ -7047,12 +7260,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.3",
+  "version": "0.4.19-pre.5",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "exports": {