@danielx/civet 0.5.30 → 0.5.31

package/dist/browser.js

@@ -529,6 +529,8 @@ ${input.slice(result.pos)}
         FunctionDeclaration,
         FunctionSignature,
         FunctionExpression,
+        AmpersandBlockRHS,
+        AmpersandUnaryPrefix,
         ThinArrowFunction,
         Arrow,
         ExplicitBlock,
@@ -637,6 +639,7 @@ ${input.slice(result.pos)}
         NoExpressions,
         ImpliedColon,
         TryStatement,
+        TryExpression,
         CatchClause,
         CatchBind,
         Finally,
@@ -1296,6 +1299,7 @@ ${input.slice(result.pos)}
       var ExpressionizedStatement$3 = IterationExpression;
       var ExpressionizedStatement$4 = SwitchExpression;
       var ExpressionizedStatement$5 = ThrowExpression;
+      var ExpressionizedStatement$6 = TryExpression;
       function ExpressionizedStatement(state) {
         let eventData;
         if (state.events) {
@@ -1307,12 +1311,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state));
+          const result = $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state) || ExpressionizedStatement$6(state));
           if (state.events)
             state.events.exit?.("ExpressionizedStatement", state, result, eventData);
           return result;
         } else {
-          const result = ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state);
+          const result = ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state) || ExpressionizedStatement$6(state);
           if (state.events)
             state.events.exit?.("ExpressionizedStatement", state, result, eventData);
           return result;
@@ -4285,25 +4289,32 @@ ${input.slice(result.pos)}
           block
         };
       });
-      var FunctionExpression$1 = $TS($S(Ampersand, $N(_), $P(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
-        $1.token = "$ => $";
-        return {
-          type: "ArrowFunction",
-          children: [$1, $3]
-        };
-      });
-      var FunctionExpression$2 = $TS($S(Ampersand, $N($EXPECT($R1, fail, "FunctionExpression /[&]/")), $P(BinaryOpRHS)), function($skip, $loc, $0, $1, $2, $3) {
-        $1.token = "$ => $";
-        const exp = module.processBinaryOpExpression([$1, $3]);
-        return {
-          type: "ArrowFunction",
-          children: exp
-        };
-      });
-      var FunctionExpression$3 = $TS($S($EXPECT($R2, fail, "FunctionExpression /[!~+-]+/"), Ampersand), function($skip, $loc, $0, $1, $2) {
+      var FunctionExpression$1 = $TS($S($E(AmpersandUnaryPrefix), Ampersand, $E(AmpersandBlockRHS)), function($skip, $loc, $0, $1, $2, $3) {
+        var prefix = $1;
+        var rhs = $3;
+        if (!prefix && !rhs)
+          return $skip;
+        if (!rhs) {
+          const ref2 = {
+            type: "Ref",
+            base: "$",
+            id: "$"
+          };
+          return {
+            type: "ArrowFunction",
+            children: [ref2, " => ", prefix, ref2]
+          };
+        }
+        const { ref } = rhs;
+        if (!prefix) {
+          return {
+            type: "ArrowFunction",
+            children: [ref, " => ", rhs]
+          };
+        }
         return {
           type: "ArrowFunction",
-          children: ["$ => ", $1, "$"]
+          children: [ref, " => ", prefix, rhs]
         };
       });
       function FunctionExpression(state) {
@@ -4317,17 +4328,89 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state));
+          const result = $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
           if (state.events)
             state.events.exit?.("FunctionExpression", state, result, eventData);
           return result;
         } else {
-          const result = FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state);
+          const result = FunctionExpression$0(state) || FunctionExpression$1(state);
           if (state.events)
             state.events.exit?.("FunctionExpression", state, result, eventData);
           return result;
         }
       }
+      var AmpersandBlockRHS$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E($S($N($EXPECT($R1, fail, "AmpersandBlockRHS /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2) {
+        var callExpRest = $1;
+        var binopRHS = $2;
+        if (!callExpRest && !binopRHS)
+          return $skip;
+        const ref = {
+          type: "Ref",
+          base: "$",
+          id: "$"
+        };
+        const exp = {
+          type: "AmpersandRef",
+          children: [ref],
+          names: [],
+          ref
+        };
+        if (callExpRest) {
+          exp.children.push(...callExpRest[1]);
+        }
+        if (binopRHS) {
+          return {
+            children: module.processBinaryOpExpression([exp, binopRHS[1]]),
+            ref
+          };
+        }
+        return exp;
+      });
+      function AmpersandBlockRHS(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("AmpersandBlockRHS", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("AmpersandBlockRHS", state, AmpersandBlockRHS$0(state));
+          if (state.events)
+            state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+          return result;
+        } else {
+          const result = AmpersandBlockRHS$0(state);
+          if (state.events)
+            state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+          return result;
+        }
+      }
+      var AmpersandUnaryPrefix$0 = $R$0($EXPECT($R2, fail, "AmpersandUnaryPrefix /[!~+-]+/"));
+      function AmpersandUnaryPrefix(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("AmpersandUnaryPrefix", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("AmpersandUnaryPrefix", state, AmpersandUnaryPrefix$0(state));
+          if (state.events)
+            state.events.exit?.("AmpersandUnaryPrefix", state, result, eventData);
+          return result;
+        } else {
+          const result = AmpersandUnaryPrefix$0(state);
+          if (state.events)
+            state.events.exit?.("AmpersandUnaryPrefix", state, result, eventData);
+          return result;
+        }
+      }
       var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), $Q(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var parameters = $1;
         var suffix = $2;
@@ -8115,6 +8198,36 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var TryExpression$0 = $TV(TryStatement, function($skip, $loc, $0, $1) {
+        var t = $0;
+        return {
+          type: "TryExpression",
+          blocks: [t.children[1], t.children[2]?.[3]],
+          children: ["(()=>{", t, "})()"]
+        };
+      });
+      function TryExpression(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("TryExpression", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("TryExpression", state, TryExpression$0(state));
+          if (state.events)
+            state.events.exit?.("TryExpression", state, result, eventData);
+          return result;
+        } else {
+          const result = TryExpression$0(state);
+          if (state.events)
+            state.events.exit?.("TryExpression", state, result, eventData);
+          return result;
+        }
+      }
       var CatchClause$0 = $S(__, Catch, $E(CatchBind), BracedBlock);
       function CatchClause(state) {
         let eventData;
@@ -16704,6 +16817,13 @@ ${input.slice(result.pos)}
             });
           }
         }
+        function processTryExpressions(statements) {
+          if (module.config.implicitReturns) {
+            gatherRecursiveAll(statements, (n) => n.type === "TryExpression").forEach(({ blocks }) => {
+              blocks.forEach(insertReturn);
+            });
+          }
+        }
         function processBindingPatternLHS(lhs, tail) {
           adjustAtBindings(lhs, true);
           const [splices, thisAssignments] = module.gatherBindingCode(lhs);
@@ -16823,6 +16943,7 @@ ${input.slice(result.pos)}
           processAssignments(statements);
           processFunctions(statements);
           processSwitchExpressions(statements);
+          processTryExpressions(statements);
           gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
           checkSpliceRef(statements);
           statements.unshift(...module.prelude);

package/dist/main.js

@@ -528,6 +528,8 @@ ${input.slice(result.pos)}
       FunctionDeclaration,
       FunctionSignature,
       FunctionExpression,
+      AmpersandBlockRHS,
+      AmpersandUnaryPrefix,
       ThinArrowFunction,
       Arrow,
       ExplicitBlock,
@@ -636,6 +638,7 @@ ${input.slice(result.pos)}
       NoExpressions,
       ImpliedColon,
       TryStatement,
+      TryExpression,
       CatchClause,
       CatchBind,
       Finally,
@@ -1295,6 +1298,7 @@ ${input.slice(result.pos)}
     var ExpressionizedStatement$3 = IterationExpression;
     var ExpressionizedStatement$4 = SwitchExpression;
     var ExpressionizedStatement$5 = ThrowExpression;
+    var ExpressionizedStatement$6 = TryExpression;
     function ExpressionizedStatement(state) {
       let eventData;
       if (state.events) {
@@ -1306,12 +1310,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state));
+        const result = $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state) || ExpressionizedStatement$6(state));
         if (state.events)
           state.events.exit?.("ExpressionizedStatement", state, result, eventData);
         return result;
       } else {
-        const result = ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state);
+        const result = ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state) || ExpressionizedStatement$6(state);
         if (state.events)
           state.events.exit?.("ExpressionizedStatement", state, result, eventData);
         return result;
@@ -4284,25 +4288,32 @@ ${input.slice(result.pos)}
         block
       };
     });
-    var FunctionExpression$1 = $TS($S(Ampersand, $N(_), $P(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
-      $1.token = "$ => $";
-      return {
-        type: "ArrowFunction",
-        children: [$1, $3]
-      };
-    });
-    var FunctionExpression$2 = $TS($S(Ampersand, $N($EXPECT($R1, fail, "FunctionExpression /[&]/")), $P(BinaryOpRHS)), function($skip, $loc, $0, $1, $2, $3) {
-      $1.token = "$ => $";
-      const exp = module2.processBinaryOpExpression([$1, $3]);
-      return {
-        type: "ArrowFunction",
-        children: exp
-      };
-    });
-    var FunctionExpression$3 = $TS($S($EXPECT($R2, fail, "FunctionExpression /[!~+-]+/"), Ampersand), function($skip, $loc, $0, $1, $2) {
+    var FunctionExpression$1 = $TS($S($E(AmpersandUnaryPrefix), Ampersand, $E(AmpersandBlockRHS)), function($skip, $loc, $0, $1, $2, $3) {
+      var prefix = $1;
+      var rhs = $3;
+      if (!prefix && !rhs)
+        return $skip;
+      if (!rhs) {
+        const ref2 = {
+          type: "Ref",
+          base: "$",
+          id: "$"
+        };
+        return {
+          type: "ArrowFunction",
+          children: [ref2, " => ", prefix, ref2]
+        };
+      }
+      const { ref } = rhs;
+      if (!prefix) {
+        return {
+          type: "ArrowFunction",
+          children: [ref, " => ", rhs]
+        };
+      }
       return {
         type: "ArrowFunction",
-        children: ["$ => ", $1, "$"]
+        children: [ref, " => ", prefix, rhs]
       };
     });
     function FunctionExpression(state) {
@@ -4316,17 +4327,89 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state));
+        const result = $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
         if (state.events)
           state.events.exit?.("FunctionExpression", state, result, eventData);
         return result;
       } else {
-        const result = FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state);
+        const result = FunctionExpression$0(state) || FunctionExpression$1(state);
         if (state.events)
           state.events.exit?.("FunctionExpression", state, result, eventData);
         return result;
       }
     }
+    var AmpersandBlockRHS$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E($S($N($EXPECT($R1, fail, "AmpersandBlockRHS /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2) {
+      var callExpRest = $1;
+      var binopRHS = $2;
+      if (!callExpRest && !binopRHS)
+        return $skip;
+      const ref = {
+        type: "Ref",
+        base: "$",
+        id: "$"
+      };
+      const exp = {
+        type: "AmpersandRef",
+        children: [ref],
+        names: [],
+        ref
+      };
+      if (callExpRest) {
+        exp.children.push(...callExpRest[1]);
+      }
+      if (binopRHS) {
+        return {
+          children: module2.processBinaryOpExpression([exp, binopRHS[1]]),
+          ref
+        };
+      }
+      return exp;
+    });
+    function AmpersandBlockRHS(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("AmpersandBlockRHS", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("AmpersandBlockRHS", state, AmpersandBlockRHS$0(state));
+        if (state.events)
+          state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+        return result;
+      } else {
+        const result = AmpersandBlockRHS$0(state);
+        if (state.events)
+          state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+        return result;
+      }
+    }
+    var AmpersandUnaryPrefix$0 = $R$0($EXPECT($R2, fail, "AmpersandUnaryPrefix /[!~+-]+/"));
+    function AmpersandUnaryPrefix(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("AmpersandUnaryPrefix", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("AmpersandUnaryPrefix", state, AmpersandUnaryPrefix$0(state));
+        if (state.events)
+          state.events.exit?.("AmpersandUnaryPrefix", state, result, eventData);
+        return result;
+      } else {
+        const result = AmpersandUnaryPrefix$0(state);
+        if (state.events)
+          state.events.exit?.("AmpersandUnaryPrefix", state, result, eventData);
+        return result;
+      }
+    }
     var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), $Q(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var parameters = $1;
       var suffix = $2;
@@ -8114,6 +8197,36 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var TryExpression$0 = $TV(TryStatement, function($skip, $loc, $0, $1) {
+      var t = $0;
+      return {
+        type: "TryExpression",
+        blocks: [t.children[1], t.children[2]?.[3]],
+        children: ["(()=>{", t, "})()"]
+      };
+    });
+    function TryExpression(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("TryExpression", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("TryExpression", state, TryExpression$0(state));
+        if (state.events)
+          state.events.exit?.("TryExpression", state, result, eventData);
+        return result;
+      } else {
+        const result = TryExpression$0(state);
+        if (state.events)
+          state.events.exit?.("TryExpression", state, result, eventData);
+        return result;
+      }
+    }
     var CatchClause$0 = $S(__, Catch, $E(CatchBind), BracedBlock);
     function CatchClause(state) {
       let eventData;
@@ -16703,6 +16816,13 @@ ${input.slice(result.pos)}
           });
         }
       }
+      function processTryExpressions(statements) {
+        if (module2.config.implicitReturns) {
+          gatherRecursiveAll(statements, (n) => n.type === "TryExpression").forEach(({ blocks }) => {
+            blocks.forEach(insertReturn);
+          });
+        }
+      }
       function processBindingPatternLHS(lhs, tail) {
         adjustAtBindings(lhs, true);
         const [splices, thisAssignments] = module2.gatherBindingCode(lhs);
@@ -16822,6 +16942,7 @@ ${input.slice(result.pos)}
         processAssignments(statements);
         processFunctions(statements);
         processSwitchExpressions(statements);
+        processTryExpressions(statements);
         gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
         checkSpliceRef(statements);
         statements.unshift(...module2.prelude);

package/dist/main.mjs

@@ -526,6 +526,8 @@ ${input.slice(result.pos)}
       FunctionDeclaration,
       FunctionSignature,
       FunctionExpression,
+      AmpersandBlockRHS,
+      AmpersandUnaryPrefix,
       ThinArrowFunction,
       Arrow,
       ExplicitBlock,
@@ -634,6 +636,7 @@ ${input.slice(result.pos)}
       NoExpressions,
       ImpliedColon,
       TryStatement,
+      TryExpression,
       CatchClause,
       CatchBind,
       Finally,
@@ -1293,6 +1296,7 @@ ${input.slice(result.pos)}
     var ExpressionizedStatement$3 = IterationExpression;
     var ExpressionizedStatement$4 = SwitchExpression;
     var ExpressionizedStatement$5 = ThrowExpression;
+    var ExpressionizedStatement$6 = TryExpression;
     function ExpressionizedStatement(state) {
       let eventData;
       if (state.events) {
@@ -1304,12 +1308,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state));
+        const result = $TOKEN("ExpressionizedStatement", state, ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state) || ExpressionizedStatement$6(state));
         if (state.events)
           state.events.exit?.("ExpressionizedStatement", state, result, eventData);
         return result;
       } else {
-        const result = ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state);
+        const result = ExpressionizedStatement$0(state) || ExpressionizedStatement$1(state) || ExpressionizedStatement$2(state) || ExpressionizedStatement$3(state) || ExpressionizedStatement$4(state) || ExpressionizedStatement$5(state) || ExpressionizedStatement$6(state);
         if (state.events)
           state.events.exit?.("ExpressionizedStatement", state, result, eventData);
         return result;
@@ -4282,25 +4286,32 @@ ${input.slice(result.pos)}
         block
       };
     });
-    var FunctionExpression$1 = $TS($S(Ampersand, $N(_), $P(CallExpressionRest)), function($skip, $loc, $0, $1, $2, $3) {
-      $1.token = "$ => $";
-      return {
-        type: "ArrowFunction",
-        children: [$1, $3]
-      };
-    });
-    var FunctionExpression$2 = $TS($S(Ampersand, $N($EXPECT($R1, fail, "FunctionExpression /[&]/")), $P(BinaryOpRHS)), function($skip, $loc, $0, $1, $2, $3) {
-      $1.token = "$ => $";
-      const exp = module.processBinaryOpExpression([$1, $3]);
-      return {
-        type: "ArrowFunction",
-        children: exp
-      };
-    });
-    var FunctionExpression$3 = $TS($S($EXPECT($R2, fail, "FunctionExpression /[!~+-]+/"), Ampersand), function($skip, $loc, $0, $1, $2) {
+    var FunctionExpression$1 = $TS($S($E(AmpersandUnaryPrefix), Ampersand, $E(AmpersandBlockRHS)), function($skip, $loc, $0, $1, $2, $3) {
+      var prefix = $1;
+      var rhs = $3;
+      if (!prefix && !rhs)
+        return $skip;
+      if (!rhs) {
+        const ref2 = {
+          type: "Ref",
+          base: "$",
+          id: "$"
+        };
+        return {
+          type: "ArrowFunction",
+          children: [ref2, " => ", prefix, ref2]
+        };
+      }
+      const { ref } = rhs;
+      if (!prefix) {
+        return {
+          type: "ArrowFunction",
+          children: [ref, " => ", rhs]
+        };
+      }
       return {
         type: "ArrowFunction",
-        children: ["$ => ", $1, "$"]
+        children: [ref, " => ", prefix, rhs]
       };
     });
     function FunctionExpression(state) {
@@ -4314,17 +4325,89 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state));
+        const result = $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
         if (state.events)
           state.events.exit?.("FunctionExpression", state, result, eventData);
         return result;
       } else {
-        const result = FunctionExpression$0(state) || FunctionExpression$1(state) || FunctionExpression$2(state) || FunctionExpression$3(state);
+        const result = FunctionExpression$0(state) || FunctionExpression$1(state);
         if (state.events)
           state.events.exit?.("FunctionExpression", state, result, eventData);
         return result;
       }
     }
+    var AmpersandBlockRHS$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E($S($N($EXPECT($R1, fail, "AmpersandBlockRHS /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2) {
+      var callExpRest = $1;
+      var binopRHS = $2;
+      if (!callExpRest && !binopRHS)
+        return $skip;
+      const ref = {
+        type: "Ref",
+        base: "$",
+        id: "$"
+      };
+      const exp = {
+        type: "AmpersandRef",
+        children: [ref],
+        names: [],
+        ref
+      };
+      if (callExpRest) {
+        exp.children.push(...callExpRest[1]);
+      }
+      if (binopRHS) {
+        return {
+          children: module.processBinaryOpExpression([exp, binopRHS[1]]),
+          ref
+        };
+      }
+      return exp;
+    });
+    function AmpersandBlockRHS(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("AmpersandBlockRHS", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("AmpersandBlockRHS", state, AmpersandBlockRHS$0(state));
+        if (state.events)
+          state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+        return result;
+      } else {
+        const result = AmpersandBlockRHS$0(state);
+        if (state.events)
+          state.events.exit?.("AmpersandBlockRHS", state, result, eventData);
+        return result;
+      }
+    }
+    var AmpersandUnaryPrefix$0 = $R$0($EXPECT($R2, fail, "AmpersandUnaryPrefix /[!~+-]+/"));
+    function AmpersandUnaryPrefix(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("AmpersandUnaryPrefix", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("AmpersandUnaryPrefix", state, AmpersandUnaryPrefix$0(state));
+        if (state.events)
+          state.events.exit?.("AmpersandUnaryPrefix", state, result, eventData);
+        return result;
+      } else {
+        const result = AmpersandUnaryPrefix$0(state);
+        if (state.events)
+          state.events.exit?.("AmpersandUnaryPrefix", state, result, eventData);
+        return result;
+      }
+    }
     var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), $Q(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var parameters = $1;
       var suffix = $2;
@@ -8112,6 +8195,36 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var TryExpression$0 = $TV(TryStatement, function($skip, $loc, $0, $1) {
+      var t = $0;
+      return {
+        type: "TryExpression",
+        blocks: [t.children[1], t.children[2]?.[3]],
+        children: ["(()=>{", t, "})()"]
+      };
+    });
+    function TryExpression(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("TryExpression", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("TryExpression", state, TryExpression$0(state));
+        if (state.events)
+          state.events.exit?.("TryExpression", state, result, eventData);
+        return result;
+      } else {
+        const result = TryExpression$0(state);
+        if (state.events)
+          state.events.exit?.("TryExpression", state, result, eventData);
+        return result;
+      }
+    }
     var CatchClause$0 = $S(__, Catch, $E(CatchBind), BracedBlock);
     function CatchClause(state) {
       let eventData;
@@ -16701,6 +16814,13 @@ ${input.slice(result.pos)}
           });
         }
       }
+      function processTryExpressions(statements) {
+        if (module.config.implicitReturns) {
+          gatherRecursiveAll(statements, (n) => n.type === "TryExpression").forEach(({ blocks }) => {
+            blocks.forEach(insertReturn);
+          });
+        }
+      }
       function processBindingPatternLHS(lhs, tail) {
         adjustAtBindings(lhs, true);
         const [splices, thisAssignments] = module.gatherBindingCode(lhs);
@@ -16820,6 +16940,7 @@ ${input.slice(result.pos)}
         processAssignments(statements);
         processFunctions(statements);
         processSwitchExpressions(statements);
+        processTryExpressions(statements);
         gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
         checkSpliceRef(statements);
         statements.unshift(...module.prelude);

package/package.json

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