@danielx/civet 0.5.71 → 0.5.72

package/dist/browser.js

@@ -3700,6 +3700,20 @@ ${input.slice(result.pos)}
           children: [start, [...ws, { ...sep, token: ", " }], [end, ...inc]]
         };
       });
+      var SliceParameters$2 = $TS($S(Loc, __, $C(DotDot, DotDotDot), $Y($S(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var l = $1;
+        var ws = $2;
+        const start = {
+          $loc: l.$loc,
+          token: "0"
+        };
+        return {
+          type: "SliceParameters",
+          start,
+          end: void 0,
+          children: [start, ws]
+        };
+      });
       function SliceParameters(state) {
         let eventData;
         if (state.events) {
@@ -3711,12 +3725,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state));
+          const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state));
           if (state.events)
             state.events.exit?.("SliceParameters", state, result, eventData);
           return result;
         } else {
-          const result = SliceParameters$0(state) || SliceParameters$1(state);
+          const result = SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state);
           if (state.events)
             state.events.exit?.("SliceParameters", state, result, eventData);
           return result;
@@ -5327,19 +5341,15 @@ ${input.slice(result.pos)}
           };
           return {
             type: "ArrowFunction",
-            children: [ref2, " => ", prefix, ref2]
+            children: [ref2, " => ", prefix, ref2],
+            ampersandBlock: true
           };
         }
         const { ref } = rhs;
-        if (!prefix) {
-          return {
-            type: "ArrowFunction",
-            children: [ref, " => ", rhs]
-          };
-        }
         return {
           type: "ArrowFunction",
-          children: [ref, " => ", prefix, rhs]
+          children: [ref, " => ", prefix, rhs],
+          ampersandBlock: true
         };
       });
       function FunctionExpression(state) {
@@ -9579,7 +9589,8 @@ ${input.slice(result.pos)}
         return {
           type: "SwitchExpression",
           children: ["(()=>{", e.children, "})()"],
-          caseBlock: e.children[2]
+          expression: e.expression,
+          caseBlock: e.caseBlock
         };
       });
       function SwitchExpression(state) {
@@ -13776,7 +13787,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var DotDot$0 = $TV($EXPECT($L114, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
+      var DotDot$0 = $TS($S($EXPECT($L114, fail, 'DotDot ".."'), $N($EXPECT($L4, fail, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
         return { $loc, token: $1 };
       });
       function DotDot(state) {
@@ -19616,6 +19627,9 @@ ${input.slice(result.pos)}
               else
                 exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
               return;
+            case "PatternMatchingStatement":
+              insertPush(exp.children[0][0], ref);
+              return;
             case "SwitchStatement":
               insertPush(exp.children[2], ref);
               return;
@@ -19703,6 +19717,9 @@ ${input.slice(result.pos)}
               else
                 exp.children.push(["\n", indent, wrapWithReturn()]);
               return;
+            case "PatternMatchingStatement":
+              insertReturn(exp.children[0][0]);
+              return;
             case "SwitchStatement":
               insertSwitchReturns(exp);
               return;
@@ -20630,7 +20647,7 @@ ${input.slice(result.pos)}
           }
         }
         function processPatternMatching(statements) {
-          gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement").forEach((s) => {
+          gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
             const { caseBlock } = s;
             const { clauses } = caseBlock;
             let errors = false;
@@ -20709,15 +20726,21 @@ ${input.slice(result.pos)}
                 block.children.push("}");
                 block.bare = false;
               }
-              const e = i < l - 1 ? ["\nelse "] : [];
-              prev.push({
+              if (i < l - 1)
+                next.push("\n", "else ");
+              prev.push(["", {
                 type: "IfStatement",
-                children: ["if", condition, block, ...e, next],
+                children: ["if", condition, block, next],
                 then: block,
-                else: e
-              });
+                else: next
+              }]);
               prev = next;
             });
+            if (module.config.implicitReturns && s.type === "SwitchExpression") {
+              insertReturn(root[0]);
+              root.unshift("(()=>{");
+              root.push("})()");
+            }
             s.type = "PatternMatchingStatement";
             s.children = [root];
           });
@@ -20770,10 +20793,10 @@ ${input.slice(result.pos)}
           addParentPointers(statements);
           processPipelineExpressions(statements);
           processAssignments(statements);
+          processPatternMatching(statements);
           processFunctions(statements);
           processSwitchExpressions(statements);
           processTryExpressions(statements);
-          processPatternMatching(statements);
           gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
           checkSpliceRef(statements);
           statements.unshift(...module.prelude);
@@ -20972,6 +20995,15 @@ ${input.slice(result.pos)}
         module.gatherBindingCode = gatherBindingCode;
         module.constructInvocation = function(fn, arg) {
           const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
+          if (fn.expr.ampersandBlock) {
+            const [ref, , prefix, rhs] = fn.expr.children;
+            ref.type = "PipedExpression";
+            ref.children = [module.makeLeftHandSideExpression(arg)];
+            return {
+              type: "UnwrappedExpression",
+              children: [module.skipIfOnlyWS(fn.leadingComment), prefix, rhs, module.skipIfOnlyWS(fn.trailingComment)]
+            };
+          }
           const lhs = module.makeLeftHandSideExpression(fn.expr);
           let comment = module.skipIfOnlyWS(fn.trailingComment);
           if (comment)
@@ -20981,10 +21013,7 @@ ${input.slice(result.pos)}
             lhs.children.splice(1, 0, comment);
           switch (arg.type) {
             case "CommaExpression":
-              arg = {
-                type: "ParenthesizedExpression",
-                children: ["(", arg, ")"]
-              };
+              arg = module.makeLeftHandSideExpression(arg);
               break;
           }
           return {

package/dist/main.js

@@ -3699,6 +3699,20 @@ ${input.slice(result.pos)}
         children: [start, [...ws, { ...sep, token: ", " }], [end, ...inc]]
       };
     });
+    var SliceParameters$2 = $TS($S(Loc, __, $C(DotDot, DotDotDot), $Y($S(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var l = $1;
+      var ws = $2;
+      const start = {
+        $loc: l.$loc,
+        token: "0"
+      };
+      return {
+        type: "SliceParameters",
+        start,
+        end: void 0,
+        children: [start, ws]
+      };
+    });
     function SliceParameters(state) {
       let eventData;
       if (state.events) {
@@ -3710,12 +3724,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state));
+        const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state));
         if (state.events)
           state.events.exit?.("SliceParameters", state, result, eventData);
         return result;
       } else {
-        const result = SliceParameters$0(state) || SliceParameters$1(state);
+        const result = SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state);
         if (state.events)
           state.events.exit?.("SliceParameters", state, result, eventData);
         return result;
@@ -5326,19 +5340,15 @@ ${input.slice(result.pos)}
         };
         return {
           type: "ArrowFunction",
-          children: [ref2, " => ", prefix, ref2]
+          children: [ref2, " => ", prefix, ref2],
+          ampersandBlock: true
         };
       }
       const { ref } = rhs;
-      if (!prefix) {
-        return {
-          type: "ArrowFunction",
-          children: [ref, " => ", rhs]
-        };
-      }
       return {
         type: "ArrowFunction",
-        children: [ref, " => ", prefix, rhs]
+        children: [ref, " => ", prefix, rhs],
+        ampersandBlock: true
       };
     });
     function FunctionExpression(state) {
@@ -9578,7 +9588,8 @@ ${input.slice(result.pos)}
       return {
         type: "SwitchExpression",
         children: ["(()=>{", e.children, "})()"],
-        caseBlock: e.children[2]
+        expression: e.expression,
+        caseBlock: e.caseBlock
       };
     });
     function SwitchExpression(state) {
@@ -13775,7 +13786,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var DotDot$0 = $TV($EXPECT($L114, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
+    var DotDot$0 = $TS($S($EXPECT($L114, fail, 'DotDot ".."'), $N($EXPECT($L4, fail, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function DotDot(state) {
@@ -19615,6 +19626,9 @@ ${input.slice(result.pos)}
             else
               exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
             return;
+          case "PatternMatchingStatement":
+            insertPush(exp.children[0][0], ref);
+            return;
           case "SwitchStatement":
             insertPush(exp.children[2], ref);
             return;
@@ -19702,6 +19716,9 @@ ${input.slice(result.pos)}
             else
               exp.children.push(["\n", indent, wrapWithReturn()]);
             return;
+          case "PatternMatchingStatement":
+            insertReturn(exp.children[0][0]);
+            return;
           case "SwitchStatement":
             insertSwitchReturns(exp);
             return;
@@ -20629,7 +20646,7 @@ ${input.slice(result.pos)}
         }
       }
       function processPatternMatching(statements) {
-        gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement").forEach((s) => {
+        gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
           const { caseBlock } = s;
           const { clauses } = caseBlock;
           let errors = false;
@@ -20708,15 +20725,21 @@ ${input.slice(result.pos)}
               block.children.push("}");
               block.bare = false;
             }
-            const e = i < l - 1 ? ["\nelse "] : [];
-            prev.push({
+            if (i < l - 1)
+              next.push("\n", "else ");
+            prev.push(["", {
               type: "IfStatement",
-              children: ["if", condition, block, ...e, next],
+              children: ["if", condition, block, next],
               then: block,
-              else: e
-            });
+              else: next
+            }]);
             prev = next;
           });
+          if (module2.config.implicitReturns && s.type === "SwitchExpression") {
+            insertReturn(root[0]);
+            root.unshift("(()=>{");
+            root.push("})()");
+          }
           s.type = "PatternMatchingStatement";
           s.children = [root];
         });
@@ -20769,10 +20792,10 @@ ${input.slice(result.pos)}
         addParentPointers(statements);
         processPipelineExpressions(statements);
         processAssignments(statements);
+        processPatternMatching(statements);
         processFunctions(statements);
         processSwitchExpressions(statements);
         processTryExpressions(statements);
-        processPatternMatching(statements);
         gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
         checkSpliceRef(statements);
         statements.unshift(...module2.prelude);
@@ -20971,6 +20994,15 @@ ${input.slice(result.pos)}
       module2.gatherBindingCode = gatherBindingCode;
       module2.constructInvocation = function(fn, arg) {
         const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
+        if (fn.expr.ampersandBlock) {
+          const [ref, , prefix, rhs] = fn.expr.children;
+          ref.type = "PipedExpression";
+          ref.children = [module2.makeLeftHandSideExpression(arg)];
+          return {
+            type: "UnwrappedExpression",
+            children: [module2.skipIfOnlyWS(fn.leadingComment), prefix, rhs, module2.skipIfOnlyWS(fn.trailingComment)]
+          };
+        }
         const lhs = module2.makeLeftHandSideExpression(fn.expr);
         let comment = module2.skipIfOnlyWS(fn.trailingComment);
         if (comment)
@@ -20980,10 +21012,7 @@ ${input.slice(result.pos)}
           lhs.children.splice(1, 0, comment);
         switch (arg.type) {
           case "CommaExpression":
-            arg = {
-              type: "ParenthesizedExpression",
-              children: ["(", arg, ")"]
-            };
+            arg = module2.makeLeftHandSideExpression(arg);
             break;
         }
         return {

package/dist/main.mjs

@@ -3697,6 +3697,20 @@ ${input.slice(result.pos)}
         children: [start, [...ws, { ...sep, token: ", " }], [end, ...inc]]
       };
     });
+    var SliceParameters$2 = $TS($S(Loc, __, $C(DotDot, DotDotDot), $Y($S(__, CloseBracket))), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var l = $1;
+      var ws = $2;
+      const start = {
+        $loc: l.$loc,
+        token: "0"
+      };
+      return {
+        type: "SliceParameters",
+        start,
+        end: void 0,
+        children: [start, ws]
+      };
+    });
     function SliceParameters(state) {
       let eventData;
       if (state.events) {
@@ -3708,12 +3722,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state));
+        const result = $TOKEN("SliceParameters", state, SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state));
         if (state.events)
           state.events.exit?.("SliceParameters", state, result, eventData);
         return result;
       } else {
-        const result = SliceParameters$0(state) || SliceParameters$1(state);
+        const result = SliceParameters$0(state) || SliceParameters$1(state) || SliceParameters$2(state);
         if (state.events)
           state.events.exit?.("SliceParameters", state, result, eventData);
         return result;
@@ -5324,19 +5338,15 @@ ${input.slice(result.pos)}
         };
         return {
           type: "ArrowFunction",
-          children: [ref2, " => ", prefix, ref2]
+          children: [ref2, " => ", prefix, ref2],
+          ampersandBlock: true
         };
       }
       const { ref } = rhs;
-      if (!prefix) {
-        return {
-          type: "ArrowFunction",
-          children: [ref, " => ", rhs]
-        };
-      }
       return {
         type: "ArrowFunction",
-        children: [ref, " => ", prefix, rhs]
+        children: [ref, " => ", prefix, rhs],
+        ampersandBlock: true
       };
     });
     function FunctionExpression(state) {
@@ -9576,7 +9586,8 @@ ${input.slice(result.pos)}
       return {
         type: "SwitchExpression",
         children: ["(()=>{", e.children, "})()"],
-        caseBlock: e.children[2]
+        expression: e.expression,
+        caseBlock: e.caseBlock
       };
     });
     function SwitchExpression(state) {
@@ -13773,7 +13784,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var DotDot$0 = $TV($EXPECT($L114, fail, 'DotDot ".."'), function($skip, $loc, $0, $1) {
+    var DotDot$0 = $TS($S($EXPECT($L114, fail, 'DotDot ".."'), $N($EXPECT($L4, fail, 'DotDot "."'))), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
     function DotDot(state) {
@@ -19613,6 +19624,9 @@ ${input.slice(result.pos)}
             else
               exp.children.push([" else {\n", indent, ref, ".push(undefined)\n", indent, "}"]);
             return;
+          case "PatternMatchingStatement":
+            insertPush(exp.children[0][0], ref);
+            return;
           case "SwitchStatement":
             insertPush(exp.children[2], ref);
             return;
@@ -19700,6 +19714,9 @@ ${input.slice(result.pos)}
             else
               exp.children.push(["\n", indent, wrapWithReturn()]);
             return;
+          case "PatternMatchingStatement":
+            insertReturn(exp.children[0][0]);
+            return;
           case "SwitchStatement":
             insertSwitchReturns(exp);
             return;
@@ -20627,7 +20644,7 @@ ${input.slice(result.pos)}
         }
       }
       function processPatternMatching(statements) {
-        gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement").forEach((s) => {
+        gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
           const { caseBlock } = s;
           const { clauses } = caseBlock;
           let errors = false;
@@ -20706,15 +20723,21 @@ ${input.slice(result.pos)}
               block.children.push("}");
               block.bare = false;
             }
-            const e = i < l - 1 ? ["\nelse "] : [];
-            prev.push({
+            if (i < l - 1)
+              next.push("\n", "else ");
+            prev.push(["", {
               type: "IfStatement",
-              children: ["if", condition, block, ...e, next],
+              children: ["if", condition, block, next],
               then: block,
-              else: e
-            });
+              else: next
+            }]);
             prev = next;
           });
+          if (module.config.implicitReturns && s.type === "SwitchExpression") {
+            insertReturn(root[0]);
+            root.unshift("(()=>{");
+            root.push("})()");
+          }
           s.type = "PatternMatchingStatement";
           s.children = [root];
         });
@@ -20767,10 +20790,10 @@ ${input.slice(result.pos)}
         addParentPointers(statements);
         processPipelineExpressions(statements);
         processAssignments(statements);
+        processPatternMatching(statements);
         processFunctions(statements);
         processSwitchExpressions(statements);
         processTryExpressions(statements);
-        processPatternMatching(statements);
         gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
         checkSpliceRef(statements);
         statements.unshift(...module.prelude);
@@ -20969,6 +20992,15 @@ ${input.slice(result.pos)}
       module.gatherBindingCode = gatherBindingCode;
       module.constructInvocation = function(fn, arg) {
         const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
+        if (fn.expr.ampersandBlock) {
+          const [ref, , prefix, rhs] = fn.expr.children;
+          ref.type = "PipedExpression";
+          ref.children = [module.makeLeftHandSideExpression(arg)];
+          return {
+            type: "UnwrappedExpression",
+            children: [module.skipIfOnlyWS(fn.leadingComment), prefix, rhs, module.skipIfOnlyWS(fn.trailingComment)]
+          };
+        }
         const lhs = module.makeLeftHandSideExpression(fn.expr);
         let comment = module.skipIfOnlyWS(fn.trailingComment);
         if (comment)
@@ -20978,10 +21010,7 @@ ${input.slice(result.pos)}
           lhs.children.splice(1, 0, comment);
         switch (arg.type) {
           case "CommaExpression":
-            arg = {
-              type: "ParenthesizedExpression",
-              children: ["(", arg, ")"]
-            };
+            arg = module.makeLeftHandSideExpression(arg);
             break;
         }
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.5.71",
+  "version": "0.5.72",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",