@danielx/civet 0.5.81 → 0.5.82

package/dist/browser.js

@@ -116,12 +116,29 @@ var Civet = (() => {
         }
         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
       };
     }
@@ -569,7 +586,6 @@ ${input.slice(result.pos)}
         YieldExpression,
         YieldTail,
         ArrowFunction,
-        ArrowFunctionTail,
         FatArrow,
         FatArrowBody,
         ConditionalExpression,
@@ -2589,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;
@@ -2643,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;
         }
       }
@@ -3561,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];
@@ -5664,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) {
@@ -5711,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",
@@ -5759,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 {
@@ -5959,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
@@ -7939,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,
@@ -7970,9 +8029,37 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var MethodModifier$0 = $S(GetOrSet, $E(_));
-      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) {
@@ -8005,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;
@@ -8018,7 +8106,7 @@ ${input.slice(result.pos)}
           type: "MethodSignature",
           children: $0,
           name,
-          modifier: $1?.[0]?.token,
+          modifier,
           returnType: suffix,
           parameters
         };
@@ -15886,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;
@@ -20698,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 {
@@ -21280,13 +21365,6 @@ ${input.slice(result.pos)}
             }, props2]
           };
         };
-        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;
@@ -21458,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);
               }
@@ -21619,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
@@ -22611,6 +22689,10 @@ ${input.slice(result.pos)}
         gatherNodes,
         gatherRecursive,
         gatherRecursiveAll,
+        gatherRecursiveWithinFunction,
+        hasAwait,
+        hasYield,
+        isFunction,
         removeParentPointers
       } = require_lib();
     }

package/dist/main.js

@@ -115,12 +115,29 @@ var require_lib = __commonJS({
       }
       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
     };
   }
@@ -568,7 +585,6 @@ ${input.slice(result.pos)}
       YieldExpression,
       YieldTail,
       ArrowFunction,
-      ArrowFunctionTail,
       FatArrow,
       FatArrowBody,
       ConditionalExpression,
@@ -2588,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;
@@ -2642,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;
       }
     }
@@ -3560,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];
@@ -5663,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) {
@@ -5710,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",
@@ -5758,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 {
@@ -5958,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
@@ -7938,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,
@@ -7969,9 +8028,37 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var MethodModifier$0 = $S(GetOrSet, $E(_));
-    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) {
@@ -8004,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;
@@ -8017,7 +8105,7 @@ ${input.slice(result.pos)}
         type: "MethodSignature",
         children: $0,
         name,
-        modifier: $1?.[0]?.token,
+        modifier,
         returnType: suffix,
         parameters
       };
@@ -15885,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;
@@ -20697,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 {
@@ -21279,13 +21364,6 @@ ${input.slice(result.pos)}
           }, props2]
         };
       };
-      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;
@@ -21457,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);
             }
@@ -21618,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
@@ -22610,6 +22688,10 @@ ${input.slice(result.pos)}
       gatherNodes,
       gatherRecursive,
       gatherRecursiveAll,
+      gatherRecursiveWithinFunction,
+      hasAwait,
+      hasYield,
+      isFunction,
       removeParentPointers
     } = require_lib();
   }

package/dist/main.mjs

@@ -113,12 +113,29 @@ var require_lib = __commonJS({
       }
       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
     };
   }
@@ -566,7 +583,6 @@ ${input.slice(result.pos)}
       YieldExpression,
       YieldTail,
       ArrowFunction,
-      ArrowFunctionTail,
       FatArrow,
       FatArrowBody,
       ConditionalExpression,
@@ -2586,53 +2602,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;
@@ -2640,14 +2639,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;
       }
     }
@@ -3558,9 +3557,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];
@@ -5661,22 +5667,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) {
@@ -5708,6 +5720,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",
@@ -5756,7 +5774,7 @@ ${input.slice(result.pos)}
         body = [prefix, rhs];
       }
       const children = [ref, " => ", ...body];
-      if (module.hasAwait(body)) {
+      if (hasAwait(body)) {
         children.unshift("async ");
       }
       return {
@@ -5956,20 +5974,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
@@ -7936,9 +7966,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,
@@ -7967,9 +8026,37 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var MethodModifier$0 = $S(GetOrSet, $E(_));
-    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) {
@@ -8002,7 +8089,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;
@@ -8015,7 +8103,7 @@ ${input.slice(result.pos)}
         type: "MethodSignature",
         children: $0,
         name,
-        modifier: $1?.[0]?.token,
+        modifier,
         returnType: suffix,
         parameters
       };
@@ -15883,7 +15971,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;
@@ -20695,15 +20783,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 {
@@ -21277,13 +21362,6 @@ ${input.slice(result.pos)}
           }, props2]
         };
       };
-      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;
@@ -21455,7 +21533,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);
             }
@@ -21616,24 +21694,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
@@ -22608,6 +22686,10 @@ ${input.slice(result.pos)}
       gatherNodes,
       gatherRecursive,
       gatherRecursiveAll,
+      gatherRecursiveWithinFunction,
+      hasAwait,
+      hasYield,
+      isFunction,
       removeParentPointers
     } = require_lib();
   }

package/package.json

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