@danielx/civet 0.5.80 → 0.5.82

package/dist/main.js

@@ -26,6 +26,123 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// source/lib.js
+var require_lib = __commonJS({
+  "source/lib.js"(exports, module2) {
+    "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;
+    }
+    function hasAwait(exp) {
+      return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
+    }
+    function hasYield(exp) {
+      return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Yield").length > 0;
+    }
+    function isFunction(node) {
+      const { type } = node;
+      return type === "FunctionExpression" || type === "ArrowFunction" || type === "MethodDefinition" || node.async;
+    }
+    function gatherRecursiveWithinFunction(node, predicate) {
+      return gatherRecursive(node, predicate, isFunction);
+    }
+    module2.exports = {
+      clone,
+      deepCopy,
+      gatherNodes,
+      gatherRecursive,
+      gatherRecursiveAll,
+      gatherRecursiveWithinFunction,
+      hasAwait,
+      hasYield,
+      isFunction,
+      removeParentPointers
+    };
+  }
+});
+
 // source/parser.hera
 var require_parser = __commonJS({
   "source/parser.hera"(exports, module2) {
@@ -468,7 +585,6 @@ ${input.slice(result.pos)}
       YieldExpression,
       YieldTail,
       ArrowFunction,
-      ArrowFunctionTail,
       FatArrow,
       FatArrowBody,
       ConditionalExpression,
@@ -565,6 +681,7 @@ ${input.slice(result.pos)}
       FunctionDeclaration,
       FunctionSignature,
       FunctionExpression,
+      AmpersandFunctionExpression,
       OperatorDeclaration,
       OperatorSignature,
       AmpersandBlockRHS,
@@ -1879,8 +1996,8 @@ ${input.slice(result.pos)}
       return module2.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;
@@ -1909,8 +2026,8 @@ ${input.slice(result.pos)}
       return module2.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;
@@ -1985,7 +2102,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) {
@@ -2344,10 +2461,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,
@@ -2464,7 +2581,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) {
@@ -2487,53 +2604,36 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ArrowFunction$0 = $TS($S($E($S(Async, __)), ArrowFunctionTail), function($skip, $loc, $0, $1, $2) {
-      var tail = $2;
-      return {
-        ...tail,
-        children: [...$1 || [], ...tail.children]
-      };
-    });
-    function ArrowFunction(state) {
-      let eventData;
-      if (state.events) {
-        const result = state.events.enter?.("ArrowFunction", state);
-        if (result) {
-          if (result.cache)
-            return result.cache;
-          eventData = result.data;
-        }
+    var ArrowFunction$0 = ThinArrowFunction;
+    var ArrowFunction$1 = $TS($S($E($S(Async, _)), Parameters, $E(ReturnTypeSuffix), FatArrow, FatArrowBody), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var async = $1;
+      var parameters = $2;
+      var suffix = $3;
+      var expOrBlock = $5;
+      if (hasAwait(expOrBlock) && !async) {
+        async = "async ";
       }
-      if (state.tokenize) {
-        const result = $TOKEN("ArrowFunction", state, ArrowFunction$0(state));
-        if (state.events)
-          state.events.exit?.("ArrowFunction", state, result, eventData);
-        return result;
-      } else {
-        const result = ArrowFunction$0(state);
-        if (state.events)
-          state.events.exit?.("ArrowFunction", state, result, eventData);
-        return result;
+      let error;
+      if (hasYield(expOrBlock)) {
+        error = {
+          type: "Error",
+          message: "Can't use yield inside of => arrow function"
+        };
       }
-    }
-    var ArrowFunctionTail$0 = ThinArrowFunction;
-    var ArrowFunctionTail$1 = $TS($S(Parameters, $E(ReturnTypeSuffix), FatArrow, FatArrowBody), function($skip, $loc, $0, $1, $2, $3, $4) {
-      var parameters = $1;
-      var suffix = $2;
-      var expOrBlock = $4;
       return {
         type: "ArrowFunction",
         parameters,
         returnType: suffix,
         ts: false,
+        async,
         block: expOrBlock,
-        children: $0
+        children: [async, $0.slice(1), error]
       };
     });
-    function ArrowFunctionTail(state) {
+    function ArrowFunction(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("ArrowFunctionTail", state);
+        const result = state.events.enter?.("ArrowFunction", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -2541,14 +2641,14 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ArrowFunctionTail", state, ArrowFunctionTail$0(state) || ArrowFunctionTail$1(state));
+        const result = $TOKEN("ArrowFunction", state, ArrowFunction$0(state) || ArrowFunction$1(state));
         if (state.events)
-          state.events.exit?.("ArrowFunctionTail", state, result, eventData);
+          state.events.exit?.("ArrowFunction", state, result, eventData);
         return result;
       } else {
-        const result = ArrowFunctionTail$0(state) || ArrowFunctionTail$1(state);
+        const result = ArrowFunction$0(state) || ArrowFunction$1(state);
         if (state.events)
-          state.events.exit?.("ArrowFunctionTail", state, result, eventData);
+          state.events.exit?.("ArrowFunction", state, result, eventData);
         return result;
       }
     }
@@ -2636,7 +2736,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) {
@@ -2715,6 +2815,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]
@@ -2744,6 +2861,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) {
@@ -2755,12 +2873,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;
@@ -2769,7 +2887,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) {
@@ -2781,12 +2902,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;
@@ -3233,7 +3354,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;
@@ -3379,7 +3500,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;
@@ -3438,9 +3559,16 @@ ${input.slice(result.pos)}
       var exp = $6;
       switch (exp.type) {
         case "FunctionExpression":
+          const fnTokenIndex = exp.children.findIndex((c) => c?.token?.startsWith("function"));
+          const children = exp.children.slice();
+          if (exp.generator) {
+            children.splice(fnTokenIndex, 2, children[fnTokenIndex + 1], id);
+          } else {
+            children.splice(fnTokenIndex, 1, id);
+          }
           return {
             ...exp,
-            children: [id, ...exp.children.slice(1)]
+            children
           };
         default:
           return [id, " = ", exp];
@@ -3455,7 +3583,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;
@@ -5541,22 +5669,28 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var FunctionSignature$0 = $TS($S($E($S(Async, $E(_))), Function, $E($S($E(_), Star)), $E($S($E(_), NWBindingIdentifier)), $E(_), Parameters, $E(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+    var FunctionSignature$0 = $TS($S($E($S(Async, _)), Function, $E($S($E(_), Star)), $E($S($E(_), NWBindingIdentifier)), $E(_), Parameters, $E(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
       var async = $1;
       var func = $2;
-      var star = $3;
+      var generator = $3;
       var wid = $4;
       var w = $5;
       var parameters = $6;
       var suffix = $7;
+      if (!async)
+        async = [];
+      if (!generator)
+        generator = [];
       return {
         type: "FunctionSignature",
         id: wid?.[1],
         parameters,
         returnType: suffix,
         ts: false,
+        async,
+        generator,
         block: null,
-        children: !parameters.implicit ? $0 : [async, func, star, wid, parameters, w, suffix]
+        children: !parameters.implicit ? $0 : [async, func, generator, wid, parameters, w, suffix]
       };
     });
     function FunctionSignature(state) {
@@ -5588,6 +5722,12 @@ ${input.slice(result.pos)}
         signature.ts = true;
         return signature;
       }
+      if (hasAwait(block) && !signature.async.length) {
+        signature.async.push("async ");
+      }
+      if (hasYield(block) && !signature.generator.length) {
+        signature.generator.push("*");
+      }
       return {
         ...signature,
         type: "FunctionExpression",
@@ -5595,7 +5735,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)
@@ -5613,7 +5776,7 @@ ${input.slice(result.pos)}
         body = [prefix, rhs];
       }
       const children = [ref, " => ", ...body];
-      if (module2.hasAwait(body)) {
+      if (hasAwait(body)) {
         children.unshift("async ");
       }
       return {
@@ -5624,10 +5787,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;
@@ -5635,14 +5798,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;
       }
     }
@@ -5813,20 +5976,32 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ThinArrowFunction$0 = $TS($S(Parameters, $E(ReturnTypeSuffix), $Q(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-      var parameters = $1;
-      var suffix = $2;
-      var arrow = $4;
-      var block = $5;
+    var ThinArrowFunction$0 = $TS($S($E($S(Async, _)), Parameters, $E(ReturnTypeSuffix), $Q(_), Arrow, BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+      var async = $1;
+      var parameters = $2;
+      var suffix = $3;
+      var arrow = $5;
+      var block = $6;
+      if (hasAwait(block) && !async) {
+        async = "async ";
+      }
+      let generator;
+      if (hasYield(block)) {
+        generator = "*";
+      }
       return {
         type: "FunctionExpression",
         id: void 0,
         parameters,
         returnType: suffix,
         ts: false,
+        async,
+        generator,
         block,
         children: [
+          async,
           { $loc: arrow.$loc, token: "function" },
+          generator,
           parameters,
           suffix,
           block
@@ -6197,7 +6372,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)
@@ -6313,7 +6488,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",
@@ -7357,7 +7532,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];
     });
@@ -7793,9 +7968,38 @@ ${input.slice(result.pos)}
     var MethodDefinition$1 = $TS($S(MethodSignature, $N(PropertyAccess), BracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3) {
       var signature = $1;
       var block = $3;
+      let children = $0;
+      let generatorPos = 0;
+      const { modifier } = signature;
+      if (hasAwait(block)) {
+        generatorPos++;
+        children = children.slice();
+        if (modifier?.get || modifier?.set) {
+          children.push({
+            type: "Error",
+            message: "Getters and setters cannot be async"
+          });
+        } else if (modifier?.async) {
+        } else {
+          children.unshift("async ");
+        }
+      }
+      if (hasYield(block)) {
+        if (children === $0)
+          children = children.slice();
+        if (modifier?.get || modifier?.set) {
+          children.push({
+            type: "Error",
+            message: "Getters and setters cannot be generators"
+          });
+        } else if (modifier?.generator) {
+        } else {
+          children.splice(generatorPos, 0, "*");
+        }
+      }
       return {
         type: "MethodDefinition",
-        children: $0,
+        children,
         name: signature.name,
         signature,
         block,
@@ -7824,9 +8028,37 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var MethodModifier$0 = $S(GetOrSet, $Q(TrailingComment));
-    var MethodModifier$1 = $S($S(Async, __), $E($S(Star, __)));
-    var MethodModifier$2 = $S(Star, __);
+    var MethodModifier$0 = $TS($S(GetOrSet, $E(_)), function($skip, $loc, $0, $1, $2) {
+      var kind = $1;
+      return {
+        type: "MethodModifier",
+        async: false,
+        generator: false,
+        get: kind.token === "get",
+        set: kind.token === "set",
+        children: $0
+      };
+    });
+    var MethodModifier$1 = $TS($S($S(Async, __), $E($S(Star, __))), function($skip, $loc, $0, $1, $2) {
+      return {
+        type: "MethodModifier",
+        async: true,
+        get: false,
+        set: false,
+        generator: !!$1,
+        children: $0
+      };
+    });
+    var MethodModifier$2 = $TS($S(Star, __), function($skip, $loc, $0, $1, $2) {
+      return {
+        type: "MethodModifier",
+        async: false,
+        get: false,
+        set: false,
+        generator: true,
+        children: $0
+      };
+    });
     function MethodModifier(state) {
       let eventData;
       if (state.events) {
@@ -7859,7 +8091,8 @@ ${input.slice(result.pos)}
         parameters
       };
     });
-    var MethodSignature$1 = $TS($S($E(MethodModifier), ClassElementName, $Q(_), NonEmptyParameters, $E(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var MethodSignature$1 = $TS($S($E(MethodModifier), ClassElementName, $E(_), NonEmptyParameters, $E(ReturnTypeSuffix)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var modifier = $1;
       var name = $2;
       var parameters = $4;
       var suffix = $5;
@@ -7872,7 +8105,7 @@ ${input.slice(result.pos)}
         type: "MethodSignature",
         children: $0,
         name,
-        modifier: $1?.[0]?.token,
+        modifier,
         returnType: suffix,
         parameters
       };
@@ -7980,8 +8213,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]
@@ -8011,21 +8244,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: module2.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: module2.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,
@@ -8491,7 +8724,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)
@@ -8520,7 +8753,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)
@@ -8549,7 +8782,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)
@@ -8642,8 +8875,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;
@@ -8807,7 +9040,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) {
@@ -8942,7 +9175,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) {
@@ -9318,7 +9551,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;
@@ -10415,7 +10648,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) {
@@ -13380,9 +13613,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) {
@@ -13394,12 +13625,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;
@@ -13530,7 +13761,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) {
@@ -13607,7 +13838,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
@@ -15742,7 +15973,7 @@ ${input.slice(result.pos)}
       }
     }
     var Yield$0 = $TS($S($EXPECT($L164, fail, 'Yield "yield"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
-      return { $loc, token: $1 };
+      return { $loc, token: $1, type: "Yield" };
     });
     function Yield(state) {
       let eventData;
@@ -17213,9 +17444,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;
@@ -17242,7 +17473,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) {
@@ -17814,7 +18045,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;
@@ -17835,7 +18066,7 @@ ${input.slice(result.pos)}
               let init, isString;
               if (property.init) {
                 init = module2.replaceNodes(
-                  module2.deepCopy(property.init),
+                  deepCopy(property.init),
                   (n) => n.type === "Identifier" && names.has(n.name),
                   (n) => [id, '["', n.name, '"]']
                 );
@@ -20554,15 +20785,12 @@ ${input.slice(result.pos)}
           ], exp.async)
         );
       }
-      module2.hasAwait = (exp) => {
-        return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
-      };
       module2.wrapIIFE = (exp, async) => {
         let prefix, suffix;
         if (async) {
           prefix = "(async ()=>{";
           suffix = "})()";
-        } else if (module2.hasAwait(exp)) {
+        } else if (hasAwait(exp)) {
           prefix = "(await (async ()=>{";
           suffix = "})())";
         } else {
@@ -21136,62 +21364,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;
-      }
-      function gatherRecursiveWithinFunction(node, predicate) {
-        return gatherRecursive(node, predicate, isFunction);
-      }
       function addParentPointers(node, parent) {
         if (node == null)
           return;
@@ -21210,43 +21382,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)];
-          })
-        );
-      }
-      module2.deepCopy = deepCopy;
       function findAncestor(node, predicate, stopPredicate) {
         node = node.parent;
         while (node && !stopPredicate?.(node)) {
@@ -21400,7 +21535,7 @@ ${input.slice(result.pos)}
             const { signature, block } = f;
             const isConstructor = signature.name === "constructor";
             const isVoid = isVoidType(signature.returnType?.t);
-            const isSet = signature.modifier === "set";
+            const isSet = signature.modifier?.set;
             if (!isConstructor && !isSet && !isVoid) {
               insertReturn(block);
             }
@@ -21561,24 +21696,24 @@ ${input.slice(result.pos)}
       };
       module2.convertMethodToFunction = function(method) {
         const { signature, block } = method;
-        let opening = signature.children[0];
-        if (opening) {
-          if (opening[0].type === "GetOrSet") {
+        let { modifier } = signature;
+        if (modifier) {
+          if (modifier.get || modifier.set) {
             throw new Error("cannot convert get/set method to function");
-          } else if (opening[0][0]?.type === "Async") {
-            opening = [opening[0][0], " function ", ...opening.slice(1)];
+          } else if (modifier.async) {
+            modifier = [modifier.children[0][0], " function ", ...modifier.children.slice(1)];
           } else {
-            opening = ["function ", ...opening];
+            modifier = ["function ", ...modifier.children];
           }
         } else {
-          opening = "function ";
+          modifier = "function ";
         }
         return {
           ...signature,
           id: signature.name,
           type: "FunctionExpression",
           children: [
-            [opening, ...signature.children.slice(1)],
+            [modifier, ...signature.children.slice(1)],
             block
           ],
           block
@@ -22209,8 +22344,12 @@ ${input.slice(result.pos)}
       module2.gatherBindingCode = gatherBindingCode;
       module2.constructInvocation = function(fn, arg) {
         const fnArr = [fn.leadingComment, fn.expr, fn.trailingComment];
-        if (fn.expr.ampersandBlock) {
-          const { ref, 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 = [module2.makeLeftHandSideExpression(arg)];
           return {
@@ -22218,7 +22357,8 @@ ${input.slice(result.pos)}
             children: [module2.skipIfOnlyWS(fn.leadingComment), ...body, module2.skipIfOnlyWS(fn.trailingComment)]
           };
         }
-        const lhs = module2.makeLeftHandSideExpression(fn.expr);
+        expr = fn.expr;
+        const lhs = module2.makeLeftHandSideExpression(expr);
         let comment = module2.skipIfOnlyWS(fn.trailingComment);
         if (comment)
           lhs.children.splice(2, 0, comment);
@@ -22542,6 +22682,18 @@ ${input.slice(result.pos)}
     }
     exports.parse = parse2;
     exports.default = { parse: parse2 };
+    var {
+      clone,
+      deepCopy,
+      gatherNodes,
+      gatherRecursive,
+      gatherRecursiveAll,
+      gatherRecursiveWithinFunction,
+      hasAwait,
+      hasYield,
+      isFunction,
+      removeParentPointers
+    } = require_lib();
   }
 });