@danielx/civet 0.5.80 → 0.5.81

package/dist/browser.js

@@ -27,6 +27,106 @@ var Civet = (() => {
   ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // source/lib.js
+  var require_lib = __commonJS({
+    "source/lib.js"(exports, module) {
+      "use strict";
+      function clone(node) {
+        removeParentPointers(node);
+        return deepCopy(node);
+      }
+      function deepCopy(node) {
+        if (node == null)
+          return node;
+        if (typeof node !== "object")
+          return node;
+        if (Array.isArray(node)) {
+          return node.map(deepCopy);
+        }
+        return Object.fromEntries(
+          Object.entries(node).map(([key, value]) => {
+            return [key, deepCopy(value)];
+          })
+        );
+      }
+      function removeParentPointers(node) {
+        if (node == null)
+          return;
+        if (typeof node !== "object")
+          return;
+        if (Array.isArray(node)) {
+          for (const child of node) {
+            removeParentPointers(child);
+          }
+          return;
+        }
+        node.parent = null;
+        if (node.children) {
+          for (const child of node.children) {
+            removeParentPointers(child);
+          }
+        }
+      }
+      function gatherNodes(node, predicate) {
+        if (node == null)
+          return [];
+        if (Array.isArray(node)) {
+          return node.flatMap((n) => gatherNodes(n, predicate));
+        }
+        if (predicate(node)) {
+          return [node];
+        }
+        switch (node.type) {
+          case "BlockStatement":
+            return [];
+          case "ForStatement":
+            const isDec = node.declaration?.type === "Declaration";
+            return node.children.flatMap((n) => {
+              if (isDec && n === node.declaration)
+                return [];
+              return gatherNodes(n, predicate);
+            });
+          default:
+            return gatherNodes(node.children, predicate);
+        }
+        return [];
+      }
+      function gatherRecursive(node, predicate, skipPredicate) {
+        if (node == null)
+          return [];
+        if (Array.isArray(node)) {
+          return node.flatMap((n) => gatherRecursive(n, predicate, skipPredicate));
+        }
+        if (skipPredicate?.(node))
+          return [];
+        if (predicate(node)) {
+          return [node];
+        }
+        return gatherRecursive(node.children, predicate, skipPredicate);
+      }
+      function gatherRecursiveAll(node, predicate) {
+        if (node == null)
+          return [];
+        if (Array.isArray(node)) {
+          return node.flatMap((n) => gatherRecursiveAll(n, predicate));
+        }
+        const nodes = gatherRecursiveAll(node.children, predicate);
+        if (predicate(node)) {
+          nodes.push(node);
+        }
+        return nodes;
+      }
+      module.exports = {
+        clone,
+        deepCopy,
+        gatherNodes,
+        gatherRecursive,
+        gatherRecursiveAll,
+        removeParentPointers
+      };
+    }
+  });
+
   // source/parser.hera
   var require_parser = __commonJS({
     "source/parser.hera"(exports, module) {
@@ -566,6 +666,7 @@ ${input.slice(result.pos)}
         FunctionDeclaration,
         FunctionSignature,
         FunctionExpression,
+        AmpersandFunctionExpression,
         OperatorDeclaration,
         OperatorSignature,
         AmpersandBlockRHS,
@@ -1880,8 +1981,8 @@ ${input.slice(result.pos)}
         return module.insertTrimmingSpace($1, "");
       });
       var ArgumentList$2 = NestedArgumentList;
-      var ArgumentList$3 = $TS($S($Q(TrailingComment), ArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
-        return [...$1, $2, ...$3];
+      var ArgumentList$3 = $TS($S($E(_), ArgumentPart, $Q($S(CommaDelimiter, $E(_), ArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+        return [...$1 || [], $2, ...$3];
       });
       function ArgumentList(state) {
         let eventData;
@@ -1910,8 +2011,8 @@ ${input.slice(result.pos)}
         return module.insertTrimmingSpace($1, "");
       });
       var NonPipelineArgumentList$2 = NestedArgumentList;
-      var NonPipelineArgumentList$3 = $TS($S($Q(TrailingComment), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $Q(TrailingComment), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
-        return [...$1, $2, ...$3];
+      var NonPipelineArgumentList$3 = $TS($S($E(_), NonPipelineArgumentPart, $Q($S(CommaDelimiter, $E(_), NonPipelineArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+        return [...$1 || [], $2, ...$3];
       });
       function NonPipelineArgumentList(state) {
         let eventData;
@@ -1986,7 +2087,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var SingleLineArgumentExpressions$0 = $S($Q(TrailingComment), ArgumentPart, $Q($S($Q(TrailingComment), Comma, $Q(TrailingComment), ArgumentPart)));
+      var SingleLineArgumentExpressions$0 = $S($E(_), ArgumentPart, $Q($S($E(_), Comma, $E(_), ArgumentPart)));
       function SingleLineArgumentExpressions(state) {
         let eventData;
         if (state.events) {
@@ -2345,10 +2446,10 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var SingleLineAssignmentExpression$0 = $TS($S($Q(TrailingComment), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
+      var SingleLineAssignmentExpression$0 = $TS($S($E(_), AssignmentExpressionTail), function($skip, $loc, $0, $1, $2) {
         var ws = $1;
         var tail = $2;
-        if (ws.length) {
+        if (ws?.length) {
           if (tail.children && tail.type !== "IterationExpression") {
             return {
               ...tail,
@@ -2465,7 +2566,7 @@ ${input.slice(result.pos)}
         }
       }
       var YieldTail$0 = $Y(EOS);
-      var YieldTail$1 = $S($E($S($Q(TrailingComment), Star)), AssignmentExpression);
+      var YieldTail$1 = $S($E($S($E(_), Star)), AssignmentExpression);
       function YieldTail(state) {
         let eventData;
         if (state.events) {
@@ -2637,7 +2738,7 @@ ${input.slice(result.pos)}
         }
       }
       var TernaryRest$0 = NestedTernaryRest;
-      var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($L9, fail, 'TernaryRest " "')), $Q(TrailingComment), QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+      var TernaryRest$1 = $TS($S($N(CoffeeBinaryExistentialEnabled), $Y($EXPECT($L9, fail, 'TernaryRest " "')), $E(_), QuestionMark, ExtendedExpression, __, Colon, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
         return $0.slice(2);
       });
       function TernaryRest(state) {
@@ -2716,6 +2817,23 @@ ${input.slice(result.pos)}
         var ws = $1;
         var head = $2;
         var body = $3;
+        if (head.token === "&") {
+          const ref = {
+            type: "Ref",
+            base: "$"
+          };
+          const arrowBody = {
+            type: "PipelineExpression",
+            children: [ws, ref, body]
+          };
+          return {
+            type: "ArrowFunction",
+            children: [ref, " => ", arrowBody],
+            ref,
+            body: [arrowBody],
+            ampersandBlock: true
+          };
+        }
         return {
           type: "PipelineExpression",
           children: [ws, head, body]
@@ -2745,6 +2863,7 @@ ${input.slice(result.pos)}
       }
       var PipelineHeadItem$0 = NonPipelineExtendedExpression;
       var PipelineHeadItem$1 = ParenthesizedExpression;
+      var PipelineHeadItem$2 = Ampersand;
       function PipelineHeadItem(state) {
         let eventData;
         if (state.events) {
@@ -2756,12 +2875,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("PipelineHeadItem", state, PipelineHeadItem$0(state) || PipelineHeadItem$1(state));
+          const result = $TOKEN("PipelineHeadItem", state, PipelineHeadItem$0(state) || PipelineHeadItem$1(state) || PipelineHeadItem$2(state));
           if (state.events)
             state.events.exit?.("PipelineHeadItem", state, result, eventData);
           return result;
         } else {
-          const result = PipelineHeadItem$0(state) || PipelineHeadItem$1(state);
+          const result = PipelineHeadItem$0(state) || PipelineHeadItem$1(state) || PipelineHeadItem$2(state);
           if (state.events)
             state.events.exit?.("PipelineHeadItem", state, result, eventData);
           return result;
@@ -2770,7 +2889,10 @@ ${input.slice(result.pos)}
       var PipelineTailItem$0 = Await;
       var PipelineTailItem$1 = Yield;
       var PipelineTailItem$2 = Return;
-      var PipelineTailItem$3 = PipelineHeadItem;
+      var PipelineTailItem$3 = AmpersandFunctionExpression;
+      var PipelineTailItem$4 = $T($S($N(Ampersand), PipelineHeadItem), function(value) {
+        return value[1];
+      });
       function PipelineTailItem(state) {
         let eventData;
         if (state.events) {
@@ -2782,12 +2904,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("PipelineTailItem", state, PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state) || PipelineTailItem$3(state));
+          const result = $TOKEN("PipelineTailItem", state, PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state) || PipelineTailItem$3(state) || PipelineTailItem$4(state));
           if (state.events)
             state.events.exit?.("PipelineTailItem", state, result, eventData);
           return result;
         } else {
-          const result = PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state) || PipelineTailItem$3(state);
+          const result = PipelineTailItem$0(state) || PipelineTailItem$1(state) || PipelineTailItem$2(state) || PipelineTailItem$3(state) || PipelineTailItem$4(state);
           if (state.events)
             state.events.exit?.("PipelineTailItem", state, result, eventData);
           return result;
@@ -3234,7 +3356,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ClassElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $Q(TrailingComment))), ClassElementDefinition);
+      var ClassElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), ClassElementDefinition);
       var ClassElement$1 = $S(Static, BracedBlock);
       function ClassElement(state) {
         let eventData;
@@ -3380,7 +3502,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ClassSignatureElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $Q(TrailingComment))), $C(MethodSignature, FieldDefinition));
+      var ClassSignatureElement$0 = $S($E(Decorators), $E(AccessModifier), $E($S(Static, $E(_))), $C(MethodSignature, FieldDefinition));
       var ClassSignatureElement$1 = $S(Static, ClassSignatureBody);
       function ClassSignatureElement(state) {
         let eventData;
@@ -3456,7 +3578,7 @@ ${input.slice(result.pos)}
         };
         return $0;
       });
-      var FieldDefinition$2 = $TS($S($E($S(Abstract, $Q(TrailingComment))), $E($S(Readonly, $Q(TrailingComment))), ClassElementName, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var FieldDefinition$2 = $TS($S($E($S(Abstract, $E(_))), $E($S(Readonly, $E(_))), ClassElementName, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         if ($1)
           return { children: $0, ts: true };
         return $0;
@@ -5596,7 +5718,30 @@ ${input.slice(result.pos)}
           block
         };
       });
-      var FunctionExpression$1 = $TS($S($E(AmpersandUnaryPrefix), $C(Ampersand, $S($N(NumericLiteral), $Y($S($E(QuestionMark), Dot)))), $E(AmpersandBlockRHS)), function($skip, $loc, $0, $1, $2, $3) {
+      var FunctionExpression$1 = AmpersandFunctionExpression;
+      function FunctionExpression(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("FunctionExpression", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          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);
+          if (state.events)
+            state.events.exit?.("FunctionExpression", state, result, eventData);
+          return result;
+        }
+      }
+      var AmpersandFunctionExpression$0 = $TS($S($E(AmpersandUnaryPrefix), $C(Ampersand, $S($N(NumericLiteral), $Y($S($E(QuestionMark), Dot)))), $E(AmpersandBlockRHS)), function($skip, $loc, $0, $1, $2, $3) {
         var prefix = $1;
         var rhs = $3;
         if (!prefix && !rhs)
@@ -5625,10 +5770,10 @@ ${input.slice(result.pos)}
           ampersandBlock: true
         };
       });
-      function FunctionExpression(state) {
+      function AmpersandFunctionExpression(state) {
         let eventData;
         if (state.events) {
-          const result = state.events.enter?.("FunctionExpression", state);
+          const result = state.events.enter?.("AmpersandFunctionExpression", state);
           if (result) {
             if (result.cache)
               return result.cache;
@@ -5636,14 +5781,14 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("FunctionExpression", state, FunctionExpression$0(state) || FunctionExpression$1(state));
+          const result = $TOKEN("AmpersandFunctionExpression", state, AmpersandFunctionExpression$0(state));
           if (state.events)
-            state.events.exit?.("FunctionExpression", state, result, eventData);
+            state.events.exit?.("AmpersandFunctionExpression", state, result, eventData);
           return result;
         } else {
-          const result = FunctionExpression$0(state) || FunctionExpression$1(state);
+          const result = AmpersandFunctionExpression$0(state);
           if (state.events)
-            state.events.exit?.("FunctionExpression", state, result, eventData);
+            state.events.exit?.("AmpersandFunctionExpression", state, result, eventData);
           return result;
         }
       }
@@ -6198,7 +6343,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var NonSingleBracedBlock$0 = $TS($S($Q(TrailingComment), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var NonSingleBracedBlock$0 = $TS($S($E(_), OpenBrace, AllowAll, $E($S(BracedContent, __, CloseBrace)), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var ws1 = $1;
         var open = $2;
         if (!$4)
@@ -6314,7 +6459,7 @@ ${input.slice(result.pos)}
         }
       }
       var BracedContent$0 = NestedBlockStatements;
-      var BracedContent$1 = $TS($S($Q(TrailingComment), Statement), function($skip, $loc, $0, $1, $2) {
+      var BracedContent$1 = $TS($S($E(_), Statement), function($skip, $loc, $0, $1, $2) {
         const expressions = [["", $2]];
         return {
           type: "BlockStatement",
@@ -7358,7 +7503,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ImplicitInlineObjectPropertyDelimiter$0 = $S($Q(TrailingComment), Comma);
+      var ImplicitInlineObjectPropertyDelimiter$0 = $S($E(_), Comma);
       var ImplicitInlineObjectPropertyDelimiter$1 = $T($S($Y($S($C(Samedent, $Q(_)), NamedProperty)), InsertComma), function(value) {
         return value[1];
       });
@@ -7825,7 +7970,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var MethodModifier$0 = $S(GetOrSet, $Q(TrailingComment));
+      var MethodModifier$0 = $S(GetOrSet, $E(_));
       var MethodModifier$1 = $S($S(Async, __), $E($S(Star, __)));
       var MethodModifier$2 = $S(Star, __);
       function MethodModifier(state) {
@@ -7981,8 +8126,8 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var AssignmentOp$0 = $TS($S(AssignmentOpSymbol, $Q(TrailingComment)), function($skip, $loc, $0, $1, $2) {
-        if ($2.length) {
+      var AssignmentOp$0 = $TS($S(AssignmentOpSymbol, $E(_)), function($skip, $loc, $0, $1, $2) {
+        if ($2?.length) {
           return {
             token: $1,
             children: [$1, ...$2]
@@ -8012,21 +8157,21 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L2, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var OperatorAssignmentOp$0 = $TS($S(Xor, $EXPECT($L2, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $E(_)), function($skip, $loc, $0, $1, $2, $3, $4) {
         return {
           special: true,
           call: module.getRef("xor"),
           children: [$2, ...$4]
         };
       });
-      var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L2, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var OperatorAssignmentOp$1 = $TS($S(Xnor, $EXPECT($L2, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $E(_)), function($skip, $loc, $0, $1, $2, $3, $4) {
         return {
           special: true,
           call: module.getRef("xnor"),
           children: [$2, ...$4]
         };
       });
-      var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L2, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var OperatorAssignmentOp$2 = $TS($S(Identifier, $EXPECT($L2, fail, 'OperatorAssignmentOp "="'), $Y(Whitespace), $E(_)), function($skip, $loc, $0, $1, $2, $3, $4) {
         return {
           special: true,
           call: $1,
@@ -8492,7 +8637,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var PostfixedStatement$0 = $TS($S(Statement, $E($S($Q(TrailingComment), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
+      var PostfixedStatement$0 = $TS($S(Statement, $E($S($E(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
         var statement = $1;
         var post = $2;
         if (post)
@@ -8521,7 +8666,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var PostfixedExpression$0 = $TS($S(ExtendedExpression, $E($S($Q(TrailingComment), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
+      var PostfixedExpression$0 = $TS($S(ExtendedExpression, $E($S($E(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
         var expression = $1;
         var post = $2;
         if (post)
@@ -8550,7 +8695,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var NonPipelinePostfixedExpression$0 = $TS($S(NonPipelineExtendedExpression, $E($S($Q(TrailingComment), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
+      var NonPipelinePostfixedExpression$0 = $TS($S(NonPipelineExtendedExpression, $E($S($E(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
         var expression = $1;
         var post = $2;
         if (post)
@@ -8643,8 +8788,8 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var EmptyStatement$0 = $T($S($Q(TrailingComment), $Y($EXPECT($L85, fail, 'EmptyStatement ";"'))), function(value) {
-        return { "type": "EmptyStatement", "children": value[0] };
+      var EmptyStatement$0 = $TS($S($E(_), $Y($EXPECT($L85, fail, 'EmptyStatement ";"'))), function($skip, $loc, $0, $1, $2) {
+        return { type: "EmptyStatement", children: $1 || [] };
       });
       function EmptyStatement(state) {
         let eventData;
@@ -8808,7 +8953,7 @@ ${input.slice(result.pos)}
         }
       }
       var ElseClause$0 = $S(Samedent, Else, Block);
-      var ElseClause$1 = $S($Q(TrailingComment), Else, Block);
+      var ElseClause$1 = $S($E(_), Else, Block);
       function ElseClause(state) {
         let eventData;
         if (state.events) {
@@ -8943,7 +9088,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ElseExpressionClause$0 = $TS($S($C($S(Samedent, Else), $S($Q(TrailingComment), Else)), ElseExpressionBlock), function($skip, $loc, $0, $1, $2) {
+      var ElseExpressionClause$0 = $TS($S($C($S(Samedent, Else), $S($E(_), Else)), ElseExpressionBlock), function($skip, $loc, $0, $1, $2) {
         return [...$1, $2];
       });
       function ElseExpressionClause(state) {
@@ -9319,7 +9464,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var WhileClause$0 = $TS($S($C(While, Until), $Q(TrailingComment), Condition), function($skip, $loc, $0, $1, $2, $3) {
+      var WhileClause$0 = $TS($S($C(While, Until), $E(_), Condition), function($skip, $loc, $0, $1, $2, $3) {
         var kind = $1;
         var ws = $2;
         var cond = $3;
@@ -10416,7 +10561,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var Condition$0 = $T($S(ParenthesizedExpression, $N($S($Q(TrailingComment), $C(BinaryOp, AssignmentOp, Dot, QuestionMark))), $N($S(_, OperatorAssignmentOp))), function(value) {
+      var Condition$0 = $T($S(ParenthesizedExpression, $N($S($E(_), $C(BinaryOp, AssignmentOp, Dot, QuestionMark))), $N($S(_, OperatorAssignmentOp))), function(value) {
         return value[0];
       });
       var Condition$1 = $TS($S(InsertOpenParen, ExpressionWithIndentedApplicationForbidden, InsertCloseParen), function($skip, $loc, $0, $1, $2, $3) {
@@ -13381,9 +13526,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var TrailingComment$0 = NonNewlineWhitespace;
-      var TrailingComment$1 = InlineComment;
-      var TrailingComment$2 = SingleLineComment;
+      var TrailingComment$0 = $S($E(_), SingleLineComment);
       function TrailingComment(state) {
         let eventData;
         if (state.events) {
@@ -13395,12 +13538,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("TrailingComment", state, TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state));
+          const result = $TOKEN("TrailingComment", state, TrailingComment$0(state));
           if (state.events)
             state.events.exit?.("TrailingComment", state, result, eventData);
           return result;
         } else {
-          const result = TrailingComment$0(state) || TrailingComment$1(state) || TrailingComment$2(state);
+          const result = TrailingComment$0(state);
           if (state.events)
             state.events.exit?.("TrailingComment", state, result, eventData);
           return result;
@@ -13531,7 +13674,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ExpressionDelimiter$0 = $TS($S($Q(TrailingComment), Semicolon, InsertComma, $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var ExpressionDelimiter$0 = $TS($S($E(_), Semicolon, InsertComma, $E(TrailingComment)), function($skip, $loc, $0, $1, $2, $3, $4) {
         return [$1, $3, $4];
       });
       var ExpressionDelimiter$1 = $T($S($Y(EOS), InsertComma), function(value) {
@@ -13608,7 +13751,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var SemicolonDelimiter$0 = $TS($S($Q(TrailingComment), Semicolon, $Q(TrailingComment)), function($skip, $loc, $0, $1, $2, $3) {
+      var SemicolonDelimiter$0 = $TS($S($E(_), Semicolon, $E(TrailingComment)), function($skip, $loc, $0, $1, $2, $3) {
         return {
           type: "SemicolonDelimiter",
           children: $0
@@ -17214,9 +17357,9 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var TypeDeclarationRest$0 = $S(TypeKeyword, $Q(TrailingComment), IdentifierName, $E(TypeParameters), __, Equals, $C($S($E(_), Type), $S(__, Type)));
-      var TypeDeclarationRest$1 = $S(Interface, $Q(TrailingComment), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock);
-      var TypeDeclarationRest$2 = $S(Namespace, $Q(TrailingComment), IdentifierName, ModuleBlock);
+      var TypeDeclarationRest$0 = $S(TypeKeyword, $E(_), IdentifierName, $E(TypeParameters), __, Equals, $C($S($E(_), Type), $S(__, Type)));
+      var TypeDeclarationRest$1 = $S(Interface, $E(_), IdentifierName, $E(TypeParameters), $E(InterfaceExtendsClause), InterfaceBlock);
+      var TypeDeclarationRest$2 = $S(Namespace, $E(_), IdentifierName, ModuleBlock);
       var TypeDeclarationRest$3 = FunctionSignature;
       function TypeDeclarationRest(state) {
         let eventData;
@@ -17243,7 +17386,7 @@ ${input.slice(result.pos)}
       var TypeLexicalDeclaration$0 = $S(__, LetOrConstOrVar, TypeDeclarationBinding, $Q($S(CommaDelimiter, __, TypeDeclarationBinding)));
       var TypeLexicalDeclaration$1 = $S(__, EnumDeclaration);
       var TypeLexicalDeclaration$2 = ClassSignature;
-      var TypeLexicalDeclaration$3 = $S(Namespace, $Q(TrailingComment), IdentifierName, DeclareBlock);
+      var TypeLexicalDeclaration$3 = $S(Namespace, $E(_), IdentifierName, DeclareBlock);
       var TypeLexicalDeclaration$4 = $S(Module, _, StringLiteral, $E(DeclareBlock));
       var TypeLexicalDeclaration$5 = $S(Global, $E(DeclareBlock));
       function TypeLexicalDeclaration(state) {
@@ -17815,7 +17958,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var EnumDeclaration$0 = $TS($S($E($S(Const, _)), Enum, $Q(TrailingComment), IdentifierName, EnumBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var EnumDeclaration$0 = $TS($S($E($S(Const, _)), Enum, $E(_), IdentifierName, EnumBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var isConst = $1;
         var id = $4;
         var block = $5;
@@ -17836,7 +17979,7 @@ ${input.slice(result.pos)}
                 let init, isString;
                 if (property.init) {
                   init = module.replaceNodes(
-                    module.deepCopy(property.init),
+                    deepCopy(property.init),
                     (n) => n.type === "Identifier" && names.has(n.name),
                     (n) => [id, '["', n.name, '"]']
                   );
@@ -21137,55 +21280,6 @@ ${input.slice(result.pos)}
             }, props2]
           };
         };
-        function gatherNodes(node, predicate) {
-          if (node == null)
-            return [];
-          if (Array.isArray(node)) {
-            return node.flatMap((n) => gatherNodes(n, predicate));
-          }
-          if (predicate(node)) {
-            return [node];
-          }
-          switch (node.type) {
-            case "BlockStatement":
-              return [];
-            case "ForStatement":
-              const isDec = node.declaration?.type === "Declaration";
-              return node.children.flatMap((n) => {
-                if (isDec && n === node.declaration)
-                  return [];
-                return gatherNodes(n, predicate);
-              });
-            default:
-              return gatherNodes(node.children, predicate);
-          }
-          return [];
-        }
-        function gatherRecursive(node, predicate, skipPredicate) {
-          if (node == null)
-            return [];
-          if (Array.isArray(node)) {
-            return node.flatMap((n) => gatherRecursive(n, predicate, skipPredicate));
-          }
-          if (skipPredicate?.(node))
-            return [];
-          if (predicate(node)) {
-            return [node];
-          }
-          return gatherRecursive(node.children, predicate, skipPredicate);
-        }
-        function gatherRecursiveAll(node, predicate) {
-          if (node == null)
-            return [];
-          if (Array.isArray(node)) {
-            return node.flatMap((n) => gatherRecursiveAll(n, predicate));
-          }
-          const nodes = gatherRecursiveAll(node.children, predicate);
-          if (predicate(node)) {
-            nodes.push(node);
-          }
-          return nodes;
-        }
         function isFunction(node) {
           const { type } = node;
           return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || node.async;
@@ -21211,43 +21305,6 @@ ${input.slice(result.pos)}
             }
           }
         }
-        function removeParentPointers(node) {
-          if (node == null)
-            return;
-          if (typeof node !== "object")
-            return;
-          if (Array.isArray(node)) {
-            for (const child of node) {
-              removeParentPointers(child);
-            }
-            return;
-          }
-          node.parent = null;
-          if (node.children) {
-            for (const child of node.children) {
-              removeParentPointers(child);
-            }
-          }
-        }
-        function clone(node) {
-          removeParentPointers(node);
-          return deepCopy(node);
-        }
-        function deepCopy(node) {
-          if (node == null)
-            return node;
-          if (typeof node !== "object")
-            return node;
-          if (Array.isArray(node)) {
-            return node.map(deepCopy);
-          }
-          return Object.fromEntries(
-            Object.entries(node).map(([key, value]) => {
-              return [key, deepCopy(value)];
-            })
-          );
-        }
-        module.deepCopy = deepCopy;
         function findAncestor(node, predicate, stopPredicate) {
           node = node.parent;
           while (node && !stopPredicate?.(node)) {
@@ -22210,8 +22267,12 @@ ${input.slice(result.pos)}
         module.gatherBindingCode = gatherBindingCode;
         module.constructInvocation = function(fn, arg) {
           const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
-          if (fn.expr.ampersandBlock) {
-            const { ref, body } = fn.expr;
+          let expr = fn.expr;
+          while (expr.type === "ParenthesizedExpression") {
+            expr = expr.expression;
+          }
+          if (expr.ampersandBlock) {
+            const { ref, body } = expr;
             ref.type = "PipedExpression";
             ref.children = [module.makeLeftHandSideExpression(arg)];
             return {
@@ -22219,7 +22280,8 @@ ${input.slice(result.pos)}
               children: [module.skipIfOnlyWS(fn.leadingComment), ...body, module.skipIfOnlyWS(fn.trailingComment)]
             };
           }
-          const lhs = module.makeLeftHandSideExpression(fn.expr);
+          expr = fn.expr;
+          const lhs = module.makeLeftHandSideExpression(expr);
           let comment = module.skipIfOnlyWS(fn.trailingComment);
           if (comment)
             lhs.children.splice(2, 0, comment);
@@ -22543,6 +22605,14 @@ ${input.slice(result.pos)}
       }
       exports.parse = parse2;
       exports.default = { parse: parse2 };
+      var {
+        clone,
+        deepCopy,
+        gatherNodes,
+        gatherRecursive,
+        gatherRecursiveAll,
+        removeParentPointers
+      } = require_lib();
     }
   });