@danielx/civet 0.5.80 → 0.5.82

package/dist/browser.js

@@ -27,6 +27,123 @@ 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;
+      }
+      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);
+      }
+      module.exports = {
+        clone,
+        deepCopy,
+        gatherNodes,
+        gatherRecursive,
+        gatherRecursiveAll,
+        gatherRecursiveWithinFunction,
+        hasAwait,
+        hasYield,
+        isFunction,
+        removeParentPointers
+      };
+    }
+  });
+
   // source/parser.hera
   var require_parser = __commonJS({
     "source/parser.hera"(exports, module) {
@@ -469,7 +586,6 @@ ${input.slice(result.pos)}
         YieldExpression,
         YieldTail,
         ArrowFunction,
-        ArrowFunctionTail,
         FatArrow,
         FatArrowBody,
         ConditionalExpression,
@@ -566,6 +682,7 @@ ${input.slice(result.pos)}
         FunctionDeclaration,
         FunctionSignature,
         FunctionExpression,
+        AmpersandFunctionExpression,
         OperatorDeclaration,
         OperatorSignature,
         AmpersandBlockRHS,
@@ -1880,8 +1997,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 +2027,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 +2103,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 +2462,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 +2582,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) {
@@ -2488,53 +2605,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;
@@ -2542,14 +2642,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;
         }
       }
@@ -2637,7 +2737,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 +2816,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 +2862,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 +2874,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 +2888,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 +2903,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 +3355,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 +3501,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;
@@ -3439,9 +3560,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];
@@ -3456,7 +3584,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;
@@ -5542,22 +5670,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) {
@@ -5589,6 +5723,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",
@@ -5596,7 +5736,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)
@@ -5614,7 +5777,7 @@ ${input.slice(result.pos)}
           body = [prefix, rhs];
         }
         const children = [ref, " => ", ...body];
-        if (module.hasAwait(body)) {
+        if (hasAwait(body)) {
           children.unshift("async ");
         }
         return {
@@ -5625,10 +5788,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 +5799,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;
         }
       }
@@ -5814,20 +5977,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
@@ -6198,7 +6373,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 +6489,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 +7533,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];
       });
@@ -7794,9 +7969,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,
@@ -7825,9 +8029,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) {
@@ -7860,7 +8092,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;
@@ -7873,7 +8106,7 @@ ${input.slice(result.pos)}
           type: "MethodSignature",
           children: $0,
           name,
-          modifier: $1?.[0]?.token,
+          modifier,
           returnType: suffix,
           parameters
         };
@@ -7981,8 +8214,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 +8245,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 +8725,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 +8754,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 +8783,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 +8876,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 +9041,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 +9176,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 +9552,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 +10649,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 +13614,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 +13626,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 +13762,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 +13839,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
@@ -15743,7 +15974,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;
@@ -17214,9 +17445,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 +17474,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 +18046,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 +18067,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, '"]']
                   );
@@ -20555,15 +20786,12 @@ ${input.slice(result.pos)}
             ], exp.async)
           );
         }
-        module.hasAwait = (exp) => {
-          return gatherRecursiveWithinFunction(exp, ({ type }) => type === "Await").length > 0;
-        };
         module.wrapIIFE = (exp, async) => {
           let prefix, suffix;
           if (async) {
             prefix = "(async ()=>{";
             suffix = "})()";
-          } else if (module.hasAwait(exp)) {
+          } else if (hasAwait(exp)) {
             prefix = "(await (async ()=>{";
             suffix = "})())";
           } else {
@@ -21137,62 +21365,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;
@@ -21211,43 +21383,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)) {
@@ -21401,7 +21536,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);
               }
@@ -21562,24 +21697,24 @@ ${input.slice(result.pos)}
         };
         module.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
@@ -22210,8 +22345,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 +22358,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 +22683,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();
     }
   });