@danielx/civet 0.6.14 → 0.6.16

package/dist/browser.js

@@ -745,12 +745,15 @@ var Civet = (() => {
         }
       }
       function findAncestor(node, predicate, stopPredicate) {
-        node = node.parent;
-        while (node && !stopPredicate?.(node)) {
-          if (predicate(node))
-            return node;
-          node = node.parent;
+        let { parent } = node;
+        while (parent && !stopPredicate?.(parent, node)) {
+          if (predicate(parent, node)) {
+            return { ancestor: parent, child: node };
+          }
+          node = parent;
+          parent = node.parent;
         }
+        return { ancestor: void 0, child: node };
       }
       function gatherNodes(node, predicate) {
         if (node == null)
@@ -823,14 +826,11 @@ var Civet = (() => {
       }
       function hoistRefDecs(statements) {
         gatherRecursiveAll(statements, (s) => s.hoistDec).forEach((node) => {
-          let { hoistDec, parent } = node;
+          let { hoistDec } = node;
           node.hoistDec = null;
-          while (parent?.type !== "BlockStatement" || parent.bare && !parent.root) {
-            node = parent;
-            parent = node.parent;
-          }
-          if (parent) {
-            insertHoistDec(parent, node, hoistDec);
+          const { ancestor, child } = findAncestor(node, (ancestor2) => ancestor2.type === "BlockStatement" && (!ancestor2.bare || ancestor2.root));
+          if (ancestor) {
+            insertHoistDec(ancestor, child, hoistDec);
           } else {
             throw new Error("Couldn't find block to hoist declaration into.");
           }
@@ -1148,6 +1148,7 @@ var Civet = (() => {
           case "AmpersandRef":
           case "Identifier":
           case "Literal":
+          case "IterationExpression":
           case "CallExpression":
           case "MemberExpression":
           case "ParenthesizedExpression":
@@ -1369,6 +1370,8 @@ var Civet = (() => {
         if (f.abstract || f.block || f.signature?.optional)
           return;
         const { name, parent } = f;
+        if (parent?.type === "ExportDeclaration")
+          return;
         const expressions = parent?.expressions ?? parent?.elements;
         const currentIndex = expressions?.findIndex(([, def]) => def === f);
         const following = currentIndex >= 0 && expressions[currentIndex + 1]?.[1];
@@ -1424,6 +1427,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 +1476,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 +1534,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 +1985,8 @@ var Civet = (() => {
                 });
               }
             } else {
-              s.children = children;
+              if (i === 0)
+                s.children = children;
             }
             if (returns && (ref = needsRef(arg))) {
               usingRef = usingRef || ref;
@@ -2216,7 +2229,7 @@ var Civet = (() => {
         let declared;
         values.forEach((value) => {
           value.children = [ref];
-          const ancestor = findAncestor(
+          const { ancestor } = findAncestor(
             value,
             ({ type }) => type === "Declaration",
             isFunction
@@ -2963,6 +2976,7 @@ ${input.slice(result.pos)}
         NonPipelineExtendedExpression,
         NonAssignmentExtendedExpression,
         NestedNonAssignmentExtendedExpression,
+        ExpressionizedStatementWithTrailingCallExpressions,
         ExpressionizedStatement,
         Expression,
         Arguments,
@@ -2973,6 +2987,8 @@ ${input.slice(result.pos)}
         ArgumentsWithTrailingMemberExpressions,
         TrailingMemberExpressions,
         AllowedTrailingMemberExpressions,
+        TrailingCallExpressions,
+        AllowedTrailingCallExpressions,
         CommaDelimiter,
         ArgumentList,
         NonPipelineArgumentList,
@@ -4112,7 +4128,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 +4159,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 +4193,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 +4511,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 +4866,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) {
@@ -14628,14 +14734,15 @@ ${input.slice(result.pos)}
         }
       }
       var ExportDeclaration$0 = $TS($S($E(Decorators), Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-        return { type: "ExportDeclaration", children: $0 };
+        var declaration = $6;
+        return { type: "ExportDeclaration", declaration, children: $0 };
       });
       var ExportDeclaration$1 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         return { type: "ExportDeclaration", ts: $3.ts, children: $0 };
       });
       var ExportDeclaration$2 = $TS($S($E(Decorators), Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3, $4) {
-        var decl = $4;
-        return { type: "ExportDeclaration", ts: decl.ts, children: $0 };
+        var declaration = $4;
+        return { type: "ExportDeclaration", declaration, ts: declaration.ts, children: $0 };
       });
       function ExportDeclaration(state) {
         let eventData;

package/dist/main.js

@@ -744,12 +744,15 @@ var require_lib = __commonJS({
       }
     }
     function findAncestor(node, predicate, stopPredicate) {
-      node = node.parent;
-      while (node && !stopPredicate?.(node)) {
-        if (predicate(node))
-          return node;
-        node = node.parent;
+      let { parent } = node;
+      while (parent && !stopPredicate?.(parent, node)) {
+        if (predicate(parent, node)) {
+          return { ancestor: parent, child: node };
+        }
+        node = parent;
+        parent = node.parent;
       }
+      return { ancestor: void 0, child: node };
     }
     function gatherNodes(node, predicate) {
       if (node == null)
@@ -822,14 +825,11 @@ var require_lib = __commonJS({
     }
     function hoistRefDecs(statements) {
       gatherRecursiveAll(statements, (s) => s.hoistDec).forEach((node) => {
-        let { hoistDec, parent } = node;
+        let { hoistDec } = node;
         node.hoistDec = null;
-        while (parent?.type !== "BlockStatement" || parent.bare && !parent.root) {
-          node = parent;
-          parent = node.parent;
-        }
-        if (parent) {
-          insertHoistDec(parent, node, hoistDec);
+        const { ancestor, child } = findAncestor(node, (ancestor2) => ancestor2.type === "BlockStatement" && (!ancestor2.bare || ancestor2.root));
+        if (ancestor) {
+          insertHoistDec(ancestor, child, hoistDec);
         } else {
           throw new Error("Couldn't find block to hoist declaration into.");
         }
@@ -1147,6 +1147,7 @@ var require_lib = __commonJS({
         case "AmpersandRef":
         case "Identifier":
         case "Literal":
+        case "IterationExpression":
         case "CallExpression":
         case "MemberExpression":
         case "ParenthesizedExpression":
@@ -1368,6 +1369,8 @@ var require_lib = __commonJS({
       if (f.abstract || f.block || f.signature?.optional)
         return;
       const { name, parent } = f;
+      if (parent?.type === "ExportDeclaration")
+        return;
       const expressions = parent?.expressions ?? parent?.elements;
       const currentIndex = expressions?.findIndex(([, def]) => def === f);
       const following = currentIndex >= 0 && expressions[currentIndex + 1]?.[1];
@@ -1423,6 +1426,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 +1475,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 +1533,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 +1984,8 @@ var require_lib = __commonJS({
               });
             }
           } else {
-            s.children = children;
+            if (i === 0)
+              s.children = children;
           }
           if (returns && (ref = needsRef(arg))) {
             usingRef = usingRef || ref;
@@ -2215,7 +2228,7 @@ var require_lib = __commonJS({
       let declared;
       values.forEach((value) => {
         value.children = [ref];
-        const ancestor = findAncestor(
+        const { ancestor } = findAncestor(
           value,
           ({ type }) => type === "Declaration",
           isFunction
@@ -2962,6 +2975,7 @@ ${input.slice(result.pos)}
       NonPipelineExtendedExpression,
       NonAssignmentExtendedExpression,
       NestedNonAssignmentExtendedExpression,
+      ExpressionizedStatementWithTrailingCallExpressions,
       ExpressionizedStatement,
       Expression,
       Arguments,
@@ -2972,6 +2986,8 @@ ${input.slice(result.pos)}
       ArgumentsWithTrailingMemberExpressions,
       TrailingMemberExpressions,
       AllowedTrailingMemberExpressions,
+      TrailingCallExpressions,
+      AllowedTrailingCallExpressions,
       CommaDelimiter,
       ArgumentList,
       NonPipelineArgumentList,
@@ -4111,7 +4127,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 +4158,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 +4192,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 +4510,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 +4865,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) {
@@ -14627,14 +14733,15 @@ ${input.slice(result.pos)}
       }
     }
     var ExportDeclaration$0 = $TS($S($E(Decorators), Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-      return { type: "ExportDeclaration", children: $0 };
+      var declaration = $6;
+      return { type: "ExportDeclaration", declaration, children: $0 };
     });
     var ExportDeclaration$1 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       return { type: "ExportDeclaration", ts: $3.ts, children: $0 };
     });
     var ExportDeclaration$2 = $TS($S($E(Decorators), Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3, $4) {
-      var decl = $4;
-      return { type: "ExportDeclaration", ts: decl.ts, children: $0 };
+      var declaration = $4;
+      return { type: "ExportDeclaration", declaration, ts: declaration.ts, children: $0 };
     });
     function ExportDeclaration(state) {
       let eventData;

package/dist/main.mjs

@@ -742,12 +742,15 @@ var require_lib = __commonJS({
       }
     }
     function findAncestor(node, predicate, stopPredicate) {
-      node = node.parent;
-      while (node && !stopPredicate?.(node)) {
-        if (predicate(node))
-          return node;
-        node = node.parent;
+      let { parent } = node;
+      while (parent && !stopPredicate?.(parent, node)) {
+        if (predicate(parent, node)) {
+          return { ancestor: parent, child: node };
+        }
+        node = parent;
+        parent = node.parent;
       }
+      return { ancestor: void 0, child: node };
     }
     function gatherNodes(node, predicate) {
       if (node == null)
@@ -820,14 +823,11 @@ var require_lib = __commonJS({
     }
     function hoistRefDecs(statements) {
       gatherRecursiveAll(statements, (s) => s.hoistDec).forEach((node) => {
-        let { hoistDec, parent } = node;
+        let { hoistDec } = node;
         node.hoistDec = null;
-        while (parent?.type !== "BlockStatement" || parent.bare && !parent.root) {
-          node = parent;
-          parent = node.parent;
-        }
-        if (parent) {
-          insertHoistDec(parent, node, hoistDec);
+        const { ancestor, child } = findAncestor(node, (ancestor2) => ancestor2.type === "BlockStatement" && (!ancestor2.bare || ancestor2.root));
+        if (ancestor) {
+          insertHoistDec(ancestor, child, hoistDec);
         } else {
           throw new Error("Couldn't find block to hoist declaration into.");
         }
@@ -1145,6 +1145,7 @@ var require_lib = __commonJS({
         case "AmpersandRef":
         case "Identifier":
         case "Literal":
+        case "IterationExpression":
         case "CallExpression":
         case "MemberExpression":
         case "ParenthesizedExpression":
@@ -1366,6 +1367,8 @@ var require_lib = __commonJS({
       if (f.abstract || f.block || f.signature?.optional)
         return;
       const { name, parent } = f;
+      if (parent?.type === "ExportDeclaration")
+        return;
       const expressions = parent?.expressions ?? parent?.elements;
       const currentIndex = expressions?.findIndex(([, def]) => def === f);
       const following = currentIndex >= 0 && expressions[currentIndex + 1]?.[1];
@@ -1421,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)) {
@@ -1430,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) {
@@ -1481,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) {
@@ -1970,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;
@@ -2213,7 +2226,7 @@ var require_lib = __commonJS({
       let declared;
       values.forEach((value) => {
         value.children = [ref];
-        const ancestor = findAncestor(
+        const { ancestor } = findAncestor(
           value,
           ({ type }) => type === "Declaration",
           isFunction
@@ -2960,6 +2973,7 @@ ${input.slice(result.pos)}
       NonPipelineExtendedExpression,
       NonAssignmentExtendedExpression,
       NestedNonAssignmentExtendedExpression,
+      ExpressionizedStatementWithTrailingCallExpressions,
       ExpressionizedStatement,
       Expression,
       Arguments,
@@ -2970,6 +2984,8 @@ ${input.slice(result.pos)}
       ArgumentsWithTrailingMemberExpressions,
       TrailingMemberExpressions,
       AllowedTrailingMemberExpressions,
+      TrailingCallExpressions,
+      AllowedTrailingCallExpressions,
       CommaDelimiter,
       ArgumentList,
       NonPipelineArgumentList,
@@ -4109,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]
@@ -4137,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;
@@ -4165,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;
@@ -4450,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;
@@ -4757,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) {
@@ -14625,14 +14731,15 @@ ${input.slice(result.pos)}
       }
     }
     var ExportDeclaration$0 = $TS($S($E(Decorators), Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-      return { type: "ExportDeclaration", children: $0 };
+      var declaration = $6;
+      return { type: "ExportDeclaration", declaration, children: $0 };
     });
     var ExportDeclaration$1 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       return { type: "ExportDeclaration", ts: $3.ts, children: $0 };
     });
     var ExportDeclaration$2 = $TS($S($E(Decorators), Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3, $4) {
-      var decl = $4;
-      return { type: "ExportDeclaration", ts: decl.ts, children: $0 };
+      var declaration = $4;
+      return { type: "ExportDeclaration", declaration, ts: declaration.ts, children: $0 };
     });
     function ExportDeclaration(state) {
       let eventData;

package/package.json

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