@danielx/civet 0.7.29 → 0.7.31

package/dist/civet

@@ -516,6 +516,7 @@ Options:
   --no-cache       Disable compiler caching (slow, for debugging)
   --typecheck      Run TypeScript and output diagnostics
   --emit-declaration  Run TypeScript and emit .d.ts files (if no errors)
+  --trace XX       Log detailed parsing notes to a file, for parser debugging
 
 You can use - to read from stdin or (prefixed by -o) write to stdout.
 

package/dist/main.js

@@ -678,7 +678,7 @@ var statementTypes = /* @__PURE__ */ new Set([
   "ForStatement",
   "IfStatement",
   "IterationStatement",
-  "LabeledStatement",
+  "LabelledStatement",
   "ReturnStatement",
   "SwitchStatement",
   "ThrowStatement",
@@ -723,13 +723,16 @@ function isExit(node) {
       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;
@@ -1095,7 +1098,7 @@ function parenthesizeType(type) {
   }
   return ["(", type, ")"];
 }
-function wrapIIFE(expressions, asyncFlag) {
+function wrapIIFE(expressions, asyncFlag, generator) {
   let prefix;
   const async = [];
   if (asyncFlag) {
@@ -1121,23 +1124,49 @@ function wrapIIFE(expressions, asyncFlag) {
   };
   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]);
@@ -1758,7 +1787,7 @@ function assignResults(node, collect) {
     ({ type } = exp);
   }
   let ref4;
-  switch (exp.type) {
+  switch (type) {
     case "BreakStatement":
     case "ContinueStatement":
     case "DebuggerStatement":
@@ -1979,6 +2008,58 @@ function insertSwitchReturns(exp) {
     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) {
@@ -1994,14 +2075,37 @@ function wrapIterationReturningResults(statement, outer, collect) {
     "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 {
@@ -2067,8 +2171,8 @@ function processSignature(f) {
   }
   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"
@@ -2096,31 +2200,55 @@ function processFunctions(statements, config2) {
   });
 }
 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) {
@@ -2134,7 +2262,7 @@ function skipImplicitArguments(args) {
   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;
@@ -2168,7 +2296,7 @@ function processCoffeeDo(ws, expression) {
     expression = {
       ...expression,
       parameters: newParameters,
-      children: expression.children.map(($2) => $2 === parameters ? newParameters : $2)
+      children: expression.children.map(($4) => $4 === parameters ? newParameters : $4)
     };
   }
   return {
@@ -2189,7 +2317,7 @@ function makeAmpersandFunction(rhs) {
     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({
@@ -3450,7 +3578,7 @@ function prependStatementExpressionBlock(initializer, statement) {
   const blockStatement = ["", statementExp];
   let ref;
   if (statementExp.type === "IterationExpression") {
-    if (statementExp.async) {
+    if (statementExp.async || statementExp.generator) {
       return;
     }
     const statement2 = statementExp.statement;
@@ -5998,7 +6126,8 @@ function attachPostfixStatementAsExpression(exp, post) {
         type: "IterationExpression",
         children: [statement],
         block: statement.block,
-        statement
+        statement,
+        generator: statement.generator
       };
     }
     case "IfStatement": {
@@ -6525,6 +6654,7 @@ var grammar = {
   ReservedBinary,
   ArgumentsWithTrailingMemberExpressions,
   TrailingMemberExpressions,
+  IndentedTrailingMemberExpression,
   AllowedTrailingMemberExpressions,
   TrailingCallExpressions,
   AllowedTrailingCallExpressions,
@@ -6793,6 +6923,7 @@ var grammar = {
   BlockStatement,
   LabelledStatement,
   Label,
+  LabelIdentifier,
   LabelledItem,
   IfStatement,
   ElseClause,
@@ -7852,7 +7983,7 @@ var ExplicitArguments$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(OpenParen, (0
 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) {
@@ -7893,20 +8024,20 @@ var ArgumentsWithTrailingMemberExpressions$0 = (0, import_lib3.$TS)((0, import_l
 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];
 });
@@ -12450,8 +12581,10 @@ var Statement$1 = VariableStatement;
 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];
@@ -12522,11 +12655,22 @@ var Label$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(Colon, Identifier, Whites
   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];
@@ -12623,7 +12767,8 @@ var IterationExpression$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_
     children: [statement],
     block: statement.block,
     statement,
-    async
+    async,
+    generator: statement.generator
   };
 });
 function IterationExpression(ctx, state2) {
@@ -12642,8 +12787,9 @@ var LoopStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(LoopClause, Block
 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"],
@@ -12658,33 +12804,41 @@ var LoopClause$0 = (0, import_lib3.$TV)(Loop, function($skip, $loc, $0, $1) {
     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) {
@@ -12719,10 +12873,11 @@ var WhileStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(WhileClause, Blo
 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);
@@ -12732,6 +12887,7 @@ var WhileClause$0 = (0, import_lib3.$TS)((0, import_lib3.$S)((0, import_lib3.$C)
     subtype: kind.token,
     children: [kind, ws, condition],
     condition,
+    generator,
     negated: kind.negated
   };
 });
@@ -12751,16 +12907,18 @@ var ForStatement$0 = (0, import_lib3.$TS)((0, import_lib3.$S)(ForClause, BlockOr
 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) {
@@ -13527,11 +13685,21 @@ var ExpressionStatement$$ = [ExpressionStatement$0, ExpressionStatement$1];
 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) {
@@ -13541,11 +13709,21 @@ var KeywordStatement$1 = (0, import_lib3.$TS)((0, import_lib3.$S)(Continue, _, S
     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;
@@ -17694,19 +17872,6 @@ var Reset$0 = (0, import_lib3.$TV)((0, import_lib3.$EXPECT)($L0, 'Reset ""'), fu
     }
   });
   Object.assign(config, initialConfig);
-  return {
-    type: "ParserMeta",
-    children: [],
-    getStateKey() {
-      const stateInt = state.currentIndent.level % 256 << 8 | state.classImplicitCallForbidden << 7 | state.indentedApplicationForbidden << 6 | state.bracedApplicationForbidden << 5 | state.trailingMemberPropertyForbidden << 4 | state.newlineBinaryOpForbidden << 3 | // This is slightly different than the rest of the state,
-      // since it is affected by the directive prologue and may be hit
-      // by the EOL rule early in the parse. Later if we wanted to
-      // allow block scoping of the compat directives we would need to
-      // add them all here.
-      config.coffeeComment << 2;
-      return [stateInt, state.currentJSXTag];
-    }
-  };
 });
 function Reset(ctx, state2) {
   return (0, import_lib3.$EVENT)(ctx, state2, "Reset", Reset$0);
@@ -17908,6 +18073,15 @@ Object.defineProperties(state, {
     }
   }
 });
+function getStateKey() {
+  const stateInt = state.currentIndent.level % 256 << 8 | state.classImplicitCallForbidden << 7 | state.indentedApplicationForbidden << 6 | state.bracedApplicationForbidden << 5 | state.trailingMemberPropertyForbidden << 4 | state.newlineBinaryOpForbidden << 3 | // This is slightly different than the rest of the state,
+  // since it is affected by the directive prologue and may be hit
+  // by the EOL rule early in the parse. Later if we wanted to
+  // allow block scoping of the compat directives we would need to
+  // add them all here.
+  config.coffeeComment << 2;
+  return [stateInt, state.currentJSXTag];
+}
 function parseProgram(input, options) {
   filename = options?.filename;
   initialConfig = options?.parseOptions;
@@ -18134,7 +18308,11 @@ var encodeBase64 = function(value) {
   })();
 };
 var base64Encode = function(src) {
-  return Buffer.from(src).toString("base64");
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(src).toString("base64");
+  } else {
+    return btoa(src);
+  }
 };
 var vlqTable = new Uint8Array(128);
 var vlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -18438,7 +18616,6 @@ var makeCache = function({ hits, trace } = {}) {
     meta.logs = logs;
   }
   const stateCache = new StateCache();
-  let getStateKey = null;
   const stack = [];
   const events = {
     meta,
@@ -18467,14 +18644,12 @@ var makeCache = function({ hits, trace } = {}) {
       return;
     },
     exit: function(ruleName, state2, result) {
-      if (ruleName === "Reset") {
-        ({ getStateKey } = result.value);
-      }
-      if (!uncacheable.has(ruleName)) {
-        const [stateKey, tagKey] = getStateKey();
-        const key = [tagKey, stateKey, state2.pos, ruleName];
-        stateCache.set(key, result);
+      if (uncacheable.has(ruleName)) {
+        return;
       }
+      const [stateKey, tagKey] = getStateKey();
+      const key = [tagKey, stateKey, state2.pos, ruleName];
+      stateCache.set(key, result);
       if (getConfig().verbose && result) {
         console.log(`Parsed ${JSON.stringify(state2.input.slice(state2.pos, result.pos))} [pos ${state2.pos}-${result.pos}] as ${ruleName}`);
       }