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

package/dist/browser.js

@@ -548,6 +548,7 @@ var Civet = (() => {
         IfClause,
         UnlessClause,
         IfExpression,
+        UnlessExpression,
         ExpressionBlock,
         NestedBlockExpressions,
         NestedBlockExpression,
@@ -1064,14 +1065,15 @@ var Civet = (() => {
       }
       var ExpressionizedStatement$0 = DebuggerExpression;
       var ExpressionizedStatement$1 = IfExpression;
-      var ExpressionizedStatement$2 = IterationExpression;
-      var ExpressionizedStatement$3 = SwitchExpression;
-      var ExpressionizedStatement$4 = 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) || ExpressionizedStatement$4(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) || ExpressionizedStatement$4(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) {
@@ -1251,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 === "-") {
@@ -1271,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) {
@@ -1568,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,
@@ -2385,14 +2406,24 @@ var Civet = (() => {
       }
       var Block$0 = $T($S(__, OpenBrace, EOS, NestedBlockStatements, __, CloseBrace), function(value) {
         var exps = value[3];
-        return { "type": "BlockStatement", "expressions": exps, "children": value };
+        return { "type": "BlockStatement", "expressions": exps, "children": value, "bare": false };
       });
       var Block$1 = $T($S(InsertOpenBrace, EOS, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function(value) {
         var exps = value[2];
-        return { "type": "BlockStatement", "expressions": exps, "children": value };
+        return { "type": "BlockStatement", "expressions": exps, "children": value, "bare": false };
       });
       var Block$2 = ThenClause;
-      var Block$3 = $S($Q(TrailingComment), Statement);
+      var Block$3 = $TS($S($Q(TrailingComment), Statement), function($skip, $loc, $0, $1, $2) {
+        var ws = $1;
+        var s = $2;
+        const expressions = [$0];
+        return {
+          type: "BlockStatement",
+          expressions,
+          children: [expressions],
+          bare: true
+        };
+      });
       function Block(state) {
         if (state.tokenize) {
           return $TOKEN("Block", state, Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state));
@@ -2400,8 +2431,16 @@ 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]];
+      var ThenClause$0 = $TS($S(Then, $Q(TrailingComment), Statement), function($skip, $loc, $0, $1, $2, $3) {
+        var ws = $2;
+        var s = $3;
+        const expressions = [[ws, s]];
+        return {
+          type: "BlockStatement",
+          expressions,
+          children: [expressions],
+          bare: true
+        };
       });
       function ThenClause(state) {
         if (state.verbose)
@@ -3282,31 +3321,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 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;
-        }
+        var post = $2;
+        if (post)
+          return module.addPostfixStatement(statement, ...post);
         return statement;
       });
       function StatementListItem(state) {
@@ -3434,16 +3453,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)
@@ -3454,6 +3464,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();
@@ -3649,10 +3674,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;
       });
@@ -3762,7 +3787,7 @@ var Civet = (() => {
                 children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", varRef2, " = ", startRef, ...ascDec],
                 names: []
               };
-              blockPrefix.push([{
+              blockPrefix.push(["", {
                 type: "AssignmentExpression",
                 children: [],
                 names: varRef2.names
@@ -3800,9 +3825,9 @@ var Civet = (() => {
             indexAssignment = [index, "="];
             assignmentNames.push(...index.names);
           }
-          blockPrefix.push([{
+          blockPrefix.push([indent, {
             type: "AssignmentExpression",
-            children: [indent, varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
+            children: [varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
             names: assignmentNames
           }]);
           return {
@@ -4070,10 +4095,18 @@ var Civet = (() => {
         var expressions = value[2];
         return { "type": "CaseClause", "cases": cases, "expressions": expressions, "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$1 = $TS($S(When, CaseExpressionList, $C(ThenClause, NestedBlockStatements), InsertBreak), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var cases = $2;
+        var expressions = $3;
+        if (expressions.expressions) {
+          expressions = expressions.expressions;
+        }
+        return {
+          type: "WhenClause",
+          cases,
+          expressions,
+          children: $0
+        };
       });
       var CaseClause$2 = $T($S(Default, ImpliedColon, $C(NestedBlockStatements, NoExpressions)), function(value) {
         var exps = value[2];
@@ -7112,6 +7145,39 @@ 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",

package/dist/civet

@@ -10,7 +10,13 @@ if (process.argv.includes("--version")) {
 encoding = "utf8";
 process.stdin.setEncoding(encoding);
 fs = require("fs");
-readline = require("node:readline");
+readline = function() {
+  try {
+    return require("node:readline");
+  } catch (error) {
+    return require("readline");
+  }
+}();
 readLines = function(rl) {
   return new Promise(function(resolve, reject) {
     var parts;
@@ -45,6 +51,6 @@ readLines(readline.createInterface(process.stdin)).then(function(input) {
   output = compile(input, { filename, js, inlineMap });
   return process.stdout.write(output);
 }).catch(function(e) {
-  console.error(e.message);
+  console.error(e);
   return process.exit(1);
 });

package/dist/main.js

@@ -547,6 +547,7 @@ var require_parser = __commonJS({
       IfClause,
       UnlessClause,
       IfExpression,
+      UnlessExpression,
       ExpressionBlock,
       NestedBlockExpressions,
       NestedBlockExpression,
@@ -1063,14 +1064,15 @@ var require_parser = __commonJS({
     }
     var ExpressionizedStatement$0 = DebuggerExpression;
     var ExpressionizedStatement$1 = IfExpression;
-    var ExpressionizedStatement$2 = IterationExpression;
-    var ExpressionizedStatement$3 = SwitchExpression;
-    var ExpressionizedStatement$4 = 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) || ExpressionizedStatement$4(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) || ExpressionizedStatement$4(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) {
@@ -1250,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 === "-") {
@@ -1270,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) {
@@ -1567,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,
@@ -2384,14 +2405,24 @@ var require_parser = __commonJS({
     }
     var Block$0 = $T($S(__, OpenBrace, EOS, NestedBlockStatements, __, CloseBrace), function(value) {
       var exps = value[3];
-      return { "type": "BlockStatement", "expressions": exps, "children": value };
+      return { "type": "BlockStatement", "expressions": exps, "children": value, "bare": false };
     });
     var Block$1 = $T($S(InsertOpenBrace, EOS, NestedBlockStatements, InsertNewline, InsertIndent, InsertCloseBrace), function(value) {
       var exps = value[2];
-      return { "type": "BlockStatement", "expressions": exps, "children": value };
+      return { "type": "BlockStatement", "expressions": exps, "children": value, "bare": false };
     });
     var Block$2 = ThenClause;
-    var Block$3 = $S($Q(TrailingComment), Statement);
+    var Block$3 = $TS($S($Q(TrailingComment), Statement), function($skip, $loc, $0, $1, $2) {
+      var ws = $1;
+      var s = $2;
+      const expressions = [$0];
+      return {
+        type: "BlockStatement",
+        expressions,
+        children: [expressions],
+        bare: true
+      };
+    });
     function Block(state) {
       if (state.tokenize) {
         return $TOKEN("Block", state, Block$0(state) || Block$1(state) || Block$2(state) || Block$3(state));
@@ -2399,8 +2430,16 @@ 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]];
+    var ThenClause$0 = $TS($S(Then, $Q(TrailingComment), Statement), function($skip, $loc, $0, $1, $2, $3) {
+      var ws = $2;
+      var s = $3;
+      const expressions = [[ws, s]];
+      return {
+        type: "BlockStatement",
+        expressions,
+        children: [expressions],
+        bare: true
+      };
     });
     function ThenClause(state) {
       if (state.verbose)
@@ -3281,31 +3320,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 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;
-      }
+      var post = $2;
+      if (post)
+        return module2.addPostfixStatement(statement, ...post);
       return statement;
     });
     function StatementListItem(state) {
@@ -3433,16 +3452,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)
@@ -3453,6 +3463,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();
@@ -3648,10 +3673,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;
     });
@@ -3761,7 +3786,7 @@ var require_parser = __commonJS({
               children: ["let ", ...startRefDec, ...endRefDec, counterRef, " = ", varRef2, " = ", startRef, ...ascDec],
               names: []
             };
-            blockPrefix.push([{
+            blockPrefix.push(["", {
               type: "AssignmentExpression",
               children: [],
               names: varRef2.names
@@ -3799,9 +3824,9 @@ var require_parser = __commonJS({
           indexAssignment = [index, "="];
           assignmentNames.push(...index.names);
         }
-        blockPrefix.push([{
+        blockPrefix.push([indent, {
           type: "AssignmentExpression",
-          children: [indent, varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
+          children: [varRef, " = ", expRef, "[", indexAssignment, counterRef, "]\n"],
           names: assignmentNames
         }]);
         return {
@@ -4069,10 +4094,18 @@ var require_parser = __commonJS({
       var expressions = value[2];
       return { "type": "CaseClause", "cases": cases, "expressions": expressions, "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$1 = $TS($S(When, CaseExpressionList, $C(ThenClause, NestedBlockStatements), InsertBreak), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var cases = $2;
+      var expressions = $3;
+      if (expressions.expressions) {
+        expressions = expressions.expressions;
+      }
+      return {
+        type: "WhenClause",
+        cases,
+        expressions,
+        children: $0
+      };
     });
     var CaseClause$2 = $T($S(Default, ImpliedColon, $C(NestedBlockStatements, NoExpressions)), function(value) {
       var exps = value[2];
@@ -7111,6 +7144,39 @@ 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",

package/package.json

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