@danielx/civet 0.7.29 → 0.7.30

package/CHANGELOG.md

@@ -4,6 +4,12 @@ This changelog is generated automatically by [`build/changelog.civet`](build/cha
 For each version of Civet, it lists and links to all incorporated PRs,
 as well as a full diff and commit list.
 
+## 0.7.30 (2024-09-15, [diff](https://github.com/DanielXMoore/Civet/compare/v0.7.29...v0.7.30), [commits](https://github.com/DanielXMoore/Civet/commits/v0.7.30))
+* Fix `!` negated indented argument in function call [[#1393](https://github.com/DanielXMoore/Civet/pull/1393)]
+* `break with` and `continue with` for modifying results array in a loop [[#1396](https://github.com/DanielXMoore/Civet/pull/1396)]
+* `break/continue [label] with` and better error handling [[#1397](https://github.com/DanielXMoore/Civet/pull/1397)]
+* `for*`, `loop*`, `while*`, `do*` generator expressions [[#1398](https://github.com/DanielXMoore/Civet/pull/1398)]
+
 ## 0.7.29 (2024-09-04, [diff](https://github.com/DanielXMoore/Civet/compare/v0.7.28...v0.7.29), [commits](https://github.com/DanielXMoore/Civet/commits/v0.7.29))
 * Lexical declarations as JSX code children [[#1387](https://github.com/DanielXMoore/Civet/pull/1387)]
 * Postfix `if`/`unless` in type declaration [[#1388](https://github.com/DanielXMoore/Civet/pull/1388)]

package/dist/browser.js

@@ -685,7 +685,7 @@ ${body}`;
     "ForStatement",
     "IfStatement",
     "IterationStatement",
-    "LabeledStatement",
+    "LabelledStatement",
     "ReturnStatement",
     "SwitchStatement",
     "ThrowStatement",
@@ -730,13 +730,16 @@ ${body}`;
         return node.expressions.some((s) => isExit(s[1]));
       }
       case "IterationStatement": {
-        return node.condition?.type === "ParenthesizedExpression" && node.condition.expression?.type === "Literal" && node.condition.expression?.raw === "true" && gatherRecursiveWithinFunction(node.block, ($) => $.type === "BreakStatement").length === 0;
+        return isLoopStatement(node) && gatherRecursiveWithinFunction(node.block, ($) => $.type === "BreakStatement").length === 0;
       }
       default: {
         return false;
       }
     }
   }
+  function isLoopStatement(node) {
+    return node.type === "IterationStatement" && node.condition?.type === "ParenthesizedExpression" && node.condition.expression?.type === "Literal" && node.condition.expression?.raw === "true";
+  }
   function isComma(node) {
     if (node?.token === ",") {
       return node;
@@ -1102,7 +1105,7 @@ ${body}`;
     }
     return ["(", type, ")"];
   }
-  function wrapIIFE(expressions, asyncFlag) {
+  function wrapIIFE(expressions, asyncFlag, generator) {
     let prefix;
     const async = [];
     if (asyncFlag) {
@@ -1128,23 +1131,49 @@ ${body}`;
     };
     const signature = {
       modifier: {
-        async: !!async.length
+        async: !!async.length,
+        generator: !!generator
       },
       returnType: void 0
     };
-    const fn = makeNode({
-      type: "ArrowFunction",
-      signature,
-      parameters,
-      returnType: void 0,
-      ts: false,
-      async,
-      block,
-      children: [async, parameters, "=>", block]
-    });
+    let fn;
+    if (generator) {
+      fn = makeNode({
+        type: "FunctionExpression",
+        signature,
+        parameters,
+        returnType: void 0,
+        ts: false,
+        async,
+        block,
+        generator,
+        children: [async, "function", generator, parameters, block]
+      });
+    } else {
+      fn = makeNode({
+        type: "ArrowFunction",
+        signature,
+        parameters,
+        returnType: void 0,
+        ts: false,
+        async,
+        block,
+        children: [async, parameters, "=>", block]
+      });
+    }
+    const children = [makeLeftHandSideExpression(fn), "()"];
+    if (fn.type === "FunctionExpression") {
+      if (gatherRecursiveWithinFunction(block, (a1) => typeof a1 === "object" && a1 != null && "token" in a1 && a1.token === "this").length) {
+        children.splice(1, 0, ".bind(this)");
+      }
+      if (gatherRecursiveWithinFunction(block, (a2) => typeof a2 === "object" && a2 != null && "token" in a2 && a2.token === "arguments").length) {
+        let ref2;
+        children[children.length - 1] = (ref2 = parameters.children)[ref2.length - 1] = "(arguments)";
+      }
+    }
     const exp = makeNode({
       type: "CallExpression",
-      children: [makeLeftHandSideExpression(fn), "()"]
+      children
     });
     if (prefix) {
       return makeLeftHandSideExpression([prefix, exp]);
@@ -1765,7 +1794,7 @@ ${body}`;
       ({ type } = exp);
     }
     let ref4;
-    switch (exp.type) {
+    switch (type) {
       case "BreakStatement":
       case "ContinueStatement":
       case "DebuggerStatement":
@@ -1986,6 +2015,58 @@ ${body}`;
       return insertReturn(clause);
     });
   }
+  function processBreakContinueWith(statement) {
+    let changed = false;
+    for (const control of gatherRecursiveWithinFunction(
+      statement.block,
+      ($) => $.type === "BreakStatement" || $.type === "ContinueStatement"
+    )) {
+      let controlName2 = function() {
+        switch (control.type) {
+          case "BreakStatement": {
+            return "break";
+          }
+          case "ContinueStatement": {
+            return "continue";
+          }
+        }
+      };
+      var controlName = controlName2;
+      if (control.with) {
+        if (control.label) {
+          let m1;
+          if (!(m1 = statement.parent, typeof m1 === "object" && m1 != null && "type" in m1 && m1.type === "LabelledStatement" && "label" in m1 && typeof m1.label === "object" && m1.label != null && "name" in m1.label && m1.label.name === control.label.name)) {
+            continue;
+          }
+        } else {
+          const { ancestor } = findAncestor(
+            control,
+            (s) => s === statement || s.type === "IterationStatement" || s.type === "ForStatement" || s.type === "SwitchStatement" && control.type === "BreakStatement"
+          );
+          if (!(ancestor === statement)) {
+            continue;
+          }
+        }
+        control.children.unshift(
+          control.type === "BreakStatement" ? (changed = true, [statement.resultsRef, " =", control.with, ";"]) : (
+            // control.type is "ContinueStatement"
+            [statement.resultsRef, ".push(", trimFirstSpace(control.with), ");"]
+          )
+        );
+        updateParentPointers(control.with, control);
+        const i = control.children.findIndex(($1) => $1?.type === "Error");
+        if (i >= 0) {
+          control.children.splice(i, 1);
+        }
+        const block = control.parent;
+        if (!(block?.type === "BlockStatement")) {
+          throw new Error(`Expected parent of ${controlName2()} to be BlockStatement`);
+        }
+        braceBlock(block);
+      }
+    }
+    return changed;
+  }
   function wrapIterationReturningResults(statement, outer, collect) {
     if (statement.type === "DoStatement" || statement.type === "ComptimeStatement") {
       if (collect) {
@@ -2001,14 +2082,37 @@ ${body}`;
       "wrapIterationReturningResults should not be called twice on the same statement"
     );
     const resultsRef = statement.resultsRef = makeRef("results");
+    let decl = "const";
+    if (statement.type === "IterationStatement" || statement.type === "ForStatement") {
+      if (processBreakContinueWith(statement)) {
+        decl = "let";
+      }
+    }
+    const breakWithOnly = decl === "let" && isLoopStatement(statement) && gatherRecursive(
+      statement.block,
+      (s) => s.type === "BreakStatement" && !s.with,
+      (s) => isFunction(s) || s.type === "IterationStatement"
+    ).length === 0;
     const declaration = {
       type: "Declaration",
-      children: ["const ", resultsRef, "=[]"]
+      children: [decl, " ", resultsRef],
+      decl,
+      names: [],
+      bindings: []
     };
+    if (decl === "const") {
+      declaration.children.push("=[]");
+    } else {
+      if (!breakWithOnly) {
+        declaration.children.push(";", resultsRef, "=[]");
+      }
+    }
     outer.children.unshift(["", declaration, ";"]);
-    assignResults(statement.block, (node) => {
-      return [resultsRef, ".push(", node, ")"];
-    });
+    if (!breakWithOnly) {
+      assignResults(statement.block, (node) => {
+        return [resultsRef, ".push(", node, ")"];
+      });
+    }
     if (collect) {
       statement.children.push(collect(resultsRef));
     } else {
@@ -2074,8 +2178,8 @@ ${body}`;
     }
     if (hasYield(block) && !f.generator?.length) {
       if (f.type === "ArrowFunction") {
-        gatherRecursiveWithinFunction(block, ($) => $.type === "YieldExpression").forEach((y) => {
-          const i = y.children.findIndex(($1) => $1.type === "Yield");
+        gatherRecursiveWithinFunction(block, ($2) => $2.type === "YieldExpression").forEach((y) => {
+          const i = y.children.findIndex(($3) => $3.type === "Yield");
           return y.children.splice(i + 1, 0, {
             type: "Error",
             message: "Can't use yield inside of => arrow function"
@@ -2103,31 +2207,55 @@ ${body}`;
     });
   }
   function expressionizeIteration(exp) {
-    const { async, subtype, block, children, statement } = exp;
+    const { async, generator, subtype, block, children, statement } = exp;
     const i = children.indexOf(statement);
     if (i < 0) {
       throw new Error("Could not find iteration statement in iteration expression");
     }
     if (subtype === "DoStatement" || subtype === "ComptimeStatement") {
-      children.splice(i, 1, wrapIIFE([["", statement, void 0]], async));
+      children.splice(i, 1, wrapIIFE([["", statement, void 0]], async, generator));
       updateParentPointers(exp);
       return;
     }
-    exp.resultsRef ??= makeRef("results");
-    const { resultsRef } = exp;
-    assignResults(block, (node) => {
-      return [resultsRef, ".push(", node, ")"];
-    });
-    braceBlock(block);
-    children.splice(
-      i,
-      1,
-      wrapIIFE([
-        ["", ["const ", resultsRef, "=[]"], ";"],
-        ...children.map((c) => ["", c, void 0]),
-        ["", wrapWithReturn(resultsRef)]
-      ], async)
-    );
+    if (generator) {
+      assignResults(block, (node) => {
+        return {
+          type: "YieldExpression",
+          expression: node,
+          children: ["yield ", node]
+        };
+      });
+      braceBlock(block);
+      children.splice(
+        i,
+        1,
+        wrapIIFE([
+          ["", statement, void 0],
+          // Prevent implicit return in generator, by adding an explicit return
+          ["", {
+            type: "ReturnStatement",
+            expression: void 0,
+            children: [";return"]
+          }, void 0]
+        ], async, generator)
+      );
+    } else {
+      exp.resultsRef ??= makeRef("results");
+      const { resultsRef } = exp;
+      assignResults(block, (node) => {
+        return [resultsRef, ".push(", node, ")"];
+      });
+      braceBlock(block);
+      children.splice(
+        i,
+        1,
+        wrapIIFE([
+          ["", ["const ", resultsRef, "=[]"], ";"],
+          ["", statement, void 0],
+          ["", wrapWithReturn(resultsRef)]
+        ], async)
+      );
+    }
     updateParentPointers(exp);
   }
   function skipImplicitArguments(args) {
@@ -2141,7 +2269,7 @@ ${body}`;
     return false;
   }
   function processCoffeeDo(ws, expression) {
-    ws = insertTrimmingSpace(ws, "");
+    ws = trimFirstSpace(ws);
     const args = [];
     if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "ArrowFunction" || typeof expression === "object" && expression != null && "type" in expression && expression.type === "FunctionExpression") {
       const { parameters } = expression;
@@ -2175,7 +2303,7 @@ ${body}`;
       expression = {
         ...expression,
         parameters: newParameters,
-        children: expression.children.map(($2) => $2 === parameters ? newParameters : $2)
+        children: expression.children.map(($4) => $4 === parameters ? newParameters : $4)
       };
     }
     return {
@@ -2196,7 +2324,7 @@ ${body}`;
       ref = makeRef("$");
       inplacePrepend(ref, body);
     }
-    if (startsWithPredicate(body, ($3) => $3.type === "ObjectExpression")) {
+    if (startsWithPredicate(body, ($5) => $5.type === "ObjectExpression")) {
       body = makeLeftHandSideExpression(body);
     }
     const parameters = makeNode({
@@ -3457,7 +3585,7 @@ ${body}`;
     const blockStatement = ["", statementExp];
     let ref;
     if (statementExp.type === "IterationExpression") {
-      if (statementExp.async) {
+      if (statementExp.async || statementExp.generator) {
         return;
       }
       const statement2 = statementExp.statement;
@@ -6020,7 +6148,8 @@ ${js}`
           type: "IterationExpression",
           children: [statement],
           block: statement.block,
-          statement
+          statement,
+          generator: statement.generator
         };
       }
       case "IfStatement": {
@@ -6547,6 +6676,7 @@ ${js}`
     ReservedBinary,
     ArgumentsWithTrailingMemberExpressions,
     TrailingMemberExpressions,
+    IndentedTrailingMemberExpression,
     AllowedTrailingMemberExpressions,
     TrailingCallExpressions,
     AllowedTrailingCallExpressions,
@@ -6815,6 +6945,7 @@ ${js}`
     BlockStatement,
     LabelledStatement,
     Label,
+    LabelIdentifier,
     LabelledItem,
     IfStatement,
     ElseClause,
@@ -7874,7 +8005,7 @@ ${js}`
   function ExplicitArguments(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "ExplicitArguments", ExplicitArguments$0);
   }
-  var ApplicationStart$0 = (0, import_lib3.$S)(IndentedApplicationAllowed, (0, import_lib3.$Y)((0, import_lib3.$S)(IndentedFurther, (0, import_lib3.$N)(IdentifierBinaryOp), (0, import_lib3.$N)(AccessStart))));
+  var ApplicationStart$0 = (0, import_lib3.$S)(IndentedApplicationAllowed, (0, import_lib3.$Y)((0, import_lib3.$S)(IndentedFurther, (0, import_lib3.$N)(IdentifierBinaryOp))), (0, import_lib3.$N)(IndentedTrailingMemberExpression));
   var ApplicationStart$1 = (0, import_lib3.$S)((0, import_lib3.$N)(EOS), (0, import_lib3.$Y)((0, import_lib3.$S)(_, (0, import_lib3.$C)(BracedApplicationAllowed, (0, import_lib3.$N)((0, import_lib3.$EXPECT)($L1, 'ApplicationStart "{"'))), (0, import_lib3.$N)(ForbiddenImplicitCalls))));
   var ApplicationStart$$ = [ApplicationStart$0, ApplicationStart$1];
   function ApplicationStart(ctx, state2) {
@@ -7915,20 +8046,20 @@ ${js}`
   function ArgumentsWithTrailingMemberExpressions(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "ArgumentsWithTrailingMemberExpressions", ArgumentsWithTrailingMemberExpressions$0);
   }
-  var TrailingMemberExpressions$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$Q)(MemberExpressionRest), (0, import_lib3.$Q)((0, import_lib3.$S)(IndentedAtLeast, (0, import_lib3.$Y)((0, import_lib3.$S)((0, import_lib3.$E)((0, import_lib3.$EXPECT)($L6, 'TrailingMemberExpressions "?"')), (0, import_lib3.$EXPECT)($L7, 'TrailingMemberExpressions "."'), (0, import_lib3.$N)((0, import_lib3.$EXPECT)($R3, "TrailingMemberExpressions /[0-9]/")))), MemberExpressionRest))), function($skip, $loc, $0, $1, $2) {
-    return $1.concat($2.map(([ws, , memberExpressionRest]) => {
-      if (Array.isArray(memberExpressionRest)) {
-        return [ws, ...memberExpressionRest];
-      }
-      return {
-        ...memberExpressionRest,
-        children: [ws, ...memberExpressionRest.children]
-      };
-    }));
+  var TrailingMemberExpressions$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$Q)(MemberExpressionRest), (0, import_lib3.$Q)(IndentedTrailingMemberExpression)), function($skip, $loc, $0, $1, $2) {
+    return [...$1, ...$2];
   });
   function TrailingMemberExpressions(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "TrailingMemberExpressions", TrailingMemberExpressions$0);
   }
+  var IndentedTrailingMemberExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(IndentedAtLeast, (0, import_lib3.$Y)((0, import_lib3.$S)((0, import_lib3.$E)((0, import_lib3.$EXPECT)($L6, 'IndentedTrailingMemberExpression "?"')), (0, import_lib3.$EXPECT)($L7, 'IndentedTrailingMemberExpression "."'), (0, import_lib3.$N)((0, import_lib3.$EXPECT)($R3, "IndentedTrailingMemberExpression /[0-9]/")))), MemberExpressionRest), function($skip, $loc, $0, $1, $2, $3) {
+    var ws = $1;
+    var rest = $3;
+    return prepend(ws, rest);
+  });
+  function IndentedTrailingMemberExpression(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "IndentedTrailingMemberExpression", IndentedTrailingMemberExpression$0);
+  }
   var AllowedTrailingMemberExpressions$0 = (0, import_lib3.$T)((0, import_lib3.$S)(TrailingMemberPropertyAllowed, TrailingMemberExpressions), function(value) {
     return value[1];
   });
@@ -12472,8 +12603,10 @@ ${js}`
   var Statement$2 = (0, import_lib3.$T)((0, import_lib3.$S)(IfStatement, (0, import_lib3.$N)(ShouldExpressionize)), function(value) {
     return value[0];
   });
-  var Statement$3 = (0, import_lib3.$T)((0, import_lib3.$S)(IterationStatement, (0, import_lib3.$N)(ShouldExpressionize)), function(value) {
-    return value[0];
+  var Statement$3 = (0, import_lib3.$TS)((0, import_lib3.$S)(IterationStatement, (0, import_lib3.$N)(ShouldExpressionize)), function($skip, $loc, $0, $1, $2) {
+    if ($1.generator)
+      return $skip;
+    return $1;
   });
   var Statement$4 = (0, import_lib3.$T)((0, import_lib3.$S)(SwitchStatement, (0, import_lib3.$N)(ShouldExpressionize)), function(value) {
     return value[0];
@@ -12544,11 +12677,22 @@ ${js}`
     var colon = $1;
     var id = $2;
     var w = $3;
-    return [id, colon, w];
+    return {
+      type: "Label",
+      name: id.name,
+      children: [id, colon, w]
+    };
   });
   function Label(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "Label", Label$0);
   }
+  var LabelIdentifier$0 = (0, import_lib3.$T)((0, import_lib3.$S)((0, import_lib3.$E)(Colon), Identifier), function(value) {
+    var id = value[1];
+    return id;
+  });
+  function LabelIdentifier(ctx, state2) {
+    return (0, import_lib3.$EVENT)(ctx, state2, "LabelIdentifier", LabelIdentifier$0);
+  }
   var LabelledItem$0 = Statement;
   var LabelledItem$1 = FunctionDeclaration;
   var LabelledItem$$ = [LabelledItem$0, LabelledItem$1];
@@ -12645,7 +12789,8 @@ ${js}`
       children: [statement],
       block: statement.block,
       statement,
-      async
+      async,
+      generator: statement.generator
     };
   });
   function IterationExpression(ctx, state2) {
@@ -12664,8 +12809,9 @@ ${js}`
   function LoopStatement(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "LoopStatement", LoopStatement$0);
   }
-  var LoopClause$0 = (0, import_lib3.$TV)(Loop, function($skip, $loc, $0, $1) {
-    var kind = $0;
+  var LoopClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Loop, (0, import_lib3.$E)((0, import_lib3.$S)((0, import_lib3.$E)(_), Star))), function($skip, $loc, $0, $1, $2) {
+    var kind = $1;
+    var generator = $2;
     const expression = {
       type: "Literal",
       children: ["true"],
@@ -12680,33 +12826,41 @@ ${js}`
       type: "IterationStatement",
       subtype: kind.token,
       children: [kind, condition],
-      condition
+      condition,
+      generator
     };
   });
   function LoopClause(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "LoopClause", LoopClause$0);
   }
-  var DoWhileStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Do, NoPostfixBracedOrEmptyBlock, __, WhileClause), function($skip, $loc, $0, $1, $2, $3, $4) {
-    var block = $2;
-    var clause = $4;
+  var DoWhileStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Do, (0, import_lib3.$E)((0, import_lib3.$S)((0, import_lib3.$E)(_), Star)), NoPostfixBracedOrEmptyBlock, __, WhileClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var d = $1;
+    var generator = $2;
+    var block = $3;
+    var ws = $4;
+    var clause = $5;
     return {
       ...clause,
       type: "IterationStatement",
       subtype: "do-while",
-      children: $0,
-      block
+      children: [d, block, ws, clause],
+      block,
+      generator
     };
   });
   function DoWhileStatement(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "DoWhileStatement", DoWhileStatement$0);
   }
-  var DoStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Do, NoPostfixBracedOrEmptyBlock), function($skip, $loc, $0, $1, $2) {
-    var block = $2;
+  var DoStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Do, (0, import_lib3.$E)((0, import_lib3.$S)((0, import_lib3.$E)(_), Star)), NoPostfixBracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3) {
+    var d = $1;
+    var generator = $2;
+    var block = $3;
     block = trimFirstSpace(block);
     return {
       type: "DoStatement",
       children: [block],
-      block
+      block,
+      generator
     };
   });
   function DoStatement(ctx, state2) {
@@ -12741,10 +12895,11 @@ ${js}`
   function WhileStatement(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "WhileStatement", WhileStatement$0);
   }
-  var WhileClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)(While, Until), (0, import_lib3.$E)(_), Condition), function($skip, $loc, $0, $1, $2, $3) {
+  var WhileClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)(While, Until), (0, import_lib3.$E)((0, import_lib3.$S)((0, import_lib3.$E)(_), Star)), (0, import_lib3.$E)(_), Condition), function($skip, $loc, $0, $1, $2, $3, $4) {
     var kind = $1;
-    var ws = $2;
-    var condition = $3;
+    var generator = $2;
+    var ws = $3;
+    var condition = $4;
     if (kind.negated) {
       kind = { ...kind, token: "while" };
       condition = negateCondition(condition);
@@ -12754,6 +12909,7 @@ ${js}`
       subtype: kind.token,
       children: [kind, ws, condition],
       condition,
+      generator,
       negated: kind.negated
     };
   });
@@ -12773,16 +12929,18 @@ ${js}`
   function ForStatement(ctx, state2) {
     return (0, import_lib3.$EVENT)(ctx, state2, "ForStatement", ForStatement$0);
   }
-  var ForClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(For, __, ForStatementControl), function($skip, $loc, $0, $1, $2, $3) {
-    var c = $3;
+  var ForClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(For, (0, import_lib3.$E)((0, import_lib3.$S)((0, import_lib3.$E)(_), Star)), __, ForStatementControl), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var generator = $2;
+    var c = $4;
     const { children, declaration } = c;
     return {
       type: "ForStatement",
-      children: [$1, ...$2, ...children],
+      children: [$1, ...$3, ...children],
       declaration,
       block: null,
       blockPrefix: c.blockPrefix,
-      hoistDec: c.hoistDec
+      hoistDec: c.hoistDec,
+      generator
     };
   });
   function ForClause(ctx, state2) {
@@ -13549,11 +13707,21 @@ ${js}`
   function ExpressionStatement(ctx, state2) {
     return (0, import_lib3.$EVENT_C)(ctx, state2, "ExpressionStatement", ExpressionStatement$$);
   }
-  var KeywordStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Break, (0, import_lib3.$E)((0, import_lib3.$S)(_, (0, import_lib3.$E)(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
+  var KeywordStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Break, (0, import_lib3.$E)((0, import_lib3.$S)(_, LabelIdentifier)), (0, import_lib3.$E)((0, import_lib3.$S)(_, With, MaybeNestedExtendedExpression))), function($skip, $loc, $0, $1, $2, $3) {
+    const children = [$1];
+    if ($2)
+      children.push($2);
+    if ($3)
+      children.push({
+        type: "Error",
+        subtype: "Warning",
+        message: "'break with' outside of loop that returns a value"
+      });
     return {
       type: "BreakStatement",
-      children: $2 ? [$1, $2[0], $2[2]] : [$1]
-      // omit colon
+      label: $2?.[1],
+      with: $3?.[2],
+      children
     };
   });
   var KeywordStatement$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(Continue, _, Switch), function($skip, $loc, $0, $1, $2, $3) {
@@ -13563,11 +13731,21 @@ ${js}`
       children: []
     };
   });
-  var KeywordStatement$2 = (0, import_lib3.$TS)((0, import_lib3.$S)(Continue, (0, import_lib3.$E)((0, import_lib3.$S)(_, (0, import_lib3.$E)(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
+  var KeywordStatement$2 = (0, import_lib3.$TS)((0, import_lib3.$S)(Continue, (0, import_lib3.$E)((0, import_lib3.$S)(_, LabelIdentifier)), (0, import_lib3.$E)((0, import_lib3.$S)(_, With, MaybeNestedExtendedExpression))), function($skip, $loc, $0, $1, $2, $3) {
+    const children = [$1];
+    if ($2)
+      children.push($2);
+    if ($3)
+      children.push({
+        type: "Error",
+        subtype: "Warning",
+        message: "'continue with' outside of loop that returns a value"
+      });
     return {
       type: "ContinueStatement",
-      children: $2 ? [$1, $2[0], $2[2]] : [$1]
-      // omit colon
+      label: $2?.[1],
+      with: $3?.[2],
+      children
     };
   });
   var KeywordStatement$3 = DebuggerStatement;