@danielx/civet 0.6.14 → 0.6.15

package/dist/browser.js

@@ -1148,6 +1148,7 @@ var Civet = (() => {
           case "AmpersandRef":
           case "Identifier":
           case "Literal":
+          case "IterationExpression":
           case "CallExpression":
           case "MemberExpression":
           case "ParenthesizedExpression":
@@ -1424,6 +1425,46 @@ var Civet = (() => {
         tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
       }
       function processAssignments(statements) {
+        gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
+          function extractAssignment(lhs) {
+            let expr = lhs;
+            while (expr.type === "ParenthesizedExpression") {
+              expr = expr.expression;
+            }
+            if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
+              if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
+                post.push([", ", lhs]);
+              } else {
+                pre.push([lhs, ", "]);
+              }
+              return expr.assigned;
+            }
+          }
+          const pre = [], post = [];
+          switch (exp.type) {
+            case "AssignmentExpression":
+              if (!exp.lhs)
+                return;
+              exp.lhs.forEach((lhsPart, i) => {
+                let newLhs2 = extractAssignment(lhsPart[1]);
+                if (newLhs2) {
+                  lhsPart[1] = newLhs2;
+                }
+              });
+              break;
+            case "UpdateExpression":
+              let newLhs = extractAssignment(exp.assigned);
+              if (newLhs) {
+                const i = exp.children.indexOf(exp.assigned);
+                exp.assigned = exp.children[i] = newLhs;
+              }
+              break;
+          }
+          if (pre.length)
+            exp.children.unshift(...pre);
+          if (post.length)
+            exp.children.push(...post);
+        });
         gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
           let { lhs: $1, exp: $2 } = exp, tail = [], i = 0, len = $1.length;
           if ($1.some((left) => left[left.length - 1].special)) {
@@ -1433,7 +1474,14 @@ var Civet = (() => {
             const [, lhs, , op] = $1[0];
             const { call } = op;
             op[op.length - 1] = "=";
-            $2 = [call, "(", lhs, ", ", $2, ")"];
+            const index2 = exp.children.indexOf($2);
+            if (index2 < 0)
+              throw new Error("Assertion error: exp not in AssignmentExpression");
+            exp.children.splice(
+              index2,
+              1,
+              exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
+            );
           }
           let wrapped = false;
           while (i < len) {
@@ -1484,49 +1532,11 @@ var Civet = (() => {
             }
             i--;
           }
-          const names = $1.flatMap(([, l]) => l.names || []);
-          exp.children = [$1, $2, ...tail];
-          exp.names = names;
-        });
-        gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
-          function extractAssignment(lhs) {
-            let expr = lhs;
-            while (expr.type === "ParenthesizedExpression") {
-              expr = expr.expression;
-            }
-            if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
-              if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
-                post.push([", ", lhs]);
-              } else {
-                pre.push([lhs, ", "]);
-              }
-              return expr.assigned;
-            }
-          }
-          const pre = [], post = [];
-          switch (exp.type) {
-            case "AssignmentExpression":
-              if (!exp.lhs)
-                return;
-              exp.lhs.forEach((lhsPart, i) => {
-                let newLhs2 = extractAssignment(lhsPart[1]);
-                if (newLhs2) {
-                  lhsPart[1] = newLhs2;
-                }
-              });
-              break;
-            case "UpdateExpression":
-              let newLhs = extractAssignment(exp.assigned);
-              if (newLhs) {
-                const i = exp.children.indexOf(exp.assigned);
-                exp.assigned = exp.children[i] = newLhs;
-              }
-              break;
-          }
-          if (pre.length)
-            exp.children.unshift(...pre);
-          if (post.length)
-            exp.children.push(...post);
+          exp.names = $1.flatMap(([, l]) => l.names || []);
+          const index = exp.children.indexOf($2);
+          if (index < 0)
+            throw new Error("Assertion error: exp not in AssignmentExpression");
+          exp.children.splice(index + 1, 0, ...tail);
         });
       }
       function attachPostfixStatementAsExpression(exp, post) {
@@ -1973,7 +1983,8 @@ var Civet = (() => {
                 });
               }
             } else {
-              s.children = children;
+              if (i === 0)
+                s.children = children;
             }
             if (returns && (ref = needsRef(arg))) {
               usingRef = usingRef || ref;
@@ -2963,6 +2974,7 @@ ${input.slice(result.pos)}
         NonPipelineExtendedExpression,
         NonAssignmentExtendedExpression,
         NestedNonAssignmentExtendedExpression,
+        ExpressionizedStatementWithTrailingCallExpressions,
         ExpressionizedStatement,
         Expression,
         Arguments,
@@ -2973,6 +2985,8 @@ ${input.slice(result.pos)}
         ArgumentsWithTrailingMemberExpressions,
         TrailingMemberExpressions,
         AllowedTrailingMemberExpressions,
+        TrailingCallExpressions,
+        AllowedTrailingCallExpressions,
         CommaDelimiter,
         ArgumentList,
         NonPipelineArgumentList,
@@ -4112,7 +4126,10 @@ ${input.slice(result.pos)}
         }
       }
       var NonAssignmentExtendedExpression$0 = NestedNonAssignmentExtendedExpression;
-      var NonAssignmentExtendedExpression$1 = $TS($S(__, ExpressionizedStatement), function($skip, $loc, $0, $1, $2) {
+      var NonAssignmentExtendedExpression$1 = $TS($S(__, ExpressionizedStatementWithTrailingCallExpressions), function($skip, $loc, $0, $1, $2) {
+        if ($2.length) {
+          return [...$1, ...$2];
+        }
         return {
           ...$2,
           children: [...$1, ...$2.children]
@@ -4140,11 +4157,17 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var NestedNonAssignmentExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatement)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var NestedNonAssignmentExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatementWithTrailingCallExpressions)), PopIndent, $E(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var expression = $3;
-        if (expression)
+        var trailing = $5;
+        if (!expression)
+          return $skip;
+        if (!trailing)
           return expression;
-        return $skip;
+        return {
+          type: "CallExpression",
+          children: [expression, ...trailing.flat()]
+        };
       });
       function NestedNonAssignmentExtendedExpression(state) {
         let eventData;
@@ -4168,6 +4191,39 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var ExpressionizedStatementWithTrailingCallExpressions$0 = $TS($S(ExpressionizedStatement, $E(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2) {
+        if (!$2)
+          return $1;
+        return {
+          type: "CallExpression",
+          children: [
+            makeLeftHandSideExpression($1),
+            $2
+          ]
+        };
+      });
+      function ExpressionizedStatementWithTrailingCallExpressions(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("ExpressionizedStatementWithTrailingCallExpressions", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("ExpressionizedStatementWithTrailingCallExpressions", state, ExpressionizedStatementWithTrailingCallExpressions$0(state));
+          if (state.events)
+            state.events.exit?.("ExpressionizedStatementWithTrailingCallExpressions", state, result, eventData);
+          return result;
+        } else {
+          const result = ExpressionizedStatementWithTrailingCallExpressions$0(state);
+          if (state.events)
+            state.events.exit?.("ExpressionizedStatementWithTrailingCallExpressions", state, result, eventData);
+          return result;
+        }
+      }
       var ExpressionizedStatement$0 = DebuggerExpression;
       var ExpressionizedStatement$1 = IfExpression;
       var ExpressionizedStatement$2 = UnlessExpression;
@@ -4453,6 +4509,54 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var TrailingCallExpressions$0 = $P($S($C(Samedent, IndentedFurther), $Y($S($E($EXPECT($L5, fail, 'TrailingCallExpressions "?"')), $EXPECT($L6, fail, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($R1, fail, "TrailingCallExpressions /[0-9]/"))))), $P(CallExpressionRest)));
+      function TrailingCallExpressions(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("TrailingCallExpressions", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("TrailingCallExpressions", state, TrailingCallExpressions$0(state));
+          if (state.events)
+            state.events.exit?.("TrailingCallExpressions", state, result, eventData);
+          return result;
+        } else {
+          const result = TrailingCallExpressions$0(state);
+          if (state.events)
+            state.events.exit?.("TrailingCallExpressions", state, result, eventData);
+          return result;
+        }
+      }
+      var AllowedTrailingCallExpressions$0 = $T($S(TrailingMemberPropertyAllowed, TrailingCallExpressions), function(value) {
+        return value[1];
+      });
+      function AllowedTrailingCallExpressions(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("AllowedTrailingCallExpressions", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("AllowedTrailingCallExpressions", state, AllowedTrailingCallExpressions$0(state));
+          if (state.events)
+            state.events.exit?.("AllowedTrailingCallExpressions", state, result, eventData);
+          return result;
+        } else {
+          const result = AllowedTrailingCallExpressions$0(state);
+          if (state.events)
+            state.events.exit?.("AllowedTrailingCallExpressions", state, result, eventData);
+          return result;
+        }
+      }
       var CommaDelimiter$0 = $S($E($C(Samedent, IndentedFurther)), $Q(_), Comma);
       function CommaDelimiter(state) {
         let eventData;
@@ -4760,7 +4864,7 @@ ${input.slice(result.pos)}
       }
       var RHS$0 = ParenthesizedAssignment;
       var RHS$1 = UnaryExpression;
-      var RHS$2 = ExpressionizedStatement;
+      var RHS$2 = ExpressionizedStatementWithTrailingCallExpressions;
       function RHS(state) {
         let eventData;
         if (state.events) {

package/dist/main.js

@@ -1147,6 +1147,7 @@ var require_lib = __commonJS({
         case "AmpersandRef":
         case "Identifier":
         case "Literal":
+        case "IterationExpression":
         case "CallExpression":
         case "MemberExpression":
         case "ParenthesizedExpression":
@@ -1423,6 +1424,46 @@ var require_lib = __commonJS({
       tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
     }
     function processAssignments(statements) {
+      gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
+        function extractAssignment(lhs) {
+          let expr = lhs;
+          while (expr.type === "ParenthesizedExpression") {
+            expr = expr.expression;
+          }
+          if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
+            if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
+              post.push([", ", lhs]);
+            } else {
+              pre.push([lhs, ", "]);
+            }
+            return expr.assigned;
+          }
+        }
+        const pre = [], post = [];
+        switch (exp.type) {
+          case "AssignmentExpression":
+            if (!exp.lhs)
+              return;
+            exp.lhs.forEach((lhsPart, i) => {
+              let newLhs2 = extractAssignment(lhsPart[1]);
+              if (newLhs2) {
+                lhsPart[1] = newLhs2;
+              }
+            });
+            break;
+          case "UpdateExpression":
+            let newLhs = extractAssignment(exp.assigned);
+            if (newLhs) {
+              const i = exp.children.indexOf(exp.assigned);
+              exp.assigned = exp.children[i] = newLhs;
+            }
+            break;
+        }
+        if (pre.length)
+          exp.children.unshift(...pre);
+        if (post.length)
+          exp.children.push(...post);
+      });
       gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
         let { lhs: $1, exp: $2 } = exp, tail = [], i = 0, len = $1.length;
         if ($1.some((left) => left[left.length - 1].special)) {
@@ -1432,7 +1473,14 @@ var require_lib = __commonJS({
           const [, lhs, , op] = $1[0];
           const { call } = op;
           op[op.length - 1] = "=";
-          $2 = [call, "(", lhs, ", ", $2, ")"];
+          const index2 = exp.children.indexOf($2);
+          if (index2 < 0)
+            throw new Error("Assertion error: exp not in AssignmentExpression");
+          exp.children.splice(
+            index2,
+            1,
+            exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
+          );
         }
         let wrapped = false;
         while (i < len) {
@@ -1483,49 +1531,11 @@ var require_lib = __commonJS({
           }
           i--;
         }
-        const names = $1.flatMap(([, l]) => l.names || []);
-        exp.children = [$1, $2, ...tail];
-        exp.names = names;
-      });
-      gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
-        function extractAssignment(lhs) {
-          let expr = lhs;
-          while (expr.type === "ParenthesizedExpression") {
-            expr = expr.expression;
-          }
-          if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
-            if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
-              post.push([", ", lhs]);
-            } else {
-              pre.push([lhs, ", "]);
-            }
-            return expr.assigned;
-          }
-        }
-        const pre = [], post = [];
-        switch (exp.type) {
-          case "AssignmentExpression":
-            if (!exp.lhs)
-              return;
-            exp.lhs.forEach((lhsPart, i) => {
-              let newLhs2 = extractAssignment(lhsPart[1]);
-              if (newLhs2) {
-                lhsPart[1] = newLhs2;
-              }
-            });
-            break;
-          case "UpdateExpression":
-            let newLhs = extractAssignment(exp.assigned);
-            if (newLhs) {
-              const i = exp.children.indexOf(exp.assigned);
-              exp.assigned = exp.children[i] = newLhs;
-            }
-            break;
-        }
-        if (pre.length)
-          exp.children.unshift(...pre);
-        if (post.length)
-          exp.children.push(...post);
+        exp.names = $1.flatMap(([, l]) => l.names || []);
+        const index = exp.children.indexOf($2);
+        if (index < 0)
+          throw new Error("Assertion error: exp not in AssignmentExpression");
+        exp.children.splice(index + 1, 0, ...tail);
       });
     }
     function attachPostfixStatementAsExpression(exp, post) {
@@ -1972,7 +1982,8 @@ var require_lib = __commonJS({
               });
             }
           } else {
-            s.children = children;
+            if (i === 0)
+              s.children = children;
           }
           if (returns && (ref = needsRef(arg))) {
             usingRef = usingRef || ref;
@@ -2962,6 +2973,7 @@ ${input.slice(result.pos)}
       NonPipelineExtendedExpression,
       NonAssignmentExtendedExpression,
       NestedNonAssignmentExtendedExpression,
+      ExpressionizedStatementWithTrailingCallExpressions,
       ExpressionizedStatement,
       Expression,
       Arguments,
@@ -2972,6 +2984,8 @@ ${input.slice(result.pos)}
       ArgumentsWithTrailingMemberExpressions,
       TrailingMemberExpressions,
       AllowedTrailingMemberExpressions,
+      TrailingCallExpressions,
+      AllowedTrailingCallExpressions,
       CommaDelimiter,
       ArgumentList,
       NonPipelineArgumentList,
@@ -4111,7 +4125,10 @@ ${input.slice(result.pos)}
       }
     }
     var NonAssignmentExtendedExpression$0 = NestedNonAssignmentExtendedExpression;
-    var NonAssignmentExtendedExpression$1 = $TS($S(__, ExpressionizedStatement), function($skip, $loc, $0, $1, $2) {
+    var NonAssignmentExtendedExpression$1 = $TS($S(__, ExpressionizedStatementWithTrailingCallExpressions), function($skip, $loc, $0, $1, $2) {
+      if ($2.length) {
+        return [...$1, ...$2];
+      }
       return {
         ...$2,
         children: [...$1, ...$2.children]
@@ -4139,11 +4156,17 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var NestedNonAssignmentExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatement)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var NestedNonAssignmentExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatementWithTrailingCallExpressions)), PopIndent, $E(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var expression = $3;
-      if (expression)
+      var trailing = $5;
+      if (!expression)
+        return $skip;
+      if (!trailing)
         return expression;
-      return $skip;
+      return {
+        type: "CallExpression",
+        children: [expression, ...trailing.flat()]
+      };
     });
     function NestedNonAssignmentExtendedExpression(state) {
       let eventData;
@@ -4167,6 +4190,39 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var ExpressionizedStatementWithTrailingCallExpressions$0 = $TS($S(ExpressionizedStatement, $E(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2) {
+      if (!$2)
+        return $1;
+      return {
+        type: "CallExpression",
+        children: [
+          makeLeftHandSideExpression($1),
+          $2
+        ]
+      };
+    });
+    function ExpressionizedStatementWithTrailingCallExpressions(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ExpressionizedStatementWithTrailingCallExpressions", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ExpressionizedStatementWithTrailingCallExpressions", state, ExpressionizedStatementWithTrailingCallExpressions$0(state));
+        if (state.events)
+          state.events.exit?.("ExpressionizedStatementWithTrailingCallExpressions", state, result, eventData);
+        return result;
+      } else {
+        const result = ExpressionizedStatementWithTrailingCallExpressions$0(state);
+        if (state.events)
+          state.events.exit?.("ExpressionizedStatementWithTrailingCallExpressions", state, result, eventData);
+        return result;
+      }
+    }
     var ExpressionizedStatement$0 = DebuggerExpression;
     var ExpressionizedStatement$1 = IfExpression;
     var ExpressionizedStatement$2 = UnlessExpression;
@@ -4452,6 +4508,54 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var TrailingCallExpressions$0 = $P($S($C(Samedent, IndentedFurther), $Y($S($E($EXPECT($L5, fail, 'TrailingCallExpressions "?"')), $EXPECT($L6, fail, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($R1, fail, "TrailingCallExpressions /[0-9]/"))))), $P(CallExpressionRest)));
+    function TrailingCallExpressions(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("TrailingCallExpressions", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("TrailingCallExpressions", state, TrailingCallExpressions$0(state));
+        if (state.events)
+          state.events.exit?.("TrailingCallExpressions", state, result, eventData);
+        return result;
+      } else {
+        const result = TrailingCallExpressions$0(state);
+        if (state.events)
+          state.events.exit?.("TrailingCallExpressions", state, result, eventData);
+        return result;
+      }
+    }
+    var AllowedTrailingCallExpressions$0 = $T($S(TrailingMemberPropertyAllowed, TrailingCallExpressions), function(value) {
+      return value[1];
+    });
+    function AllowedTrailingCallExpressions(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("AllowedTrailingCallExpressions", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("AllowedTrailingCallExpressions", state, AllowedTrailingCallExpressions$0(state));
+        if (state.events)
+          state.events.exit?.("AllowedTrailingCallExpressions", state, result, eventData);
+        return result;
+      } else {
+        const result = AllowedTrailingCallExpressions$0(state);
+        if (state.events)
+          state.events.exit?.("AllowedTrailingCallExpressions", state, result, eventData);
+        return result;
+      }
+    }
     var CommaDelimiter$0 = $S($E($C(Samedent, IndentedFurther)), $Q(_), Comma);
     function CommaDelimiter(state) {
       let eventData;
@@ -4759,7 +4863,7 @@ ${input.slice(result.pos)}
     }
     var RHS$0 = ParenthesizedAssignment;
     var RHS$1 = UnaryExpression;
-    var RHS$2 = ExpressionizedStatement;
+    var RHS$2 = ExpressionizedStatementWithTrailingCallExpressions;
     function RHS(state) {
       let eventData;
       if (state.events) {

package/dist/main.mjs

@@ -1145,6 +1145,7 @@ var require_lib = __commonJS({
         case "AmpersandRef":
         case "Identifier":
         case "Literal":
+        case "IterationExpression":
         case "CallExpression":
         case "MemberExpression":
         case "ParenthesizedExpression":
@@ -1421,6 +1422,46 @@ var require_lib = __commonJS({
       tail.push(...splices.map((s) => [", ", s]), ...thisAssignments.map((a) => [", ", a]));
     }
     function processAssignments(statements) {
+      gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
+        function extractAssignment(lhs) {
+          let expr = lhs;
+          while (expr.type === "ParenthesizedExpression") {
+            expr = expr.expression;
+          }
+          if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
+            if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
+              post.push([", ", lhs]);
+            } else {
+              pre.push([lhs, ", "]);
+            }
+            return expr.assigned;
+          }
+        }
+        const pre = [], post = [];
+        switch (exp.type) {
+          case "AssignmentExpression":
+            if (!exp.lhs)
+              return;
+            exp.lhs.forEach((lhsPart, i) => {
+              let newLhs2 = extractAssignment(lhsPart[1]);
+              if (newLhs2) {
+                lhsPart[1] = newLhs2;
+              }
+            });
+            break;
+          case "UpdateExpression":
+            let newLhs = extractAssignment(exp.assigned);
+            if (newLhs) {
+              const i = exp.children.indexOf(exp.assigned);
+              exp.assigned = exp.children[i] = newLhs;
+            }
+            break;
+        }
+        if (pre.length)
+          exp.children.unshift(...pre);
+        if (post.length)
+          exp.children.push(...post);
+      });
       gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" && n.names === null).forEach((exp) => {
         let { lhs: $1, exp: $2 } = exp, tail = [], i = 0, len = $1.length;
         if ($1.some((left) => left[left.length - 1].special)) {
@@ -1430,7 +1471,14 @@ var require_lib = __commonJS({
           const [, lhs, , op] = $1[0];
           const { call } = op;
           op[op.length - 1] = "=";
-          $2 = [call, "(", lhs, ", ", $2, ")"];
+          const index2 = exp.children.indexOf($2);
+          if (index2 < 0)
+            throw new Error("Assertion error: exp not in AssignmentExpression");
+          exp.children.splice(
+            index2,
+            1,
+            exp.exp = $2 = [call, "(", lhs, ", ", $2, ")"]
+          );
         }
         let wrapped = false;
         while (i < len) {
@@ -1481,49 +1529,11 @@ var require_lib = __commonJS({
           }
           i--;
         }
-        const names = $1.flatMap(([, l]) => l.names || []);
-        exp.children = [$1, $2, ...tail];
-        exp.names = names;
-      });
-      gatherRecursiveAll(statements, (n) => n.type === "AssignmentExpression" || n.type === "UpdateExpression").forEach((exp) => {
-        function extractAssignment(lhs) {
-          let expr = lhs;
-          while (expr.type === "ParenthesizedExpression") {
-            expr = expr.expression;
-          }
-          if (expr.type === "AssignmentExpression" || expr.type === "UpdateExpression") {
-            if (expr.type === "UpdateExpression" && expr.children[0] === expr.assigned) {
-              post.push([", ", lhs]);
-            } else {
-              pre.push([lhs, ", "]);
-            }
-            return expr.assigned;
-          }
-        }
-        const pre = [], post = [];
-        switch (exp.type) {
-          case "AssignmentExpression":
-            if (!exp.lhs)
-              return;
-            exp.lhs.forEach((lhsPart, i) => {
-              let newLhs2 = extractAssignment(lhsPart[1]);
-              if (newLhs2) {
-                lhsPart[1] = newLhs2;
-              }
-            });
-            break;
-          case "UpdateExpression":
-            let newLhs = extractAssignment(exp.assigned);
-            if (newLhs) {
-              const i = exp.children.indexOf(exp.assigned);
-              exp.assigned = exp.children[i] = newLhs;
-            }
-            break;
-        }
-        if (pre.length)
-          exp.children.unshift(...pre);
-        if (post.length)
-          exp.children.push(...post);
+        exp.names = $1.flatMap(([, l]) => l.names || []);
+        const index = exp.children.indexOf($2);
+        if (index < 0)
+          throw new Error("Assertion error: exp not in AssignmentExpression");
+        exp.children.splice(index + 1, 0, ...tail);
       });
     }
     function attachPostfixStatementAsExpression(exp, post) {
@@ -1970,7 +1980,8 @@ var require_lib = __commonJS({
               });
             }
           } else {
-            s.children = children;
+            if (i === 0)
+              s.children = children;
           }
           if (returns && (ref = needsRef(arg))) {
             usingRef = usingRef || ref;
@@ -2960,6 +2971,7 @@ ${input.slice(result.pos)}
       NonPipelineExtendedExpression,
       NonAssignmentExtendedExpression,
       NestedNonAssignmentExtendedExpression,
+      ExpressionizedStatementWithTrailingCallExpressions,
       ExpressionizedStatement,
       Expression,
       Arguments,
@@ -2970,6 +2982,8 @@ ${input.slice(result.pos)}
       ArgumentsWithTrailingMemberExpressions,
       TrailingMemberExpressions,
       AllowedTrailingMemberExpressions,
+      TrailingCallExpressions,
+      AllowedTrailingCallExpressions,
       CommaDelimiter,
       ArgumentList,
       NonPipelineArgumentList,
@@ -4109,7 +4123,10 @@ ${input.slice(result.pos)}
       }
     }
     var NonAssignmentExtendedExpression$0 = NestedNonAssignmentExtendedExpression;
-    var NonAssignmentExtendedExpression$1 = $TS($S(__, ExpressionizedStatement), function($skip, $loc, $0, $1, $2) {
+    var NonAssignmentExtendedExpression$1 = $TS($S(__, ExpressionizedStatementWithTrailingCallExpressions), function($skip, $loc, $0, $1, $2) {
+      if ($2.length) {
+        return [...$1, ...$2];
+      }
       return {
         ...$2,
         children: [...$1, ...$2.children]
@@ -4137,11 +4154,17 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var NestedNonAssignmentExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatement)), PopIndent), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var NestedNonAssignmentExtendedExpression$0 = $TS($S($Y(EOS), PushIndent, $E($S(Nested, ExpressionizedStatementWithTrailingCallExpressions)), PopIndent, $E(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var expression = $3;
-      if (expression)
+      var trailing = $5;
+      if (!expression)
+        return $skip;
+      if (!trailing)
         return expression;
-      return $skip;
+      return {
+        type: "CallExpression",
+        children: [expression, ...trailing.flat()]
+      };
     });
     function NestedNonAssignmentExtendedExpression(state) {
       let eventData;
@@ -4165,6 +4188,39 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var ExpressionizedStatementWithTrailingCallExpressions$0 = $TS($S(ExpressionizedStatement, $E(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2) {
+      if (!$2)
+        return $1;
+      return {
+        type: "CallExpression",
+        children: [
+          makeLeftHandSideExpression($1),
+          $2
+        ]
+      };
+    });
+    function ExpressionizedStatementWithTrailingCallExpressions(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ExpressionizedStatementWithTrailingCallExpressions", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ExpressionizedStatementWithTrailingCallExpressions", state, ExpressionizedStatementWithTrailingCallExpressions$0(state));
+        if (state.events)
+          state.events.exit?.("ExpressionizedStatementWithTrailingCallExpressions", state, result, eventData);
+        return result;
+      } else {
+        const result = ExpressionizedStatementWithTrailingCallExpressions$0(state);
+        if (state.events)
+          state.events.exit?.("ExpressionizedStatementWithTrailingCallExpressions", state, result, eventData);
+        return result;
+      }
+    }
     var ExpressionizedStatement$0 = DebuggerExpression;
     var ExpressionizedStatement$1 = IfExpression;
     var ExpressionizedStatement$2 = UnlessExpression;
@@ -4450,6 +4506,54 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var TrailingCallExpressions$0 = $P($S($C(Samedent, IndentedFurther), $Y($S($E($EXPECT($L5, fail, 'TrailingCallExpressions "?"')), $EXPECT($L6, fail, 'TrailingCallExpressions "."'), $N($R$0($EXPECT($R1, fail, "TrailingCallExpressions /[0-9]/"))))), $P(CallExpressionRest)));
+    function TrailingCallExpressions(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("TrailingCallExpressions", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("TrailingCallExpressions", state, TrailingCallExpressions$0(state));
+        if (state.events)
+          state.events.exit?.("TrailingCallExpressions", state, result, eventData);
+        return result;
+      } else {
+        const result = TrailingCallExpressions$0(state);
+        if (state.events)
+          state.events.exit?.("TrailingCallExpressions", state, result, eventData);
+        return result;
+      }
+    }
+    var AllowedTrailingCallExpressions$0 = $T($S(TrailingMemberPropertyAllowed, TrailingCallExpressions), function(value) {
+      return value[1];
+    });
+    function AllowedTrailingCallExpressions(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("AllowedTrailingCallExpressions", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("AllowedTrailingCallExpressions", state, AllowedTrailingCallExpressions$0(state));
+        if (state.events)
+          state.events.exit?.("AllowedTrailingCallExpressions", state, result, eventData);
+        return result;
+      } else {
+        const result = AllowedTrailingCallExpressions$0(state);
+        if (state.events)
+          state.events.exit?.("AllowedTrailingCallExpressions", state, result, eventData);
+        return result;
+      }
+    }
     var CommaDelimiter$0 = $S($E($C(Samedent, IndentedFurther)), $Q(_), Comma);
     function CommaDelimiter(state) {
       let eventData;
@@ -4757,7 +4861,7 @@ ${input.slice(result.pos)}
     }
     var RHS$0 = ParenthesizedAssignment;
     var RHS$1 = UnaryExpression;
-    var RHS$2 = ExpressionizedStatement;
+    var RHS$2 = ExpressionizedStatementWithTrailingCallExpressions;
     function RHS(state) {
       let eventData;
       if (state.events) {

package/package.json

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